fujin/Applied-Energistics-2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor pattern encoding terminals

Browse Source
This commit is contained in:
PrototypeTrousers
2022-10-18 20:48:20 -03:00
parent 4f5bdfefe8
commit b443f1ce57
8 changed files with 756 additions and 1118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/appeng/container/implementations/ContainerExpandedProcessingPatternTerm.java
+12 -404
View File
@@ -1,55 +1,33 @@
package appeng.container.implementations;
import appeng.api.AEApi;
import appeng.api.definitions.IDefinitions;
import appeng.api.storage.ITerminalHost;
import appeng.container.slot.*;
import appeng.helpers.IContainerCraftingPacket;
import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
import appeng.util.Platform;
import appeng.util.inv.IAEAppEngInventory;
import appeng.util.inv.InvOperation;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import appeng.container.slot.OptionalSlotFake;
import appeng.container.slot.SlotFakeCraftingMatrix;
import appeng.container.slot.SlotPatternOutputs;
import appeng.container.slot.SlotRestrictedInput;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.IContainerListener;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.wrapper.PlayerInvWrapper;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import static appeng.helpers.PatternHelper.PROCESSING_INPUT_LIMIT;
import static appeng.helpers.PatternHelper.PROCESSING_OUTPUT_LIMIT;
public class ContainerExpandedProcessingPatternTerm extends ContainerMEMonitorable implements IAEAppEngInventory, IOptionalSlotHost, IContainerCraftingPacket {
private final IItemHandler crafting;
private final SlotFakeCraftingMatrix[] gridSlots = new SlotFakeCraftingMatrix[PROCESSING_INPUT_LIMIT];
private final OptionalSlotFake[] outputSlots = new OptionalSlotFake[PROCESSING_OUTPUT_LIMIT];
private final SlotRestrictedInput patternSlotIN;
private final SlotRestrictedInput patternSlotOUT;
private final PartExpandedProcessingPatternTerminal expandedProcessingPatternTerminal;
public class ContainerExpandedProcessingPatternTerm extends ContainerPatternEncoder {
public ContainerExpandedProcessingPatternTerm(InventoryPlayer ip, ITerminalHost monitorable) {
super(ip, monitorable, false);
this.expandedProcessingPatternTerminal = (PartExpandedProcessingPatternTerminal) monitorable;
this.craftingSlots = new SlotFakeCraftingMatrix[PROCESSING_INPUT_LIMIT];
this.outputSlots = new OptionalSlotFake[PROCESSING_OUTPUT_LIMIT];
final IItemHandler patternInv = this.getExpandedPatternTerminal().getInventoryByName("pattern");
final IItemHandler output = this.getExpandedPatternTerminal().getInventoryByName("output");
final IItemHandler patternInv = this.getPart().getInventoryByName("pattern");
final IItemHandler output = this.getPart().getInventoryByName("output");
this.crafting = this.getExpandedPatternTerminal().getInventoryByName("crafting");
this.crafting = this.getPart().getInventoryByName("crafting");
for (int y = 0; y < 4; y++) {
for (int x = 0; x < 4; x++) {
this.addSlotToContainer(this.gridSlots[x + y * 4] = new SlotFakeCraftingMatrix(this.crafting, x + y * 4, 4 + x * 18, -85 + y * 18));
this.addSlotToContainer(this.craftingSlots[x + y * 4] = new SlotFakeCraftingMatrix(this.crafting, x + y * 4, 4 + x * 18, -85 + y * 18));
}
}
@@ -67,124 +45,7 @@ public class ContainerExpandedProcessingPatternTerm extends ContainerMEMonitorab
this.patternSlotOUT.setStackLimit(1);
this.bindPlayerInventory(ip, 0, 0);
}
@Override
public ItemStack transferStackInSlot(final EntityPlayer p, final int idx) {
if (Platform.isClient()) {
return ItemStack.EMPTY;
}
if (this.inventorySlots.get(idx) instanceof SlotPlayerInv || this.inventorySlots.get(idx) instanceof SlotPlayerHotBar) {
final AppEngSlot clickSlot = (AppEngSlot) this.inventorySlots.get(idx); // require AE SLots!
ItemStack itemStack = clickSlot.getStack();
if (AEApi.instance().definitions().materials().blankPattern().isSameAs(itemStack)) {
IItemHandler patternInv = this.getExpandedPatternTerminal().getInventoryByName("pattern");
ItemStack remainder = patternInv.insertItem(0, itemStack, false);
clickSlot.putStack(remainder);
}
}
return super.transferStackInSlot(p, idx);
}
@Override
public void saveChanges() {
}
@Override
public void onChangeInventory(final IItemHandler inv, final int slot, final InvOperation mc, final ItemStack removedStack, final ItemStack newStack) {
}
public void encodeAndMoveToInventory() {
encode();
ItemStack output = this.patternSlotOUT.getStack();
if (!output.isEmpty()) {
if (!getPlayerInv().addItemStackToInventory(output)) {
getPlayerInv().player.dropItem(output, false);
}
this.patternSlotOUT.putStack(ItemStack.EMPTY);
}
}
public void encode() {
ItemStack output = this.patternSlotOUT.getStack();
final ItemStack[] in = this.getInputs();
final ItemStack[] out = this.getOutputs();
// if there is no input, this would be silly.
if (in == null || out == null) {
return;
}
// first check the output slots, should either be null, or a pattern
if (!output.isEmpty() && !this.isPattern(output)) {
return;
} // if nothing is there we should snag a new pattern.
else if (output.isEmpty()) {
output = this.patternSlotIN.getStack();
if (output.isEmpty() || !this.isPattern(output)) {
return; // no blanks.
}
// remove one, and clear the input slot.
output.setCount(output.getCount() - 1);
if (output.getCount() == 0) {
this.patternSlotIN.putStack(ItemStack.EMPTY);
}
// add a new encoded pattern.
Optional<ItemStack> maybePattern = AEApi.instance().definitions().items().encodedPattern().maybeStack(1);
if (maybePattern.isPresent()) {
output = maybePattern.get();
this.patternSlotOUT.putStack(output);
}
}
// encode the slot.
final NBTTagCompound encodedValue = new NBTTagCompound();
final NBTTagList tagIn = new NBTTagList();
final NBTTagList tagOut = new NBTTagList();
for (final ItemStack i : in) {
tagIn.appendTag(this.createItemTag(i));
}
for (final ItemStack i : out) {
tagOut.appendTag(this.createItemTag(i));
}
encodedValue.setTag("in", tagIn);
encodedValue.setTag("out", tagOut);
encodedValue.setBoolean("crafting", false);
encodedValue.setBoolean("substitute", false);
output.setTagCompound(encodedValue);
}
boolean isPattern(final ItemStack output) {
if (output.isEmpty()) {
return false;
}
final IDefinitions definitions = AEApi.instance().definitions();
boolean isPattern = definitions.items().encodedPattern().isSameAs(output);
isPattern |= definitions.materials().blankPattern().isSameAs(output);
return isPattern;
}
NBTBase createItemTag(final ItemStack i) {
final NBTTagCompound c = new NBTTagCompound();
if (!i.isEmpty()) {
i.writeToNBT(c);
}
return c;
}
@Override
@@ -192,261 +53,8 @@ public class ContainerExpandedProcessingPatternTerm extends ContainerMEMonitorab
return true;
}
protected ItemStack[] getInputs() {
final ItemStack[] input = new ItemStack[16];
boolean hasValue = false;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty()) {
hasValue = true;
}
}
if (hasValue) {
return input;
}
return null;
}
protected ItemStack[] getOutputs() {
final List<ItemStack> list = new ArrayList<>(3);
boolean hasValue = false;
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
if (!out.isEmpty() && out.getCount() > 0) {
list.add(out);
hasValue = true;
}
}
if (hasValue) {
return list.toArray(new ItemStack[0]);
}
return null;
}
public void clear() {
for (final Slot s : this.gridSlots) {
s.putStack(ItemStack.EMPTY);
}
for (final Slot s : this.outputSlots) {
s.putStack(ItemStack.EMPTY);
}
this.detectAndSendChanges();
}
@Override
public IItemHandler getInventoryByName(final String name) {
if (name.equals("player")) {
return new PlayerInvWrapper(this.getInventoryPlayer());
}
return this.getExpandedPatternTerminal().getInventoryByName(name);
}
@Override
public boolean useRealItems() {
public boolean isCraftingMode() {
return false;
}
public PartExpandedProcessingPatternTerminal getExpandedPatternTerminal() {
return this.expandedProcessingPatternTerminal;
}
public void multiply(int multiple) {
ItemStack[] input = new ItemStack[gridSlots.length];
boolean canMultiplyInputs = true;
boolean canMultiplyOutputs = true;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty() && input[x].getCount() * multiple > input[x].getMaxStackSize()) {
canMultiplyInputs = false;
}
}
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
if (!out.isEmpty() && out.getCount() * multiple > out.getMaxStackSize()) {
canMultiplyOutputs = false;
}
}
if (canMultiplyInputs && canMultiplyOutputs) {
for (SlotFakeCraftingMatrix craftingSlot : this.gridSlots) {
ItemStack stack = craftingSlot.getStack();
if (!stack.isEmpty()) {
craftingSlot.getStack().setCount(stack.getCount() * multiple);
}
}
for (OptionalSlotFake outputSlot : this.outputSlots) {
ItemStack stack = outputSlot.getStack();
if (!stack.isEmpty()) {
outputSlot.getStack().setCount(stack.getCount() * multiple);
}
}
}
}
public void divide(int divide) {
ItemStack[] input = new ItemStack[gridSlots.length];
boolean canDivideInputs = true;
boolean canDivideOutputs = true;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty() && input[x].getCount() % divide != 0) {
canDivideInputs = false;
}
}
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
if (!out.isEmpty() && out.getCount() % divide != 0) {
canDivideOutputs = false;
}
}
if (canDivideInputs && canDivideOutputs) {
for (SlotFakeCraftingMatrix craftingSlot : this.gridSlots) {
ItemStack stack = craftingSlot.getStack();
if (!stack.isEmpty()) {
craftingSlot.getStack().setCount(stack.getCount() / divide);
}
}
for (OptionalSlotFake outputSlot : this.outputSlots) {
ItemStack stack = outputSlot.getStack();
if (!stack.isEmpty()) {
outputSlot.getStack().setCount(stack.getCount() / divide);
}
}
}
}
public void increase(int increase) {
ItemStack[] input = new ItemStack[gridSlots.length];
boolean canIncreaseInputs = true;
boolean canIncreaseOutputs = true;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty() && input[x].getCount() + increase > input[x].getMaxStackSize()) {
canIncreaseInputs = false;
}
}
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
if (!out.isEmpty() && out.getCount() + increase > out.getMaxStackSize()) {
canIncreaseOutputs = false;
}
}
if (canIncreaseInputs && canIncreaseOutputs) {
for (SlotFakeCraftingMatrix craftingSlot : this.gridSlots) {
ItemStack stack = craftingSlot.getStack();
if (!stack.isEmpty()) {
craftingSlot.getStack().setCount(stack.getCount() + increase);
}
}
for (OptionalSlotFake outputSlot : this.outputSlots) {
ItemStack stack = outputSlot.getStack();
if (!stack.isEmpty()) {
outputSlot.getStack().setCount(stack.getCount() + increase);
}
}
}
}
public void decrease(int decrease) {
ItemStack[] input = new ItemStack[gridSlots.length];
boolean canDecreaseInputs = true;
boolean canDecreaseOutputs = true;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty() && input[x].getCount() - decrease < 1) {
canDecreaseInputs = false;
}
}
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
if (!out.isEmpty() && out.getCount() - decrease < 1) {
canDecreaseOutputs = false;
}
}
if (canDecreaseInputs && canDecreaseOutputs) {
for (SlotFakeCraftingMatrix craftingSlot : this.gridSlots) {
ItemStack stack = craftingSlot.getStack();
if (!stack.isEmpty()) {
craftingSlot.getStack().setCount(stack.getCount() - decrease);
}
}
for (OptionalSlotFake outputSlot : this.outputSlots) {
ItemStack stack = outputSlot.getStack();
if (!stack.isEmpty()) {
outputSlot.getStack().setCount(stack.getCount() - decrease);
}
}
}
}
public void maximizeCount() {
ItemStack[] input = new ItemStack[gridSlots.length];
boolean canGrowInputs = true;
boolean canGrowOutputs = true;
int maxInputStackGrowth = 0;
int maxOutputStackGrowth = 0;
for (int x = 0; x < this.gridSlots.length; x++) {
input[x] = this.gridSlots[x].getStack();
if (!input[x].isEmpty() && input[x].getMaxStackSize() - input[x].getCount() > maxInputStackGrowth) {
maxInputStackGrowth = input[x].getMaxStackSize() - input[x].getCount();
}
if (!input[x].isEmpty() && input[x].getCount() + maxInputStackGrowth > input[x].getMaxStackSize()) {
canGrowInputs = false;
}
}
for (final OptionalSlotFake outputSlot : this.outputSlots) {
final ItemStack out = outputSlot.getStack();
{
maxOutputStackGrowth = out.getMaxStackSize() - out.getCount();
}
if (!out.isEmpty() && out.getCount() + maxOutputStackGrowth > out.getMaxStackSize()) {
canGrowOutputs = false;
}
}
if (canGrowInputs && canGrowOutputs) {
int maxStackGrowth = Math.min(maxInputStackGrowth, maxOutputStackGrowth);
for (SlotFakeCraftingMatrix craftingSlot : this.gridSlots) {
ItemStack stack = craftingSlot.getStack();
if (!stack.isEmpty()) {
craftingSlot.getStack().setCount(stack.getCount() + maxStackGrowth);
}
}
for (OptionalSlotFake outputSlot : this.outputSlots) {
ItemStack stack = outputSlot.getStack();
if (!stack.isEmpty()) {
outputSlot.getStack().setCount(stack.getCount() + maxStackGrowth);
}
}
}
}
@Override
public void onSlotChange(final Slot s) {
if (s == this.patternSlotOUT && Platform.isServer()) {
for (final IContainerListener listener : this.listeners) {
for (final Slot slot : this.inventorySlots) {
if (slot instanceof OptionalSlotFake || slot instanceof SlotFakeCraftingMatrix) {
listener.sendSlotContents(this, slot.slotNumber, slot.getStack());
}
}
if (listener instanceof EntityPlayerMP) {
((EntityPlayerMP) listener).isChangingQuantityOnly = false;
}
}
this.detectAndSendChanges();
}
}
}