diff options
Diffstat (limited to 'src/main/java/gregtech/api/multitileentity/multiblock/base')
7 files changed, 844 insertions, 2299 deletions
diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/ComplexParallelController.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/ComplexParallelController.java index 808c16a200..cdcb77d6e5 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/ComplexParallelController.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/ComplexParallelController.java @@ -2,7 +2,8 @@ package gregtech.api.multitileentity.multiblock.base; import java.util.ArrayList; import java.util.List; -import java.util.stream.LongStream; + +import javax.annotation.Nonnull; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; @@ -12,206 +13,58 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.StatCollector; import net.minecraft.world.World; -import net.minecraftforge.fluids.FluidStack; -import gregtech.api.enums.GT_Values; import gregtech.api.logic.ComplexParallelProcessingLogic; -import gregtech.api.logic.interfaces.PollutionLogicHost; import gregtech.api.util.GT_Utility; import gregtech.api.util.GT_Waila; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; -public abstract class ComplexParallelController<T extends ComplexParallelController<T>> extends PowerController<T> { +public abstract class ComplexParallelController<C extends ComplexParallelController<C, P>, P extends ComplexParallelProcessingLogic<P>> + extends Controller<C, P> { - protected ComplexParallelProcessingLogic processingLogic; protected int maxComplexParallels = 0; protected int currentComplexParallels = 0; - protected long[] maxProgressTimes = new long[0]; - protected long[] progressTimes = new long[0]; public ComplexParallelController() { isSimpleMachine = false; } - protected void setMaxComplexParallels(int parallel) { - if (parallel != maxComplexParallels) { - if (maxComplexParallels != 0) { - stopMachine(false); - } - maxProgressTimes = new long[parallel]; - progressTimes = new long[parallel]; + protected void setMaxComplexParallels(int parallel, boolean stopMachine) { + if (parallel != maxComplexParallels && maxComplexParallels != 0 && stopMachine) { + stopMachine(false); } maxComplexParallels = parallel; - } - - @Override - protected void runMachine(long tick) { - if (acceptsFuel() && isActive()) { - if (!consumeFuel()) { - stopMachine(true); - return; - } - } - - if (hasThingsToDo()) { - markDirty(); - runningTick(tick); - } - if ((tick % TICKS_BETWEEN_RECIPE_CHECKS == 0 || hasWorkJustBeenEnabled() || hasInventoryBeenModified()) - && maxComplexParallels != currentComplexParallels) { - if (isAllowedToWork() && maxComplexParallels > currentComplexParallels) { - wasEnabled = false; - boolean started = false; - for (int i = 0; i < maxComplexParallels; i++) { - if (maxProgressTimes[i] <= 0 && checkRecipe(i)) { - currentComplexParallels++; - started = true; - } - } - if (started) { - setActive(true); - updateSlots(); - markDirty(); - issueClientUpdate(); - } - } - } - } - - @Override - protected void runningTick(long tick) { - consumeEnergy(); - boolean allStopped = true; - for (int i = 0; i < maxComplexParallels; i++) { - if (maxProgressTimes[i] > 0 && ++progressTimes[i] >= maxProgressTimes[i]) { - progressTimes[i] = 0; - maxProgressTimes[i] = 0; - outputItems(i); - outputFluids(i); - if (isAllowedToWork()) { - if (checkRecipe(i)) { - allStopped = false; - } else { - currentComplexParallels--; - } - } - updateSlots(); - } else if (maxProgressTimes[i] > 0) { - allStopped = false; - } - } - if (allStopped) { - setActive(false); - issueClientUpdate(); - } - - if (this instanceof PollutionLogicHost && tick % POLLUTION_TICK == 0) { - doPollution(); - } - emitEnergy(); - } - - protected boolean checkRecipe(int index) { - ComplexParallelProcessingLogic processingLogic = getComplexProcessingLogic(); - if (processingLogic == null || index < 0 || index >= maxComplexParallels) { - return false; - } - processingLogic.clear(index); - boolean result = processingLogic.setInputItems(index, getInputItems(index)) - .setInputFluids(index, getInputFluids(index)) - .setTileEntity(this) - .setVoidProtection(index, isVoidProtectionEnabledForItem(index), isVoidProtectionEnabledForFluid(index)) - .setEut(index, getEutForComplexParallel(index)) - .setPerfectOverclock(hasPerfectOverclock()) - .process(index); - setDuration(index, processingLogic.getDuration(index)); - setEut(processingLogic.getTotalEU()); - return result; - } - - protected void outputItems(int index) { - ComplexParallelProcessingLogic processingLogic = getComplexProcessingLogic(); - if (processingLogic != null && index >= 0 && index < maxComplexParallels) { - outputItems(processingLogic.getOutputItems(index)); - } - } - - protected void outputFluids(int index) { - ComplexParallelProcessingLogic processingLogic = getComplexProcessingLogic(); - if (processingLogic != null && index >= 0 && index < maxComplexParallels) { - outputFluids(processingLogic.getOutputFluids(index)); - } - } - - protected ComplexParallelProcessingLogic getComplexProcessingLogic() { - return processingLogic; - } - - @Override - public boolean hasThingsToDo() { - return LongStream.of(maxProgressTimes) - .sum() > 0; + setProcessingUpdate(true); } @Override protected void stopMachine(boolean powerShutDown) { super.stopMachine(powerShutDown); - for (int i = 0; i < maxComplexParallels; i++) { - maxProgressTimes[i] = 0; - } - } - - protected void setDuration(int index, long duration) { - if (duration < 0) { - duration = -duration; - } - if (index >= 0 && index < maxComplexParallels) { - maxProgressTimes[index] = duration; - } - } - - protected ItemStack[] getInputItems(int index) { - return getInputItems(); - } - - protected FluidStack[] getInputFluids(int index) { - return getInputFluids(); - } - - protected boolean isVoidProtectionEnabledForItem(int index) { - return protectsExcessItem(); - } - - protected boolean isVoidProtectionEnabledForFluid(int index) { - return protectsExcessFluid(); } protected boolean hasPerfectOverclock() { return false; } - protected long getEutForComplexParallel(int index) { - // As default behavior we'll give the parallel all remaining EU we have - return GT_Values.V[tier] - eut; - } - @Override protected void addProgressStringToScanner(EntityPlayer player, int logLevel, ArrayList<String> list) { + P processing = getProcessingLogic(); for (int i = 0; i < maxComplexParallels; i++) { list.add( StatCollector.translateToLocal("GT5U.multiblock.Progress") + " " + (i + 1) + ": " + EnumChatFormatting.GREEN - + GT_Utility.formatNumbers(progressTimes[i] > 20 ? progressTimes[i] / 20 : progressTimes[i]) + + GT_Utility.formatNumbers( + processing.getProgress(i) > 20 ? processing.getProgress(i) / 20 : processing.getProgress(i)) + EnumChatFormatting.RESET - + (progressTimes[i] > 20 ? " s / " : " ticks / ") + + (processing.getProgress(i) > 20 ? " s / " : " ticks / ") + EnumChatFormatting.YELLOW - + GT_Utility - .formatNumbers(maxProgressTimes[i] > 20 ? maxProgressTimes[i] / 20 : maxProgressTimes[i]) + + GT_Utility.formatNumbers( + processing.getDuration(i) > 20 ? processing.getDuration(i) / 20 : processing.getDuration(i)) + EnumChatFormatting.RESET - + (maxProgressTimes[i] > 20 ? " s" : " ticks")); + + (processing.getDuration(i) > 20 ? " s" : " ticks")); } } @@ -219,10 +72,11 @@ public abstract class ComplexParallelController<T extends ComplexParallelControl public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y, int z) { super.getWailaNBTData(player, tile, tag, world, x, y, z); + P processing = getProcessingLogic(); tag.setInteger("maxComplexParallels", maxComplexParallels); for (int i = 0; i < maxComplexParallels; i++) { - tag.setLong("maxProgress" + i, maxProgressTimes[i]); - tag.setLong("progress" + i, progressTimes[i]); + tag.setInteger("maxProgress" + i, processing.getDuration(i)); + tag.setInteger("progress" + i, processing.getProgress(i)); } } @@ -233,8 +87,8 @@ public abstract class ComplexParallelController<T extends ComplexParallelControl final NBTTagCompound tag = accessor.getNBTData(); maxComplexParallels = tag.getInteger("maxComplexParallels"); for (int i = 0; i < maxComplexParallels; i++) { - long maxProgress = tag.getLong("maxProgress" + i); - long progress = tag.getLong("progress" + i); + long maxProgress = tag.getInteger("maxProgress" + i); + long progress = tag.getInteger("progress" + i); currentTip.add( "Process " + (i + 1) + ": " @@ -242,4 +96,16 @@ public abstract class ComplexParallelController<T extends ComplexParallelControl .getMachineProgressString(maxProgress > 0 && maxProgress >= progress, maxProgress, progress)); } } + + @Override + public void setProcessingLogicPower(@Nonnull P processingLogic) { + processingLogic.setAmperageOC(true); + processingLogic.setAvailableAmperage(getPowerLogic().getMaxAmperage() / maxComplexParallels); + processingLogic.setAvailableVoltage(getPowerLogic().getVoltage() / maxComplexParallels); + } + + @Override + public void updateProcessingLogic(@Nonnull P processingLogic) { + processingLogic.setMaxComplexParallel(maxComplexParallels); + } } diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java index 606d957fd6..8ac908be12 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java @@ -1,261 +1,109 @@ package gregtech.api.multitileentity.multiblock.base; -import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; -import static gregtech.GT_Mod.GT_FML_LOGGER; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.EV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.HV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.IV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.LuV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MAX_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.MV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UEV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UHV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UIV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UMV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.UXV_Sensor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Conveyor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Emitter; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_FieldGenerator; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Motor; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Piston; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Pump; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_RobotArm; -import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.ZPM_Sensor; -import static gregtech.loaders.preload.GT_Loader_MultiTileEntities.COMPONENT_CASING_REGISTRY_NAME; -import static mcp.mobius.waila.api.SpecialChars.GREEN; -import static mcp.mobius.waila.api.SpecialChars.RED; -import static mcp.mobius.waila.api.SpecialChars.RESET; +import static gregtech.api.util.GT_Utility.moveMultipleItemStacks; +import static gregtech.common.misc.WirelessNetworkManager.strongCheckOrAddUser; +import static mcp.mobius.waila.api.SpecialChars.*; import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; -import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; -import net.minecraft.block.Block; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.nbt.NBTTagList; import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; import net.minecraft.world.World; -import net.minecraftforge.common.util.Constants; import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.FluidTankInfo; -import net.minecraftforge.fluids.IFluidTank; -import org.apache.commons.lang3.tuple.ImmutablePair; -import org.apache.commons.lang3.tuple.Pair; import org.lwjgl.input.Keyboard; import com.gtnewhorizon.structurelib.StructureLibAPI; import com.gtnewhorizon.structurelib.alignment.IAlignment; import com.gtnewhorizon.structurelib.alignment.IAlignmentLimits; -import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing; import com.gtnewhorizon.structurelib.alignment.enumerable.Flip; import com.gtnewhorizon.structurelib.alignment.enumerable.Rotation; import com.gtnewhorizon.structurelib.structure.IStructureDefinition; -import com.gtnewhorizon.structurelib.structure.IStructureElement; -import com.gtnewhorizon.structurelib.structure.IStructureElementChain; import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; import com.gtnewhorizon.structurelib.util.Vec3Impl; -import com.gtnewhorizons.modularui.api.ModularUITextures; -import com.gtnewhorizons.modularui.api.drawable.ItemDrawable; -import com.gtnewhorizons.modularui.api.forge.IItemHandler; -import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable; -import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; -import com.gtnewhorizons.modularui.api.forge.ListItemHandler; -import com.gtnewhorizons.modularui.api.math.Pos2d; import com.gtnewhorizons.modularui.api.screen.ModularWindow; -import com.gtnewhorizons.modularui.api.screen.UIBuildContext; -import com.gtnewhorizons.modularui.api.widget.IWidgetBuilder; -import com.gtnewhorizons.modularui.api.widget.Widget; -import com.gtnewhorizons.modularui.common.widget.DrawableWidget; -import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; -import com.gtnewhorizons.modularui.common.widget.MultiChildWidget; -import com.gtnewhorizons.modularui.common.widget.Scrollable; -import com.gtnewhorizons.modularui.common.widget.SlotWidget; -import com.gtnewhorizons.modularui.common.widget.TabButton; -import com.gtnewhorizons.modularui.common.widget.TabContainer; import cpw.mods.fml.common.network.NetworkRegistry; -import gnu.trove.list.TIntList; -import gnu.trove.list.array.TIntArrayList; -import gregtech.api.enums.GT_Values; import gregtech.api.enums.GT_Values.NBT; -import gregtech.api.enums.OrePrefixes; -import gregtech.api.enums.TextureSet; +import gregtech.api.enums.InventoryType; import gregtech.api.enums.VoidingMode; -import gregtech.api.fluid.FluidTankGT; -import gregtech.api.gui.modularui.GT_UITextures; import gregtech.api.interfaces.IDescribable; import gregtech.api.interfaces.fluid.IFluidStore; -import gregtech.api.interfaces.modularui.ControllerWithOptionalFeatures; +import gregtech.api.logic.ControllerFluidLogic; +import gregtech.api.logic.ControllerItemLogic; +import gregtech.api.logic.FluidInventoryLogic; +import gregtech.api.logic.ItemInventoryLogic; +import gregtech.api.logic.MuTEProcessingLogic; import gregtech.api.logic.PowerLogic; -import gregtech.api.logic.ProcessingLogic; -import gregtech.api.logic.interfaces.PowerLogicHost; -import gregtech.api.logic.interfaces.ProcessingLogicHost; -import gregtech.api.multitileentity.MultiTileEntityContainer; -import gregtech.api.multitileentity.MultiTileEntityRegistry; +import gregtech.api.multitileentity.enums.MultiTileCasingPurpose; import gregtech.api.multitileentity.interfaces.IMultiBlockController; import gregtech.api.multitileentity.interfaces.IMultiBlockPart; -import gregtech.api.multitileentity.interfaces.IMultiTileEntity; import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_AddToolTips; import gregtech.api.multitileentity.machine.MultiTileBasicMachine; import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; import gregtech.api.multitileentity.multiblock.casing.UpgradeCasing; +import gregtech.api.net.GT_Packet_MultiTileEntity; import gregtech.api.objects.GT_ItemStack; -import gregtech.api.recipe.RecipeMap; -import gregtech.api.recipe.check.CheckRecipeResult; -import gregtech.api.recipe.check.CheckRecipeResultRegistry; import gregtech.api.util.GT_Multiblock_Tooltip_Builder; import gregtech.api.util.GT_Utility; import gregtech.api.util.GT_Waila; -import gregtech.common.tileentities.casings.upgrade.Inventory; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; /** * Multi Tile Entities - or MuTEs - don't have dedicated hatches, but their casings can become hatches. */ -public abstract class Controller<T extends Controller<T>> extends MultiTileBasicMachine - implements IAlignment, IConstructable, IMultiBlockController, IDescribable, IMTE_AddToolTips, - ISurvivalConstructable, ControllerWithOptionalFeatures { +public abstract class Controller<C extends Controller<C, P>, P extends MuTEProcessingLogic<P>> + extends MultiTileBasicMachine<P> + implements IAlignment, IMultiBlockController, IDescribable, IMTE_AddToolTips, ISurvivalConstructable { public static final String ALL_INVENTORIES_NAME = "all"; + protected static final int AUTO_OUTPUT_FREQUENCY_TICK = 20; private static final Map<Integer, GT_Multiblock_Tooltip_Builder> tooltip = new ConcurrentHashMap<>(); private final List<UpgradeCasing> upgradeCasings = new ArrayList<>(); private final List<FunctionalCasing> functionalCasings = new ArrayList<>(); protected BuildState buildState = new BuildState(); - protected Map<String, String> multiBlockInputInventoryNames = new LinkedHashMap<>(); - protected Map<String, String> multiBlockOutputInventoryNames = new LinkedHashMap<>(); - protected Map<String, String> multiBlockInputInventoryToTankLink = new LinkedHashMap<>(); - protected Map<String, IItemHandlerModifiable> multiBlockInputInventory = new LinkedHashMap<>(); - protected Map<String, IItemHandlerModifiable> multiBlockOutputInventory = new LinkedHashMap<>(); - - protected Map<String, String> multiBlockInputTankNames = new LinkedHashMap<>(); - protected Map<String, String> multiBlockOutputTankNames = new LinkedHashMap<>(); - protected Map<String, FluidTankGT[]> multiBlockInputTank = new LinkedHashMap<>(); - protected Map<String, FluidTankGT[]> multiBlockOutputTank = new LinkedHashMap<>(); - private boolean structureOkay = false, structureChanged = false; private ExtendedFacing extendedFacing = ExtendedFacing.DEFAULT; private IAlignmentLimits limits = getInitialAlignmentLimits(); - private String inventoryName; - private String tankName; protected boolean separateInputs = getDefaultInputSeparationMode(); protected VoidingMode voidingMode = getDefaultVoidingMode(); protected boolean batchMode = getDefaultBatchMode(); protected boolean recipeLock = getDefaultRecipeLockingMode(); + protected boolean shouldSort = false; /** If this is set to true, the machine will get default WAILA behavior */ protected boolean isSimpleMachine = true; + protected boolean isCleanroom = false; + protected ControllerItemLogic controllerItemInput = new ControllerItemLogic(); + protected ControllerItemLogic controllerItemOutput = new ControllerItemLogic(); + protected ControllerFluidLogic controllerFluidInput = new ControllerFluidLogic(); + protected ControllerFluidLogic controllerFluidOutput = new ControllerFluidLogic(); + // A list of sides // Each side has a list of parts that have a cover that need to be ticked protected List<LinkedList<WeakReference<IMultiBlockPart>>> registeredCoveredParts = Arrays.asList( @@ -266,6 +114,15 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic new LinkedList<>(), new LinkedList<>()); + // A list for each purpose that a casing can register to, to be ticked + protected List<LinkedList<WeakReference<IMultiBlockPart>>> registeredTickableParts = new ArrayList<>(); + + public Controller() { + for (int i = 0; i < MultiTileCasingPurpose.values().length; i++) { + registeredTickableParts.add(new LinkedList<>()); + } + } + /** Registry ID of the required casing */ public abstract short getCasingRegistryID(); @@ -288,7 +145,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic * other instances, even for those of the same class. */ @Override - public abstract IStructureDefinition<T> getStructureDefinition(); + public abstract IStructureDefinition<C> getStructureDefinition(); /** * Checks the Machine. @@ -296,16 +153,20 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic * NOTE: If using `buildState` be sure to `startBuilding()` and either `endBuilding()` or `failBuilding()` */ public boolean checkMachine() { + calculateTier(); + updatePowerLogic(); + return tier > 0; + } + + protected void calculateTier() { double sum = 0; if (functionalCasings == null || functionalCasings.size() == 0) { - return false; + return; } for (FunctionalCasing casing : functionalCasings) { sum += casing.getPartTier() * casing.getPartModifier(); } - tier = (int) Math.floor(sum / functionalCasings.size()); - // Maximum Energy stores will have a cap of 2 minute work time of current voltage - return tier > 0; + tier = (int) Math.min(Math.floor(sum / functionalCasings.size()), 14); } @Override @@ -322,77 +183,26 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic (byte) extendedFacing.getFlip() .getIndex()); - saveUpgradeInventoriesToNBT(nbt); - saveUpgradeTanksToNBT(nbt); - nbt.setString(NBT.VOIDING_MODE, voidingMode.name); nbt.setBoolean(NBT.SEPARATE_INPUTS, separateInputs); nbt.setBoolean(NBT.RECIPE_LOCK, recipeLock); nbt.setBoolean(NBT.BATCH_MODE, batchMode); } - private void saveUpgradeInventoriesToNBT(NBTTagCompound nbt) { - final NBTTagList inputInvList = new NBTTagList(); - multiBlockInputInventory.forEach((id, inv) -> { - if (!id.equals("controller")) { - final NBTTagCompound tTag = new NBTTagCompound(); - tTag.setString(NBT.UPGRADE_INVENTORY_UUID, id); - tTag.setString(NBT.UPGRADE_INVENTORY_NAME, multiBlockInputInventoryNames.get(id)); - tTag.setInteger(NBT.UPGRADE_INVENTORY_SIZE, inv.getSlots()); - writeInventory(tTag, inv, NBT.INV_INPUT_LIST); - inputInvList.appendTag(tTag); - } - }); - final NBTTagList outputInvList = new NBTTagList(); - multiBlockOutputInventory.forEach((id, inv) -> { - if (!id.equals("controller")) { - final NBTTagCompound tTag = new NBTTagCompound(); - tTag.setString(NBT.UPGRADE_INVENTORY_UUID, id); - tTag.setString(NBT.UPGRADE_INVENTORY_NAME, multiBlockOutputInventoryNames.get(id)); - tTag.setInteger(NBT.UPGRADE_INVENTORY_SIZE, inv.getSlots()); - writeInventory(tTag, inv, NBT.INV_OUTPUT_LIST); - outputInvList.appendTag(tTag); - } - }); - nbt.setTag(NBT.UPGRADE_INVENTORIES_INPUT, inputInvList); - nbt.setTag(NBT.UPGRADE_INVENTORIES_OUTPUT, outputInvList); - } - - private void saveUpgradeTanksToNBT(NBTTagCompound nbt) { - final NBTTagList inputTankList = new NBTTagList(); - multiBlockInputTank.forEach((id, tanks) -> { - if (!id.equals("controller") && tanks != null && tanks.length > 0) { - final NBTTagCompound tTag = new NBTTagCompound(); - tTag.setString(NBT.UPGRADE_TANK_UUID, id); - tTag.setString(NBT.UPGRADE_TANK_NAME, multiBlockInputTankNames.get(id)); - // We assume all tanks in the tank-array are equally sized - tTag.setLong(NBT.UPGRADE_TANK_CAPACITY, tanks[0].capacity()); - tTag.setLong(NBT.UPGRADE_TANK_CAPACITY_MULTIPLIER, tanks[0].getCapacityMultiplier()); - tTag.setInteger(NBT.UPGRADE_TANKS_COUNT, tanks.length); - for (int i = 0; i < tanks.length; i++) { - tanks[i].writeToNBT(tTag, NBT.UPGRADE_TANKS_PREFIX + i); - } - inputTankList.appendTag(tTag); - } - }); - final NBTTagList outputTankList = new NBTTagList(); - multiBlockOutputTank.forEach((id, tanks) -> { - if (!id.equals("controller") && tanks != null && tanks.length > 0) { - final NBTTagCompound tTag = new NBTTagCompound(); - tTag.setString(NBT.UPGRADE_TANK_UUID, id); - tTag.setString(NBT.UPGRADE_TANK_NAME, multiBlockInputTankNames.get(id)); - // We assume all tanks in the tank-array are equally sized - tTag.setLong(NBT.UPGRADE_TANK_CAPACITY, tanks[0].capacity()); - tTag.setLong(NBT.UPGRADE_TANK_CAPACITY_MULTIPLIER, tanks[0].getCapacityMultiplier()); - tTag.setInteger(NBT.UPGRADE_TANKS_COUNT, tanks.length); - for (int i = 0; i < tanks.length; i++) { - tanks[i].writeToNBT(tTag, NBT.UPGRADE_TANKS_PREFIX + i); - } - outputTankList.appendTag(tTag); - } - }); - nbt.setTag(NBT.UPGRADE_TANKS_INPUT, inputTankList); - nbt.setTag(NBT.UPGRADE_TANKS_OUTPUT, outputTankList); + @Override + protected void saveItemLogic(NBTTagCompound nbt) { + NBTTagCompound itemInputNBT = controllerItemInput.saveToNBT(); + nbt.setTag(NBT.INV_INPUT_LIST, itemInputNBT); + NBTTagCompound itemOutputNBT = controllerItemOutput.saveToNBT(); + nbt.setTag(NBT.INV_OUTPUT_LIST, itemOutputNBT); + } + + @Override + protected void saveFluidLogic(NBTTagCompound nbt) { + NBTTagCompound fluidInputNBT = controllerFluidInput.saveToNBT(); + nbt.setTag(NBT.TANK_IN, fluidInputNBT); + NBTTagCompound fluidOutputNBT = controllerFluidOutput.saveToNBT(); + nbt.setTag(NBT.TANK_OUT, fluidOutputNBT); } @Override @@ -401,83 +211,37 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic // Multiblock inventories are a collection of inventories. The first inventory is the default internal // inventory, and the others are added by inventory extending blocks. - if (inputInventory != null) registerInventory("controller", "controller", inputInventory, Inventory.INPUT); - if (outputInventory != null) registerInventory("controller", "controller", outputInventory, Inventory.OUTPUT); - - if (inputTanks != null) registerFluidInventory("controller", "controller", inputTanks, Inventory.INPUT); - if (outputTanks != null) registerFluidInventory("controller", "controller", outputTanks, Inventory.OUTPUT); structureOkay = nbt.getBoolean(NBT.STRUCTURE_OK); extendedFacing = ExtendedFacing .of(getFrontFacing(), Rotation.byIndex(nbt.getByte(NBT.ROTATION)), Flip.byIndex(nbt.getByte(NBT.FLIP))); - loadUpgradeInventoriesFromNBT(nbt); - loadUpgradeTanksFromNBT(nbt); - voidingMode = VoidingMode.fromName(nbt.getString(NBT.VOIDING_MODE)); separateInputs = nbt.getBoolean(NBT.SEPARATE_INPUTS); recipeLock = nbt.getBoolean(NBT.RECIPE_LOCK); batchMode = nbt.getBoolean(NBT.BATCH_MODE); } - private void loadUpgradeInventoriesFromNBT(NBTTagCompound nbt) { - final NBTTagList listInputInventories = nbt - .getTagList(NBT.UPGRADE_INVENTORIES_INPUT, Constants.NBT.TAG_COMPOUND); - for (int i = 0; i < listInputInventories.tagCount(); i++) { - final NBTTagCompound nbtInv = listInputInventories.getCompoundTagAt(i); - final String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); - final String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); - final int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); - final IItemHandlerModifiable inv = new ItemStackHandler(invSize); - loadInventory(nbtInv, inv, NBT.INV_INPUT_LIST); - registerInventory(invName, invUUID, invSize, Inventory.INPUT); - } - - final NBTTagList listOutputInventories = nbt - .getTagList(NBT.UPGRADE_INVENTORIES_OUTPUT, Constants.NBT.TAG_COMPOUND); - for (int i = 0; i < listOutputInventories.tagCount(); i++) { - final NBTTagCompound nbtInv = listOutputInventories.getCompoundTagAt(i); - final String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); - final String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); - final int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); - IItemHandlerModifiable inv = new ItemStackHandler(invSize); - loadInventory(nbtInv, inv, NBT.INV_OUTPUT_LIST); - registerInventory(invName, invUUID, invSize, Inventory.OUTPUT); + @Override + protected void loadItemLogic(NBTTagCompound nbt) { + if (!nbt.hasKey(NBT.INV_INPUT_LIST) && !nbt.hasKey(NBT.INV_OUTPUT_LIST)) { + controllerItemInput.addInventory(new ItemInventoryLogic(16)); + controllerItemOutput.addInventory(new ItemInventoryLogic(16)); + return; } + controllerItemInput.loadFromNBT(nbt.getCompoundTag(NBT.INV_INPUT_LIST)); + controllerItemOutput.loadFromNBT(nbt.getCompoundTag(NBT.INV_OUTPUT_LIST)); } - private void loadUpgradeTanksFromNBT(NBTTagCompound nbt) { - final NBTTagList listInputTanks = nbt.getTagList(NBT.UPGRADE_TANKS_INPUT, Constants.NBT.TAG_COMPOUND); - for (int i = 0; i < listInputTanks.tagCount(); i++) { - final NBTTagCompound nbtTank = listInputTanks.getCompoundTagAt(i); - String tankUUID = nbtTank.getString(NBT.UPGRADE_TANK_UUID); - String tankName = nbtTank.getString(NBT.UPGRADE_TANK_NAME); - long capacity = nbtTank.getLong(NBT.UPGRADE_TANK_CAPACITY); - long capacityMultiplier = nbtTank.getLong(NBT.UPGRADE_TANK_CAPACITY_MULTIPLIER); - int count = nbtTank.getInteger(NBT.UPGRADE_TANKS_COUNT); - FluidTankGT[] tanks = new FluidTankGT[count]; - for (int j = 0; j < count; j++) { - tanks[j] = new FluidTankGT(capacity).setCapacityMultiplier(capacityMultiplier) - .readFromNBT(nbtTank, NBT.UPGRADE_TANKS_PREFIX + j); - } - registerFluidInventory(tankName, tankUUID, count, capacity, capacityMultiplier, Inventory.INPUT); - } - - final NBTTagList listOutputTanks = nbt.getTagList(NBT.UPGRADE_TANKS_OUTPUT, Constants.NBT.TAG_COMPOUND); - for (int i = 0; i < listOutputTanks.tagCount(); i++) { - final NBTTagCompound nbtTank = listOutputTanks.getCompoundTagAt(i); - String tankUUID = nbtTank.getString(NBT.UPGRADE_TANK_UUID); - String tankName = nbtTank.getString(NBT.UPGRADE_TANK_NAME); - long capacity = nbtTank.getLong(NBT.UPGRADE_TANK_CAPACITY); - long capacityMultiplier = nbtTank.getLong(NBT.UPGRADE_TANK_CAPACITY_MULTIPLIER); - int count = nbtTank.getInteger(NBT.UPGRADE_TANKS_COUNT); - FluidTankGT[] tanks = new FluidTankGT[count]; - for (int j = 0; j < count; j++) { - tanks[j] = new FluidTankGT(capacity).setCapacityMultiplier(capacityMultiplier) - .readFromNBT(nbtTank, NBT.UPGRADE_TANKS_PREFIX + j); - } - registerFluidInventory(tankName, tankUUID, count, capacity, capacityMultiplier, Inventory.OUTPUT); + @Override + protected void loadFluidLogic(NBTTagCompound nbt) { + if (!nbt.hasKey(NBT.TANK_IN) && !nbt.hasKey(NBT.TANK_OUT)) { + controllerFluidInput.addInventory(new FluidInventoryLogic(16, 32000)); + controllerFluidOutput.addInventory(new FluidInventoryLogic(16, 32000)); + return; } + controllerFluidInput.loadFromNBT(nbt.getCompoundTag(NBT.TANK_IN)); + controllerFluidOutput.loadFromNBT(nbt.getCompoundTag(NBT.TANK_OUT)); } @Override @@ -489,9 +253,9 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic public String[] getDescription() { if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { return getTooltip().getStructureInformation(); - } else { - return getTooltip().getInformation(); } + + return getTooltip().getInformation(); } @Override @@ -519,6 +283,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic // Only trigger an update if forced (from onPostTick, generally), or if the structure has changed if ((structureChanged || aForceReset)) { + clearSpecialLists(); structureOkay = checkMachine(); } structureChanged = false; @@ -531,8 +296,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } public final boolean checkPiece(String piece, Vec3Impl offset) { - functionalCasings.clear(); - upgradeCasings.clear(); return checkPiece(piece, offset.get0(), offset.get1(), offset.get2()); } @@ -617,8 +380,8 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @SuppressWarnings("unchecked") - private IStructureDefinition<Controller<T>> getCastedStructureDefinition() { - return (IStructureDefinition<Controller<T>>) getStructureDefinition(); + private IStructureDefinition<Controller<C, P>> getCastedStructureDefinition() { + return (IStructureDefinition<Controller<C, P>>) getStructureDefinition(); } @Override @@ -628,24 +391,27 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public void setExtendedFacing(ExtendedFacing newExtendedFacing) { - if (extendedFacing != newExtendedFacing) { - onStructureChange(); - if (structureOkay) stopMachine(false); - extendedFacing = newExtendedFacing; - structureOkay = false; - if (isServerSide()) { - StructureLibAPI.sendAlignment( - this, - new NetworkRegistry.TargetPoint( - getWorld().provider.dimensionId, - getXCoord(), - getYCoord(), - getZCoord(), - 512)); - } else { - issueTextureUpdate(); - } + if (extendedFacing == newExtendedFacing) { + return; + } + + onStructureChange(); + if (structureOkay) stopMachine(false); + extendedFacing = newExtendedFacing; + structureOkay = false; + if (isServerSide()) { + StructureLibAPI.sendAlignment( + this, + new NetworkRegistry.TargetPoint( + getWorld().provider.dimensionId, + getXCoord(), + getYCoord(), + getZCoord(), + 512)); + } else { + issueTextureUpdate(); } + } @Override @@ -686,6 +452,31 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override + public void registerCaseWithPurpose(MultiTileCasingPurpose purpose, IMultiBlockPart part) { + final LinkedList<WeakReference<IMultiBlockPart>> tickableParts = registeredTickableParts.get(purpose.ordinal()); + final Iterator<WeakReference<IMultiBlockPart>> it = tickableParts.iterator(); + while (it.hasNext()) { + final IMultiBlockPart next = (it.next()).get(); + if (next == null) { + it.remove(); + } else if (next == part) { + return; + } + } + tickableParts.add(new WeakReference<>(part)); + } + + @Override + public void unregisterCaseWithPurpose(MultiTileCasingPurpose purpose, IMultiBlockPart part) { + final LinkedList<WeakReference<IMultiBlockPart>> tickableParts = registeredTickableParts.get(purpose.ordinal()); + final Iterator<WeakReference<IMultiBlockPart>> it = tickableParts.iterator(); + while (it.hasNext()) { + final IMultiBlockPart next = (it.next()).get(); + if (next == null || next == part) it.remove(); + } + } + + @Override public void onFirstTick(boolean isServerSide) { super.onFirstTick(isServerSide); if (isServerSide) { @@ -715,7 +506,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public void onTick(long timer, boolean isServerSide) { + public void onTick(long tick, boolean isServerSide) { if (!tickCovers()) { return; } @@ -723,24 +514,94 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public void onPostTick(long tick, boolean isServerSide) { - if (isServerSide) { - if (tick % 600 == 5) { - clearSpecialLists(); - // Recheck the structure every 30 seconds or so - if (!checkStructure(false)) checkStructure(true); + if (!isServerSide) { // client side + doActivitySound(getActivitySoundLoop()); + return; + } + + // server side + if (tick % 600 == 5) { + // Recheck the structure every 30 seconds or so + if (!checkStructure(false)) checkStructure(true); + } + if (checkStructure(false)) { + runMachine(tick); + pushItemOutputs(tick); + pushFluidOutputs(tick); + + } else { + stopMachine(false); + } + + } + + protected void pushItemOutputs(long tick) { + if (tick % AUTO_OUTPUT_FREQUENCY_TICK != 0) return; + final LinkedList<WeakReference<IMultiBlockPart>> registeredItemOutputs = registeredTickableParts + .get(MultiTileCasingPurpose.ItemOutput.ordinal()); + final Iterator<WeakReference<IMultiBlockPart>> itemOutputIterator = registeredItemOutputs.iterator(); + while (itemOutputIterator.hasNext()) { + final IMultiBlockPart part = (itemOutputIterator.next()).get(); + if (part == null) { + itemOutputIterator.remove(); + continue; } - if (checkStructure(false)) { - runMachine(tick); - } else { - stopMachine(false); + if (!part.shouldTick(mTickTimer)) { + itemOutputIterator.remove(); + continue; + } + + final IInventory facingInventory = part.getIInventoryAtSide(part.getFrontFacing()); + if (facingInventory == null) { + continue; + } + + moveMultipleItemStacks( + part, + facingInventory, + part.getFrontFacing(), + part.getBackFacing(), + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1, + part.getSizeInventory()); + for (int i = 0; i < part.getSizeInventory(); i++) { + if (part.getStackInSlot(i) != null && part.getStackInSlot(i).stackSize <= 0) { + part.setInventorySlotContents(i, null); + } + } + + } + } + + protected void pushFluidOutputs(long tick) { + if (tick % AUTO_OUTPUT_FREQUENCY_TICK != 0) return; + final LinkedList<WeakReference<IMultiBlockPart>> registeredFluidOutputs = registeredTickableParts + .get(MultiTileCasingPurpose.FluidOutput.ordinal()); + final Iterator<WeakReference<IMultiBlockPart>> fluidOutputIterator = registeredFluidOutputs.iterator(); + while (fluidOutputIterator.hasNext()) { + final IMultiBlockPart part = (fluidOutputIterator.next()).get(); + if (part == null) { + fluidOutputIterator.remove(); + continue; + } + if (!part.shouldTick(mTickTimer)) { + fluidOutputIterator.remove(); } - } else { - doActivitySound(getActivitySoundLoop()); } } + @Override + public void setCleanroom(boolean cleanroom) { + isCleanroom = cleanroom; + } + protected void clearSpecialLists() { upgradeCasings.clear(); + functionalCasings.clear(); } @Override @@ -773,47 +634,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic this.limits = mLimits; } - // IMachineProgress - @Override - public long getProgress() { - return progressTime; - } - - @Override - public long getMaxProgress() { - return maxProgressTime; - } - - @Override - public boolean increaseProgress(int aProgressAmountInTicks) { - return increaseProgressGetOverflow(aProgressAmountInTicks) != aProgressAmountInTicks; - } - - @Override - public FluidStack getDrainableFluid(ForgeDirection side) { - return getDrainableFluid(side, null); - } - - @Override - public FluidStack getDrainableFluid(ForgeDirection side, Fluid fluidToDrain) { - final IFluidTank tank = getFluidTankDrainable( - side, - fluidToDrain == null ? null : new FluidStack(fluidToDrain, 0)); - return tank == null ? null : tank.getFluid(); - } - - /** - * Increases the Progress, returns the overflown Progress. - */ - public int increaseProgressGetOverflow(int aProgress) { - return 0; - } - - @Override - public boolean hasThingsToDo() { - return getMaxProgress() > 0; - } - public boolean isSeparateInputs() { return separateInputs; } @@ -822,8 +642,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic separateInputs = aSeparateInputs; } - // End IMachineProgress - protected IAlignmentLimits getInitialAlignmentLimits() { return (d, r, f) -> !f.isVerticallyFliped(); } @@ -877,226 +695,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } } - public <S> IStructureElement<S> addMultiTileCasing(String registryName, int meta, int modes) { - MultiTileEntityRegistry registry = MultiTileEntityRegistry.getRegistry(registryName); - int registryID = Block.getIdFromBlock(registry.mBlock); - return addMultiTileCasing(registryID, meta, modes); - } - - public <S> IStructureElement<S> addMultiTileCasing(int registryID, int meta, int modes) { - return new IStructureElement<S>() { - - private final short[] DEFAULT = new short[] { 255, 255, 255, 0 }; - private IIcon[] mIcons = null; - - @Override - public boolean check(S t, World world, int x, int y, int z) { - final TileEntity tileEntity = world.getTileEntity(x, y, z); - if (!(tileEntity instanceof MultiBlockPart part)) return false; - - if (registryID != part.getMultiTileEntityRegistryID() || meta != part.getMultiTileEntityID()) - return false; - - final IMultiBlockController tTarget = part.getTarget(false); - if (tTarget != null && tTarget != t) return false; - - part.setTarget((IMultiBlockController) t, modes); - - ((Controller<?>) t).registerSpecialCasings(part); - return true; - } - - @Override - public boolean spawnHint(S t, World world, int x, int y, int z, ItemStack trigger) { - if (mIcons == null) { - mIcons = new IIcon[6]; - Arrays.fill(mIcons, TextureSet.SET_NONE.mTextures[OrePrefixes.block.mTextureIndex].getIcon()); - // Arrays.fill(mIcons, getTexture(aCasing); - // for (byte i : ALL_VALID_SIDES) { - // mIcons[i] = aCasing.getIcon(i, aMeta); - // } - } - final short[] RGBA = DEFAULT; - StructureLibAPI.hintParticleTinted(world, x, y, z, mIcons, RGBA); - // StructureLibAPI.hintParticle(world, x, y, z, aCasing, aMeta); - return true; - } - - @Override - public boolean placeBlock(S t, World world, int x, int y, int z, ItemStack trigger) { - final MultiTileEntityRegistry tRegistry = MultiTileEntityRegistry.getRegistry(registryID); - final MultiTileEntityContainer tContainer = tRegistry - .getNewTileEntityContainer(world, x, y, z, meta, null); - if (tContainer == null) { - GT_FML_LOGGER.error("NULL CONTAINER"); - return false; - } - final IMultiTileEntity te = ((IMultiTileEntity) tContainer.mTileEntity); - if (!(te instanceof MultiBlockPart)) { - GT_FML_LOGGER.error("Not a multiblock part"); - return false; - } - if (world.setBlock(x, y, z, tContainer.mBlock, 15 - tContainer.mBlockMetaData, 2)) { - tContainer.setMultiTile(world, x, y, z); - ((MultiBlockPart) te).setTarget(Controller.this, modes); - - ((Controller<?>) t).registerSpecialCasings((MultiBlockPart) te); - } - - return false; - } - - public IIcon getTexture(OrePrefixes aBlock) { - return TextureSet.SET_NONE.mTextures[OrePrefixes.block.mTextureIndex].getIcon(); - } - }; - } - - protected <S> IStructureElementChain<S> addMotorCasings(int modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Motor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Motor.getId(), modes)); - } - - protected <S> IStructureElementChain<S> addPumpCasings(int modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Pump.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Pump.getId(), modes)); - } - - protected <S> IStructureElementChain<S> addPistonCasings(int modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Piston.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Piston.getId(), modes)); - } - - protected <S> IStructureElementChain<S> addConveyorCasings(int modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Conveyor.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Conveyor.getId(), modes)); - } - - protected <S> IStructureElementChain<S> addRobotArmCasings(int modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_RobotArm.getId(), modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_RobotArm.getId(), modes)); - } - - protected <S> IStructureElementChain<S> addSensorCasings(int Modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Sensor.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Sensor.getId(), Modes)); - } - - protected <S> IStructureElementChain<S> addEmitterCasings(int Modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_Emitter.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_Emitter.getId(), Modes)); - } - - protected <S> IStructureElementChain<S> addFieldGeneratorCasings(int Modes) { - return ofChain( - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, HV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, EV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, IV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, LuV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, ZPM_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UHV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UEV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UIV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UMV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, UXV_FieldGenerator.getId(), Modes), - addMultiTileCasing(COMPONENT_CASING_REGISTRY_NAME, MAX_FieldGenerator.getId(), Modes)); - } - - protected void registerSpecialCasings(MultiBlockPart part) { + public void registerSpecialCasings(MultiBlockPart part) { if (part instanceof UpgradeCasing) { upgradeCasings.add((UpgradeCasing) part); } @@ -1105,728 +704,177 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } } - /** - * Fluid - MultiBlock related Fluid Tank behaviour. - */ - public void registerFluidInventory(String name, String id, int numberOfSlots, long capacity, - long capacityMultiplier, int type) { - if (name == null || name.equals("") - || id == null - || id.equals("") - || numberOfSlots < 0 - || capacity < 0 - || capacityMultiplier < 0) { - return; - } - FluidTankGT[] tanks = new FluidTankGT[numberOfSlots]; - for (int i = 0; i < numberOfSlots; i++) { - tanks[i] = new FluidTankGT(capacity).setCapacityMultiplier(capacityMultiplier); - } - registerFluidInventory(name, id, tanks, type); - } - - public void registerFluidInventory(String name, String id, FluidTankGT[] fluidInventory, int type) { - if (name == null || name.equals("") - || id == null - || id.equals("") - || fluidInventory == null - || fluidInventory.length == 0) { - return; - } - if (type == Inventory.INPUT || type == Inventory.BOTH) { - if (multiBlockInputTank.containsKey(id)) return; - multiBlockInputTank.put(id, fluidInventory); - multiBlockInputTankNames.put(id, name); - } - if (type == Inventory.OUTPUT || type == Inventory.BOTH) { - if (multiBlockOutputTank.containsKey(id)) return; - multiBlockOutputTank.put(id, fluidInventory); - multiBlockOutputTankNames.put(id, name); - } - } - - public void unregisterFluidInventory(String aName, String aID, int aType) { - if ((aType == Inventory.INPUT || aType == Inventory.BOTH) && multiBlockInputTank.containsKey(aID)) { - multiBlockInputTank.remove(aID, multiBlockInputTank.get(aID)); - multiBlockInputTankNames.remove(aID, aName); - } - if ((aType == Inventory.OUTPUT || aType == Inventory.BOTH) && multiBlockOutputTank.containsKey(aID)) { - multiBlockOutputTank.remove(aID, multiBlockOutputTank.get(aID)); - multiBlockOutputTankNames.remove(aID, aName); - } - } - - protected FluidTankGT[] getTanksForInput() { - List<FluidTankGT> tanks = new ArrayList<>(); - for (FluidTankGT[] inputTanks : multiBlockInputTank.values()) { - tanks.addAll(Arrays.asList(inputTanks)); - } - return tanks.toArray(new FluidTankGT[0]); - } - - protected FluidTankGT[] getTanksForOutput() { - List<FluidTankGT> tanks = new ArrayList<>(); - for (FluidTankGT[] outputTanks : multiBlockOutputTank.values()) { - tanks.addAll(Arrays.asList(outputTanks)); - } - return tanks.toArray(new FluidTankGT[0]); - } - - protected IFluidTank getFluidTankFillable(MultiBlockPart aPart, ForgeDirection side, FluidStack aFluidToFill) { - return getFluidTankFillable(side, aFluidToFill); - } - - protected IFluidTank getFluidTankDrainable(MultiBlockPart aPart, ForgeDirection side, FluidStack aFluidToDrain) { - return getFluidTankDrainable(side, aFluidToDrain); - } - - protected IFluidTank[] getFluidTanks(MultiBlockPart aPart, ForgeDirection side) { - return getFluidTanks(side); - } - - @Override - public int fill(MultiBlockPart aPart, ForgeDirection aDirection, FluidStack aFluid, boolean aDoFill) { - if (aFluid == null || aFluid.amount <= 0) return 0; - final IFluidTank tTank = getFluidTankFillable(aPart, aDirection, aFluid); - if (tTank == null) return 0; - final int rFilledAmount = tTank.fill(aFluid, aDoFill); - if (rFilledAmount > 0 && aDoFill) hasInventoryChanged = true; - return rFilledAmount; - } - - @Override - public FluidStack drain(MultiBlockPart aPart, ForgeDirection aDirection, FluidStack aFluid, boolean aDoDrain) { - if (aFluid == null || aFluid.amount <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, aFluid); - if (tTank == null || tTank.getFluid() == null - || tTank.getFluidAmount() == 0 - || !tTank.getFluid() - .isFluidEqual(aFluid)) - return null; - final FluidStack rDrained = tTank.drain(aFluid.amount, aDoDrain); - if (rDrained != null && aDoDrain) markInventoryBeenModified(); - return rDrained; - } - - @Override - public FluidStack drain(MultiBlockPart aPart, ForgeDirection aDirection, int aAmountToDrain, boolean aDoDrain) { - if (aAmountToDrain <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, null); - if (tTank == null || tTank.getFluid() == null || tTank.getFluidAmount() == 0) return null; - final FluidStack rDrained = tTank.drain(aAmountToDrain, aDoDrain); - if (rDrained != null && aDoDrain) markInventoryBeenModified(); - return rDrained; - } - - @Override - public boolean canFill(MultiBlockPart aPart, ForgeDirection aDirection, Fluid aFluid) { - if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankFillable(aPart, aDirection, new FluidStack(aFluid, 0)); - return tTank != null && (tTank.getFluid() == null || tTank.getFluid() - .getFluid() == aFluid); - } - - @Override - public boolean canDrain(MultiBlockPart aPart, ForgeDirection aDirection, Fluid aFluid) { - if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, new FluidStack(aFluid, 0)); - return tTank != null && (tTank.getFluid() != null && tTank.getFluid() - .getFluid() == aFluid); - } - - @Override - public FluidTankInfo[] getTankInfo(MultiBlockPart aPart, ForgeDirection aDirection) { - final IFluidTank[] tTanks = getFluidTanks(aPart, aDirection); - if (tTanks == null || tTanks.length <= 0) return GT_Values.emptyFluidTankInfo; - final FluidTankInfo[] rInfo = new FluidTankInfo[tTanks.length]; - for (int i = 0; i < tTanks.length; i++) rInfo[i] = new FluidTankInfo(tTanks[i]); - return rInfo; - } - - @Override - public IFluidTank[] getFluidTanksForGUI(MultiBlockPart aPart) { - final String lockedInventory = aPart.getLockedInventory(); - if (lockedInventory == null) { - if (aPart.modeSelected(MultiBlockPart.FLUID_IN)) return getTanksForInput(); - else if (aPart.modeSelected(MultiBlockPart.FLUID_OUT)) return getTanksForOutput(); - } else { - final Map<String, FluidTankGT[]> tankMap = getMultiBlockTankArray(aPart); - if (tankMap == null) return GT_Values.emptyFluidTank; - final FluidTankGT[] tanks = tankMap.get(lockedInventory); - return tanks != null ? tanks : GT_Values.emptyFluidTank; - } - return GT_Values.emptyFluidTank; - } - - // #region Energy - @Override - public PowerLogic getPowerLogic(IMultiBlockPart part, ForgeDirection side) { - if (!(this instanceof PowerLogicHost powerLogicHost)) { - return null; - } - - if (part.getFrontFacing() != side) { - return null; - } - - return powerLogicHost.getPowerLogic(side); - } - // #endregion Energy - - /** - * Item - MultiBlock related Item behaviour. - */ - @Override - public void registerInventory(String aName, String aID, int aInventorySize, int aType) { - registerInventory(aName, aID, new ItemStackHandler(aInventorySize), aType); - } - - public void registerInventory(String name, String id, IItemHandlerModifiable inventory, int type) { - if (name == null || name.equals("") || id == null || id.equals("") || inventory == null) { - return; - } - if (type == Inventory.INPUT || type == Inventory.BOTH) { - if (multiBlockInputInventory.containsKey(id)) return; - multiBlockInputInventory.put(id, inventory); - multiBlockInputInventoryNames.put(id, name); - } - if (type == Inventory.OUTPUT || type == Inventory.BOTH) { - if (multiBlockOutputInventory.containsKey(id)) return; - multiBlockOutputInventory.put(id, inventory); - multiBlockOutputInventoryNames.put(id, name); - } - } - - @Override - public void unregisterInventory(String aName, String aID, int aType) { - if ((aType == Inventory.INPUT || aType == Inventory.BOTH) && multiBlockInputInventory.containsKey(aID)) { - multiBlockInputInventory.remove(aID, multiBlockInputInventory.get(aID)); - multiBlockInputInventoryNames.remove(aID, aName); - } - if ((aType == Inventory.OUTPUT || aType == Inventory.BOTH) && multiBlockOutputInventory.containsKey(aID)) { - multiBlockOutputInventory.remove(aID, multiBlockOutputInventory.get(aID)); - multiBlockOutputInventoryNames.remove(aID, aName); - } - } - - @Override - public void changeInventoryName(String aName, String aID, int aType) { - if ((aType == Inventory.INPUT || aType == Inventory.BOTH) && multiBlockInputInventoryNames.containsKey(aID)) { - multiBlockInputInventoryNames.put(aID, aName); - } - if ((aType == Inventory.OUTPUT || aType == Inventory.BOTH) && multiBlockOutputInventoryNames.containsKey(aID)) { - multiBlockOutputInventoryNames.put(aID, aName); - } - } - - @Override - public boolean hasInventoryBeenModified(MultiBlockPart aPart) { - if (aPart.modeSelected(MultiBlockPart.ITEM_IN)) return hasInventoryBeenModified(); - else if (aPart.modeSelected(MultiBlockPart.ITEM_OUT)) return hasOutputInventoryBeenModified(); - - return false; - } + // #region Fluid - MultiBlock related Fluid Tank behaviour. @Override - public boolean isValidSlot(MultiBlockPart aPart, int aIndex) { - return false; + @Nullable + public FluidInventoryLogic getFluidLogic(@Nonnull ForgeDirection side, @Nonnull InventoryType type) { + if (side == facing) return null; + return switch (type) { + case Input -> controllerFluidInput.getAllInventoryLogics(); + case Output -> controllerFluidOutput.getAllInventoryLogics(); + default -> null; + }; } - @Override - public void enableWorking() { - super.enableWorking(); - if (!structureOkay) { - checkStructure(true); - } + @Nullable + public FluidInventoryLogic getFluidLogic(@Nonnull InventoryType type, @Nullable UUID id) { + return switch (type) { + case Input -> controllerFluidInput.getInventoryLogic(id); + case Output -> controllerFluidOutput.getInventoryLogic(id); + default -> null; + }; } @Override - public IItemHandlerModifiable getInventoryForGUI(MultiBlockPart aPart) { - if (isServerSide()) { - for (UpgradeCasing tPart : upgradeCasings) { - if (!(tPart instanceof Inventory)) continue; - tPart.issueClientUpdate(); + @Nonnull + public UUID registerFluidInventory(int tanks, long capacity, int tier, @Nonnull InventoryType type, + boolean isUpgradeInventory) { + return switch (type) { + case Input -> controllerFluidInput + .addInventory(new FluidInventoryLogic(tanks, capacity, tier, isUpgradeInventory)); + case Output -> controllerFluidOutput + .addInventory(new FluidInventoryLogic(tanks, capacity, tier, isUpgradeInventory)); + case Both -> { + UUID id = controllerFluidInput + .addInventory(new FluidInventoryLogic(tanks, capacity, tier, isUpgradeInventory)); + controllerFluidOutput + .addInventory(id, new FluidInventoryLogic(tanks, capacity, tier, isUpgradeInventory)); + yield id; } - } - final Map<String, IItemHandlerModifiable> multiBlockInventory = getMultiBlockInventory(aPart); - if (multiBlockInventory == null) return null; - - final String lockedInventory = aPart.getLockedInventory(); - if (lockedInventory == null) { - return new ListItemHandler(multiBlockInventory.values()); - } else { - final IItemHandlerModifiable inv = multiBlockInventory.get(lockedInventory); - return inv; - } - } - - @Override - public boolean addStackToSlot(MultiBlockPart aPart, int aIndex, ItemStack aStack) { - return false; + }; } @Override - public boolean addStackToSlot(MultiBlockPart aPart, int aIndex, ItemStack aStack, int aAmount) { - return false; - } - - protected Map<String, FluidTankGT[]> getMultiBlockTankArray(MultiBlockPart aPart) { - if (aPart.modeSelected(MultiBlockPart.FLUID_IN)) return multiBlockInputTank; - else if (aPart.modeSelected(MultiBlockPart.FLUID_OUT)) return multiBlockOutputTank; - return null; - } - - protected Map<String, String> getMultiBlockTankArrayNames(MultiBlockPart aPart) { - if (aPart.modeSelected(MultiBlockPart.FLUID_IN)) return multiBlockInputTankNames; - else if (aPart.modeSelected(MultiBlockPart.FLUID_OUT)) return multiBlockOutputTankNames; - return null; - } - - protected Map<String, IItemHandlerModifiable> getMultiBlockInventory(MultiBlockPart aPart) { - if (aPart.modeSelected(MultiBlockPart.ITEM_IN)) return multiBlockInputInventory; - else if (aPart.modeSelected(MultiBlockPart.ITEM_OUT)) return multiBlockOutputInventory; - return null; - } - - protected Map<String, String> getMultiBlockInventoryNames(MultiBlockPart aPart) { - if (aPart.modeSelected(MultiBlockPart.ITEM_IN)) return multiBlockInputInventoryNames; - else if (aPart.modeSelected(MultiBlockPart.ITEM_OUT)) return multiBlockOutputInventoryNames; - return null; - } - - protected Pair<IItemHandlerModifiable, Integer> getInventory(MultiBlockPart aPart, int aSlot) { - final Map<String, IItemHandlerModifiable> multiBlockInventory = getMultiBlockInventory(aPart); - if (multiBlockInventory == null) return null; - - final String invName = aPart.getLockedInventory(); - if (invName != null && !invName.isEmpty()) return new ImmutablePair<>(multiBlockInventory.get(invName), aSlot); - - int start = 0; - for (IItemHandlerModifiable inv : multiBlockInventory.values()) { - if (aSlot >= start && aSlot < start + inv.getSlots()) { - return new ImmutablePair<>(inv, aSlot - start); + @Nonnull + public FluidInventoryLogic unregisterFluidInventory(@Nonnull UUID id, @Nonnull InventoryType type) { + return switch (type) { + case Input -> controllerFluidInput.removeInventory(id); + case Output -> controllerFluidOutput.removeInventory(id); + case Both -> { + FluidInventoryLogic input = controllerFluidInput.removeInventory(id); + FluidInventoryLogic output = controllerFluidOutput.removeInventory(id); + yield new FluidInventoryLogic( + Arrays.asList(input, output) + .stream() + .map(inv -> inv.getInventory()) + .collect(Collectors.toList())); } - start += inv.getSlots(); - } - return null; + }; } @Override - public int[] getAccessibleSlotsFromSide(MultiBlockPart aPart, ForgeDirection side) { - final TIntList tList = new TIntArrayList(); - final Map<String, IItemHandlerModifiable> multiBlockInventory = getMultiBlockInventory(aPart); - if (multiBlockInventory == null) return tList.toArray(); - - final String lockedInventory = aPart.getLockedInventory(); - // Item in --> input inv - // Item out --> output inv - - int start = 0; - if (lockedInventory == null) { - for (IItemHandlerModifiable inv : multiBlockInventory.values()) { - for (int i = start; i < inv.getSlots() + start; i++) tList.add(i); - start += inv.getSlots(); - } - } else { - final IItemHandlerModifiable inv = multiBlockInventory.get(lockedInventory); - final int len = inv != null ? inv.getSlots() : 0; - for (int i = 0; i < len; i++) tList.add(i); + public void changeFluidInventoryDisplayName(@Nullable UUID id, @Nullable String displayName, + @Nonnull InventoryType type) { + switch (type) { + case Input: + controllerFluidInput.setInventoryDisplayName(id, displayName); + break; + case Output: + controllerFluidOutput.setInventoryDisplayName(id, displayName); + break; + case Both: + controllerFluidInput.setInventoryDisplayName(id, displayName); + controllerFluidOutput.setInventoryDisplayName(id, displayName); + break; } - return tList.toArray(); } - @Override - public boolean canInsertItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side) { - final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); - if (tInv == null) return false; - - final int tSlot = tInv.getRight(); - final IItemHandlerModifiable inv = tInv.getLeft(); - - return inv.getStackInSlot(tSlot) == null || GT_Utility.areStacksEqual(aStack, inv.getStackInSlot(tSlot)); // && - // allowPutStack(getBaseMetaTileEntity(), - // aIndex, - // (byte) - // aSide, - // aStack) - } + // #endregion Fluid - @Override - public boolean canExtractItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side) { - final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); - if (tInv == null) return false; - - final int tSlot = tInv.getRight(); - final IItemHandlerModifiable inv = tInv.getLeft(); - - return inv.getStackInSlot(tSlot) != null; // && allowPullStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, - // aStack); - } + // #region Item - MultiBlock related Item behaviour. @Override - public int getSizeInventory(MultiBlockPart aPart) { - final Map<String, IItemHandlerModifiable> multiBlockInventory = getMultiBlockInventory(aPart); - if (multiBlockInventory == null) return 0; - - final String lockedInventory = aPart.getLockedInventory(); - if (lockedInventory == null) { - int len = 0; - for (IItemHandlerModifiable inv : multiBlockInventory.values()) len += inv.getSlots(); - return len; - } else { - final IItemHandlerModifiable inv = multiBlockInventory.get(lockedInventory); - return inv != null ? inv.getSlots() : 0; - } + @Nullable + public ItemInventoryLogic getItemLogic(@Nonnull ForgeDirection side, @Nonnull InventoryType type) { + if (side == facing) return null; + return switch (type) { + case Input -> controllerItemInput.getAllInventoryLogics(); + case Output -> controllerItemOutput.getAllInventoryLogics(); + default -> null; + }; } @Override - public ItemStack getStackInSlot(MultiBlockPart aPart, int aSlot) { - final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); - if (tInv == null) return null; - - final int tSlot = tInv.getRight(); - final IItemHandlerModifiable inv = tInv.getLeft(); - if (inv == null) return null; - - return inv.getStackInSlot(tSlot); + @Nullable + public ItemInventoryLogic getItemLogic(@Nonnull InventoryType type, @Nullable UUID id) { + return switch (type) { + case Input -> controllerItemInput.getInventoryLogic(id); + case Output -> controllerItemOutput.getInventoryLogic(id); + default -> null; + }; } @Override - public ItemStack decrStackSize(MultiBlockPart aPart, int aSlot, int aDecrement) { - final ItemStack tStack = getStackInSlot(aPart, aSlot); - ItemStack rStack = GT_Utility.copyOrNull(tStack); - if (tStack != null) { - if (tStack.stackSize <= aDecrement) { - setInventorySlotContents(aPart, aSlot, null); - } else { - rStack = tStack.splitStack(aDecrement); - if (tStack.stackSize == 0) setInventorySlotContents(aPart, aSlot, null); + @Nonnull + public UUID registerItemInventory(int slots, int tier, @Nonnull InventoryType type, boolean isUpgradeInventory) { + return switch (type) { + case Input -> controllerItemInput.addInventory(new ItemInventoryLogic(slots, tier, isUpgradeInventory)); + case Output -> controllerItemOutput.addInventory(new ItemInventoryLogic(slots, tier, isUpgradeInventory)); + case Both -> { + UUID id = controllerItemInput.addInventory(new ItemInventoryLogic(slots, tier, isUpgradeInventory)); + controllerItemOutput.addInventory(id, new ItemInventoryLogic(slots, tier, isUpgradeInventory)); + yield id; } - } - return rStack; - } - - @Override - public ItemStack getStackInSlotOnClosing(MultiBlockPart aPart, int aSlot) { - final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); - if (tInv == null) return null; - - final IItemHandlerModifiable inv = tInv.getLeft(); - final int tSlot = tInv.getRight(); - - final ItemStack rStack = inv.getStackInSlot(tSlot); - inv.setStackInSlot(tSlot, null); - return rStack; - } - - @Override - public void setInventorySlotContents(MultiBlockPart aPart, int aSlot, ItemStack aStack) { - final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); - if (tInv == null) return; - - final IItemHandlerModifiable inv = tInv.getLeft(); - final int tSlot = tInv.getRight(); - inv.setStackInSlot(tSlot, aStack); - } - - @Override - public List<String> getInventoryNames(MultiBlockPart aPart) { - final List<String> inventoryNames = new ArrayList<>(); - inventoryNames.add(ALL_INVENTORIES_NAME); - inventoryNames.addAll(getMultiBlockInventoryNames(aPart).values()); - return inventoryNames; - } - - @Override - public List<String> getInventoryIDs(MultiBlockPart aPart) { - final List<String> tInventoryIDs = new ArrayList<>(); - tInventoryIDs.add(ALL_INVENTORIES_NAME); - tInventoryIDs.addAll(getMultiBlockInventory(aPart).keySet()); - return tInventoryIDs; - } - - @Override - public String getInventoryName(MultiBlockPart aPart) { - final StringBuilder str = new StringBuilder(); - str.append(getInventoryName()); - if (aPart.modeSelected(MultiBlockPart.ITEM_IN)) { - str.append(" Input"); - } else if (aPart.modeSelected(MultiBlockPart.ITEM_OUT)) { - str.append(" Output"); - String a; - } else { - str.append(" Unknown"); - } - final String lockedInventory = aPart.getLockedInventory(); - if (lockedInventory != null && !lockedInventory.equals("")) { - str.append(" [Locked: ") - .append(lockedInventory) - .append("]"); - } - - return str.toString(); - } - - @Override - public List<String> getTankArrayNames(MultiBlockPart aPart) { - final List<String> inventoryNames = new ArrayList<>(); - inventoryNames.add(ALL_INVENTORIES_NAME); - inventoryNames.addAll(getMultiBlockTankArrayNames(aPart).values()); - return inventoryNames; - } - - @Override - public List<String> getTankArrayIDs(MultiBlockPart aPart) { - final List<String> inventoryIDs = new ArrayList<>(); - inventoryIDs.add(ALL_INVENTORIES_NAME); - inventoryIDs.addAll(getMultiBlockTankArray(aPart).keySet()); - return inventoryIDs; - } - - @Override - public boolean hasCustomInventoryName(MultiBlockPart aPart) { - return hasCustomInventoryName(); - } - - @Override - public int getInventoryStackLimit(MultiBlockPart aPart) { - return getInventoryStackLimit(); - } - - @Override - public void markDirty(MultiBlockPart aPart) { - markDirty(); - if (aPart.modeSelected(MultiBlockPart.ITEM_OUT)) markOutputInventoryBeenModified(); - else markInventoryBeenModified(); - } - - @Override - public boolean isUseableByPlayer(MultiBlockPart aPart, EntityPlayer aPlayer) { - return isUseableByPlayer(aPlayer); - } - - @Override - public void openInventory(MultiBlockPart aPart) { - // TODO: MultiInventory - consider the part's inventory - openInventory(); - } - - @Override - public void closeInventory(MultiBlockPart aPart) { - // TODO: MultiInventory - consider the part's inventory - closeInventory(); - } - - @Override - public boolean isItemValidForSlot(MultiBlockPart aPart, int aSlot, ItemStack aStack) { - return isItemValidForSlot(aSlot, aStack); - } - - /* - * Helper Methods For Recipe checking - */ - - @Override - protected ItemStack[] getInputItems() { - return getInventoriesForInput().getStacks() - .toArray(new ItemStack[0]); - } - - protected ItemStack[] getOutputItems() { - return getInventoriesForOutput().getStacks() - .toArray(new ItemStack[0]); - } - - protected Iterable<Pair<ItemStack[], String>> getItemInputsForEachInventory() { - return multiBlockInputInventory.entrySet() - .stream() - .map( - (entry) -> Pair.of( - entry.getValue() - .getStacks() - .toArray(new ItemStack[0]), - entry.getKey())) - .collect(Collectors.toList()); - } - - protected ItemStack[] getItemInputsForInventory(String id) { - IItemHandlerModifiable inventory = multiBlockInputInventory.get(id); - if (inventory != null) { - return inventory.getStacks() - .toArray(new ItemStack[0]); - } - return null; + }; } @Override - protected FluidStack[] getInputFluids() { - List<FluidStack> fluidStacks = new ArrayList<>(); - for (FluidTankGT[] inputTanks : multiBlockInputTank.values()) { - for (FluidTankGT inputTank : inputTanks) { - FluidStack fluidStack = inputTank.get(); - if (fluidStack != null) { - fluidStacks.add(fluidStack); - } + public ItemInventoryLogic unregisterItemInventory(@Nonnull UUID id, @Nonnull InventoryType type) { + return switch (type) { + case Input -> controllerItemInput.removeInventory(id); + case Output -> controllerItemOutput.removeInventory(id); + case Both -> { + ItemInventoryLogic input = controllerItemInput.removeInventory(id); + ItemInventoryLogic output = controllerItemOutput.removeInventory(id); + yield new ItemInventoryLogic( + Arrays.asList(input, output) + .stream() + .map(inv -> inv.getInventory()) + .collect(Collectors.toList())); } - } - return fluidStacks.toArray(new FluidStack[0]); - } - - protected FluidStack[] getOutputFluids() { - List<FluidStack> fluidStacks = new ArrayList<>(); - for (FluidTankGT[] inputTanks : multiBlockInputTank.values()) { - for (FluidTankGT inputTank : inputTanks) { - FluidStack fluidStack = inputTank.getFluid(); - if (fluidStack != null) { - fluidStacks.add(fluidStack); - } - } - } - return fluidStacks.toArray(new FluidStack[0]); - } - - protected Iterable<Pair<FluidStack[], String>> getFluidInputsForEachTankArray() { - return multiBlockInputTank.entrySet() - .stream() - .map((entry) -> Pair.of(FluidTankGT.getFluidsFromTanks(entry.getValue()), entry.getKey())) - .collect(Collectors.toList()); - } - - protected FluidStack[] getFluidInputsForTankArray(String id) { - return FluidTankGT.getFluidsFromTanks(multiBlockInputTank.get(id)); - } - - protected void setItemOutputs(String inventory, ItemStack... itemOutputs) { - itemsToOutput = itemOutputs; - inventoryName = inventory; - } - - @Override - protected void setItemOutputs(ItemStack... outputs) { - super.setItemOutputs(outputs); - inventoryName = null; + }; } @Override - protected void outputItems() { - if (itemsToOutput == null) { - return; - } - - IItemHandlerModifiable inv; - if (inventoryName != null) { - inv = multiBlockOutputInventory.getOrDefault(inventoryName, getInventoriesForOutput()); - } else { - inv = getInventoriesForOutput(); + public void changeItemInventoryDisplayName(@Nullable UUID id, @Nullable String displayName, + @Nonnull InventoryType type) { + switch (type) { + case Input: + controllerItemInput.setInventoryDisplayName(id, displayName); + break; + case Output: + controllerItemOutput.setInventoryDisplayName(id, displayName); + break; + case Both: + controllerItemInput.setInventoryDisplayName(id, displayName); + controllerItemOutput.setInventoryDisplayName(id, displayName); + break; } - for (ItemStack item : itemsToOutput) { - int index = 0; - while (item != null && item.stackSize > 0 && index < inv.getSlots()) { - item = inv.insertItem(index++, item.copy(), false); - } - } - itemsToOutput = null; } - protected void setFluidOutputs(String tank, FluidStack... fluidOuputs) { - fluidsToOutput = fluidOuputs; - tankName = tank; - } + // #endregion Item - @Override - protected void setFluidOutputs(FluidStack... outputs) { - super.setFluidOutputs(outputs); - tankName = null; - } + // #region Energy + @Nonnull @Override - protected void outputFluids() { - if (fluidsToOutput == null) { - return; - } - - List<FluidTankGT> tanks = Arrays.asList(outputTanks); - for (FluidStack fluid : fluidsToOutput) { - int index = 0; - while (fluid != null && fluid.amount > 0 && index < tanks.size()) { - int filled = tanks.get(index++) - .fill(fluid, true); - fluid.amount -= filled; - } - } + public PowerLogic getPowerLogic() { + return getPowerLogic(ForgeDirection.UNKNOWN); } - @Override - protected void updateSlots() { - IItemHandlerModifiable inv = getInventoriesForInput(); - for (int i = 0; i < inv.getSlots(); i++) { - if (inv.getStackInSlot(i) != null && inv.getStackInSlot(i).stackSize <= 0) { - inv.setStackInSlot(i, null); - } - } - - for (FluidTankGT inputTank : getTanksForInput()) { - if (inputTank == null) { - continue; - } - - if (inputTank.get() != null && inputTank.get().amount <= 0) { - inputTank.setEmpty(); - continue; - } - - FluidStack afterRecipe = inputTank.get(); - FluidStack beforeRecipe = inputTank.get(Integer.MAX_VALUE); - if (afterRecipe == null || beforeRecipe == null) { - continue; - } - int difference = beforeRecipe.amount - afterRecipe.amount; - inputTank.remove(difference); - } - } + // #endregion Energy @Override - protected boolean checkRecipe() { - if (!(this instanceof ProcessingLogicHost)) { - return false; - } - ProcessingLogic logic = ((ProcessingLogicHost) this).getProcessingLogic(); - logic.clear(); - CheckRecipeResult result = CheckRecipeResultRegistry.NO_RECIPE; - if (isSeparateInputs()) { - // TODO: Add separation with fluids - for (Pair<ItemStack[], String> inventory : getItemInputsForEachInventory()) { - IItemHandlerModifiable outputInventory = multiBlockOutputInventory - .getOrDefault(inventory.getLeft(), null); - result = logic.setInputItems(inventory.getLeft()) - .setCurrentOutputItems(getOutputItems()) - .process(); - if (result.wasSuccessful()) { - inventoryName = inventory.getRight(); - break; - } - logic.clear(); - } - } else { - result = logic.setInputItems(getInputItems()) - .setCurrentOutputItems(getOutputItems()) - .setInputFluids(getInputFluids()) - .setCurrentOutputFluids(getOutputFluids()) - .process(); - } - setDuration(logic.getDuration()); - setEut(logic.getCalculatedEut()); - setItemOutputs(logic.getOutputItems()); - setFluidOutputs(logic.getOutputFluids()); - return result.wasSuccessful(); - } - - public IItemHandlerModifiable getOutputInventory() { - return outputInventory; - } - - public FluidTankGT[] getOutputTanks() { - return outputTanks; + protected void updateSlots() { + controllerItemInput.getAllInventoryLogics() + .update(shouldSort); + controllerItemOutput.getAllInventoryLogics() + .update(shouldSort); + controllerFluidInput.getAllInventoryLogics() + .update(); + controllerFluidOutput.getAllInventoryLogics() + .update(); } /* @@ -1838,24 +886,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public ModularWindow createWindow(UIBuildContext buildContext) { - System.out.println("MultiBlockController::createWindow"); - if (!useModularUI()) return null; - - buildContext.setValidator(getValidator()); - final ModularWindow.Builder builder = ModularWindow.builder(getGUIWidth(), getGUIHeight()); - builder.setBackground(getGUITextureSet().getMainBackground()); - builder.setGuiTint(getGUIColorization()); - if (doesBindPlayerInventory()) { - bindPlayerInventoryUI(builder, buildContext); - } - addUIWidgets(builder, buildContext); - addTitleToUI(builder); - addCoverTabs(builder, buildContext); - return builder.build(); - } - - @Override public boolean hasGui(ForgeDirection side) { return true; } @@ -1866,222 +896,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public int getGUIHeight() { - return 192; - } - - protected Widget getGregTechLogo() { - return new DrawableWidget().setDrawable(getGUITextureSet().getGregTechLogo()) - .setSize(17, 17); - } - - @Override - public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { - if (isServerSide()) { - for (UpgradeCasing tPart : upgradeCasings) { - if (!(tPart instanceof Inventory)) continue; - tPart.issueClientUpdate(); - } - } - int page = 0; - TabContainer tabs = new TabContainer().setButtonSize(20, 24); - tabs.addTabButton( - new TabButton(page++) - .setBackground( - false, - ModularUITextures.VANILLA_TAB_TOP_START.getSubArea(0, 0, 1f, 0.5f), - new ItemDrawable(getStackForm(1)).withFixedSize(16, 16) - .withOffset(2, 4)) - .setBackground( - true, - ModularUITextures.VANILLA_TAB_TOP_START.getSubArea(0, 0.5f, 1f, 1f), - new ItemDrawable(getStackForm(1)).withFixedSize(16, 16) - .withOffset(2, 4)) - .addTooltip(getLocalName()) - .setPos(20 * (page - 1), -20)) - .addPage(createMainPage(builder).setSize(getGUIWidth(), getGUIHeight())); - if (hasItemInput()) { - tabs.addTabButton( - new TabButton(page++) - .setBackground( - false, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0, 1f, 0.5f), - GT_UITextures.PICTURE_ITEM_IN.withFixedSize(16, 16) - .withOffset(2, 4)) - .setBackground( - true, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0.5f, 1f, 1f), - GT_UITextures.PICTURE_ITEM_IN.withFixedSize(16, 16) - .withOffset(2, 4)) - .setPos(20 * (page - 1), -20)) - .addPage( - new MultiChildWidget().addChild(getItemInventoryInputGUI()) - .addChild(getGregTechLogo().setPos(147, 86)) - .setSize(getGUIWidth(), getGUIHeight())); - } - - if (hasItemOutput()) { - tabs.addTabButton( - new TabButton(page++) - .setBackground( - false, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0, 1f, 0.5f), - GT_UITextures.PICTURE_ITEM_OUT.withFixedSize(16, 16) - .withOffset(2, 4)) - .setBackground( - true, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0.5f, 1f, 1f), - GT_UITextures.PICTURE_ITEM_OUT.withFixedSize(16, 16) - .withOffset(2, 4)) - .setPos(20 * (page - 1), -20)) - .addPage( - new MultiChildWidget().addChild(getItemInventoryOutputGUI()) - .addChild(getGregTechLogo().setPos(147, 86)) - .setSize(getGUIWidth(), getGUIHeight())); - } - - if (hasFluidInput()) { - tabs.addTabButton( - new TabButton(page++) - .setBackground( - false, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0, 1f, 0.5f), - GT_UITextures.PICTURE_FLUID_IN.withFixedSize(16, 16) - .withOffset(2, 4)) - .setBackground( - true, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0.5f, 1f, 1f), - GT_UITextures.PICTURE_FLUID_IN.withFixedSize(16, 16) - .withOffset(2, 4)) - .setPos(20 * (page - 1), -20)) - .addPage( - new MultiChildWidget().addChild(getFluidInventoryInputGUI()) - .addChild(getGregTechLogo().setPos(147, 86)) - .setSize(getGUIWidth(), getGUIHeight())); - } - - if (hasFluidOutput()) { - tabs.addTabButton( - new TabButton(page++) - .setBackground( - false, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0, 1f, 0.5f), - GT_UITextures.PICTURE_FLUID_OUT.withFixedSize(16, 16) - .withOffset(2, 4)) - .setBackground( - true, - ModularUITextures.VANILLA_TAB_TOP_MIDDLE.getSubArea(0, 0.5f, 1f, 1f), - GT_UITextures.PICTURE_FLUID_OUT.withFixedSize(16, 16) - .withOffset(2, 4)) - .setPos(20 * (page - 1), -20)) - .addPage( - new MultiChildWidget().addChild(getFluidInventoryOutputGUI()) - .addChild(getGregTechLogo().setPos(147, 86)) - .setSize(getGUIWidth(), getGUIHeight())); - } - builder.widget(tabs); - } - - protected MultiChildWidget createMainPage(IWidgetBuilder<?> builder) { - MultiChildWidget page = new MultiChildWidget(); - page.addChild( - new DrawableWidget().setDrawable(GT_UITextures.PICTURE_SCREEN_BLACK) - .setPos(7, 4) - .setSize(160, 75)) - .addChild(createButtons(builder)); - return page; - } - - protected MultiChildWidget createButtons(IWidgetBuilder<?> builder) { - MultiChildWidget buttons = new MultiChildWidget(); - buttons.setSize(16, 167) - .setPos(7, 86); - buttons.addChild(createPowerSwitchButton(builder)) - .addChild(createVoidExcessButton(builder)) - .addChild(createInputSeparationButton(builder)) - .addChild(createBatchModeButton(builder)) - .addChild(createLockToSingleRecipeButton(builder)); - - return buttons; - } - - protected Widget getItemInventoryInputGUI() { - final IItemHandlerModifiable inv = getInventoriesForInput(); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < Math.min(inv.getSlots(), 128); rows++) { - final int columnsToMake = Math.min(Math.min(inv.getSlots(), 128) - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - scrollable.widget( - new SlotWidget(inv, rows * 4 + column).setPos(column * 18, rows * 18) - .setSize(18, 18)); - } - } - return scrollable.setSize(18 * 4 + 4, 18 * 5) - .setPos(52, 7); - } - - protected Widget getItemInventoryOutputGUI() { - final IItemHandlerModifiable inv = getInventoriesForOutput(); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < Math.min(inv.getSlots(), 128); rows++) { - final int columnsToMake = Math.min(Math.min(inv.getSlots(), 128) - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - scrollable.widget( - new SlotWidget(inv, rows * 4 + column).setPos(column * 18, rows * 18) - .setSize(18, 18)); - } - } - return scrollable.setSize(18 * 4 + 4, 18 * 5) - .setPos(52, 7); - } - - protected IItemHandlerModifiable getInventoriesForInput() { - return new ListItemHandler(multiBlockInputInventory.values()); - } - - protected IItemHandlerModifiable getInventoriesForOutput() { - return new ListItemHandler(multiBlockOutputInventory.values()); - } - - protected Widget getFluidInventoryInputGUI() { - final IFluidTank[] tanks = getTanksForInput(); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < tanks.length; rows++) { - final int columnsToMake = Math.min(tanks.length - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - final FluidSlotWidget fluidSlot = new FluidSlotWidget(tanks[rows * 4 + column]); - scrollable.widget( - fluidSlot.setPos(column * 18, rows * 18) - .setSize(18, 18)); - } - } - return scrollable.setSize(18 * 4 + 4, 18 * 5) - .setPos(52, 7); - } - - protected Widget getFluidInventoryOutputGUI() { - final IFluidTank[] tanks = getTanksForOutput(); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < tanks.length; rows++) { - final int columnsToMake = Math.min(tanks.length - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - final FluidSlotWidget fluidSlot = new FluidSlotWidget(tanks[rows * 4 + column]); - fluidSlot.setInteraction(true, false); - scrollable.widget( - fluidSlot.setPos(column * 18, rows * 18) - .setSize(18, 18)); - } - } - return scrollable.setSize(18 * 4 + 4, 18 * 5) - .setPos(52, 7); - } - - @Override - public Pos2d getPowerSwitchButtonPos() { - return new Pos2d(144, 0); - } - - @Override public boolean supportsVoidProtection() { return true; } @@ -2097,23 +911,6 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public List<ItemStack> getItemOutputSlots(ItemStack[] toOutput) { - List<ItemStack> ret = new ArrayList<>(); - IItemHandler inv = getOutputInventory(); - if (inv != null && inv.getSlots() > 0) { - for (int i = 0; i < inv.getSlots(); i++) { - ret.add(inv.getStackInSlot(i)); - } - } - return ret; - } - - @Override - public List<? extends IFluidStore> getFluidOutputSlots(FluidStack[] toOutput) { - return Arrays.asList(getOutputTanks()); - } - - @Override public boolean canDumpItemToME() { return false; } @@ -2124,31 +921,21 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public Pos2d getVoidingModeButtonPos() { - return new Pos2d(54, 0); - } - - @Override public boolean supportsInputSeparation() { return true; } @Override - public boolean isInputSeparationEnabled() { + public boolean isInputSeparated() { return separateInputs; } @Override - public void setInputSeparation(boolean enabled) { + public void setInputSeparation(Boolean enabled) { this.separateInputs = enabled; } @Override - public Pos2d getInputSeparationButtonPos() { - return new Pos2d(36, 0); - } - - @Override public boolean supportsBatchMode() { return true; } @@ -2159,16 +946,11 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public void setBatchMode(boolean mode) { + public void setBatchMode(Boolean mode) { this.batchMode = mode; } @Override - public Pos2d getBatchModeButtonPos() { - return new Pos2d(18, 0); - } - - @Override public boolean supportsSingleRecipeLocking() { return false; } @@ -2179,32 +961,23 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public void setRecipeLocking(boolean enabled) { + public void setRecipeLocking(Boolean enabled) { this.recipeLock = enabled; } @Override - public RecipeMap<?> getRecipeMap() { - return null; - } - - @Override - public Pos2d getRecipeLockingButtonPos() { - return new Pos2d(0, 0); - } - - @Override - public ModularWindow createWindowGUI(UIBuildContext buildContext) { - return createWindow(buildContext); - } - - @Override public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y, int z) { super.getWailaNBTData(player, tile, tag, world, x, y, z); - tag.setLong("progress", progressTime); - tag.setLong("maxProgress", maxProgressTime); + P processing = getProcessingLogic(); + tag.setInteger("progress", processing.getProgress()); + tag.setInteger("maxProgress", processing.getDuration()); tag.setBoolean("structureOkay", structureOkay); + tag.setBoolean("isActive", isActive()); + if (isActive()) { + tag.setLong("energyUsage", getProcessingLogic().getCalculatedEut()); + tag.setLong("energyTier", tier); + } } @Override @@ -2219,8 +992,92 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } if (isSimpleMachine) { boolean isActive = tag.getBoolean("isActive"); - currentTip - .add(GT_Waila.getMachineProgressString(isActive, tag.getLong("maxProgress"), tag.getLong("progress"))); + currentTip.add( + GT_Waila.getMachineProgressString(isActive, tag.getInteger("maxProgress"), tag.getInteger("progress"))); + } + boolean isActive = tag.getBoolean("isActive"); + if (isActive) { + long energyTier = tag.getLong("energyTier"); + long actualEnergyUsage = tag.getLong("energyUsage"); + if (actualEnergyUsage > 0) { + currentTip.add( + StatCollector.translateToLocalFormatted( + "GT5U.waila.energy.use_with_amperage", + GT_Utility.formatNumbers(actualEnergyUsage), + GT_Utility.getAmperageForTier(actualEnergyUsage, (byte) energyTier), + GT_Utility.getColoredTierNameFromTier((byte) energyTier))); + } else if (actualEnergyUsage < 0) { + currentTip.add( + StatCollector.translateToLocalFormatted( + "GT5U.waila.energy.produce_with_amperage", + GT_Utility.formatNumbers(-actualEnergyUsage), + GT_Utility.getAmperageForTier(-actualEnergyUsage, (byte) energyTier), + GT_Utility.getColoredTierNameFromTier((byte) energyTier))); + } } } + + @Override + public GT_Packet_MultiTileEntity getClientDataPacket() { + final GT_Packet_MultiTileEntity packet = super.getClientDataPacket(); + + return packet; + + } + + @Override + public void enableWorking() { + super.enableWorking(); + if (!structureOkay) { + checkStructure(true); + } + } + + @Override + public List<ItemStack> getItemOutputSlots(ItemStack[] toOutput) { + return new ArrayList<>(0); + } + + @Override + public List<? extends IFluidStore> getFluidOutputSlots(FluidStack[] toOutput) { + return new ArrayList<>(0); + } + + @Override + @Nonnull + public Set<Entry<UUID, FluidInventoryLogic>> getAllFluidInventoryLogics(@Nonnull InventoryType type) { + return switch (type) { + case Input -> controllerFluidInput.getAllInventoryLogicsAsEntrySet(); + case Output -> controllerFluidOutput.getAllInventoryLogicsAsEntrySet(); + default -> super.getAllFluidInventoryLogics(type); + }; + } + + @Override + @Nonnull + public Set<Entry<UUID, ItemInventoryLogic>> getAllItemInventoryLogics(@Nonnull InventoryType type) { + return switch (type) { + case Input -> controllerItemInput.getAllInventoryLogicsAsEntrySet(); + case Output -> controllerItemOutput.getAllInventoryLogicsAsEntrySet(); + default -> super.getAllItemInventoryLogics(type); + }; + } + + @Override + public void setWirelessSupport(boolean canUse) { + if (canUse) { + strongCheckOrAddUser(getOwnerUuid(), getOwnerName()); + } + power.setCanUseWireless(canUse, getOwnerUuid()); + } + + @Override + public void setLaserSupport(boolean canUse) { + power.setCanUseLaser(canUse); + } + + @Override + public void setMaxAmperage(long amperage) { + power.setMaxAmperage(amperage); + } } diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java index db9053b0d7..223edc0761 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java @@ -2,7 +2,6 @@ package gregtech.api.multitileentity.multiblock.base; import static com.google.common.math.LongMath.log2; import static gregtech.api.enums.GT_Values.B; -import static gregtech.api.enums.GT_Values.NBT; import static gregtech.api.enums.Textures.BlockIcons.FLUID_IN_SIGN; import static gregtech.api.enums.Textures.BlockIcons.FLUID_OUT_SIGN; import static gregtech.api.enums.Textures.BlockIcons.ITEM_IN_SIGN; @@ -11,13 +10,17 @@ import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ENERGY_IN_MULTI; import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ENERGY_OUT_MULTI; import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PIPE_IN; import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PIPE_OUT; -import static org.apache.commons.lang3.ObjectUtils.firstNonNull; import java.math.RoundingMode; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; +import java.util.HashSet; import java.util.List; +import java.util.Set; +import java.util.UUID; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; @@ -25,44 +28,42 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; +import net.minecraft.util.StatCollector; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.FluidTankInfo; -import net.minecraftforge.fluids.IFluidTank; -import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable; -import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.ModularWindow.Builder; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; import com.gtnewhorizons.modularui.common.widget.DrawableWidget; -import com.gtnewhorizons.modularui.common.widget.DropDownWidget; -import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; -import com.gtnewhorizons.modularui.common.widget.Scrollable; -import com.gtnewhorizons.modularui.common.widget.SlotGroup; -import com.gtnewhorizons.modularui.common.widget.SlotWidget; -import com.gtnewhorizons.modularui.common.widget.TextWidget; - -import gregtech.api.enums.GT_Values; + +import gregtech.api.enums.GT_Values.NBT; +import gregtech.api.enums.InventoryType; import gregtech.api.fluid.FluidTankGT; -import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.gui.GUIHost; +import gregtech.api.gui.GUIProvider; import gregtech.api.interfaces.ITexture; +import gregtech.api.logic.FluidInventoryLogic; +import gregtech.api.logic.ItemInventoryLogic; +import gregtech.api.logic.NullPowerLogic; import gregtech.api.logic.PowerLogic; import gregtech.api.logic.interfaces.PowerLogicHost; +import gregtech.api.multitileentity.MultiTileEntityRegistry; import gregtech.api.multitileentity.base.NonTickableMultiTileEntity; +import gregtech.api.multitileentity.enums.MultiTileCasingPurpose; import gregtech.api.multitileentity.interfaces.IMultiBlockController; import gregtech.api.multitileentity.interfaces.IMultiBlockPart; -import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_BreakBlock; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasModes; import gregtech.api.net.GT_Packet_MultiTileEntity; import gregtech.api.render.TextureFactory; import gregtech.api.util.GT_Utility; import gregtech.common.covers.CoverInfo; +import gregtech.common.gui.PartGUIProvider; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; public abstract class MultiBlockPart extends NonTickableMultiTileEntity - implements IMultiBlockPart, IMTE_BreakBlock, IMTE_HasModes, PowerLogicHost { + implements IMultiBlockPart, IMTE_HasModes, PowerLogicHost, IMultiTileEntity.IMTE_AddToolTips, GUIHost { public static final int NOTHING = 0, ENERGY_IN = B[0], ENERGY_OUT = B[1], FLUID_IN = B[2], FLUID_OUT = B[3], ITEM_IN = B[4], ITEM_OUT = B[5]; @@ -70,16 +71,20 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity protected final List<Integer> BASIC_MODES = new ArrayList<>( Arrays.asList(NOTHING, ENERGY_IN, ENERGY_OUT, FLUID_IN, FLUID_OUT, ITEM_IN, ITEM_OUT)); - protected ChunkCoordinates mTargetPos = null; - protected IMultiBlockController target = null; + protected Set<MultiTileCasingPurpose> registeredPurposes = new HashSet<>(); - protected int mAllowedModes = NOTHING; // BITMASK - Modes allowed for this part - protected byte mMode = 0; // Mode selected for this part + protected ChunkCoordinates targetPosition = null; - protected String mLockedInventory = GT_Values.E; + protected int allowedModes = NOTHING; // BITMASK - Modes allowed for this part + protected int mode = 0; // Mode selected for this part + + protected UUID lockedInventory; protected int mLockedInventoryIndex = 0; protected FluidTankGT configurationTank = new FluidTankGT(); + @Nonnull + protected final GUIProvider<?> guiProvider = createGUIProvider(); + /** * What Part Tier is this part? All Basic Casings are Tier 1, and will allow: Energy, Item, Fluid input/output. Some * of the more advanced modes can be set to require a higher tier part. @@ -88,33 +93,40 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return 1; } - public String getLockedInventory() { - // TODO: Can this cause side-effects? Removed for now because it causes huge network traffic when using covers - // issueClientUpdate(); - IMultiBlockController controller = getTarget(false); - if (modeSelected(ITEM_IN) || modeSelected(ITEM_OUT)) { - if (!getNameOfInventoryFromIndex(controller, mLockedInventoryIndex).equals(mLockedInventory)) { - mLockedInventory = getNameOfInventoryFromIndex(controller, mLockedInventoryIndex); - if (mLockedInventory.equals(Controller.ALL_INVENTORIES_NAME)) { - mLockedInventory = ""; - } - } - } else { - if (!getNameOfTankArrayFromIndex(controller, mLockedInventoryIndex).equals(mLockedInventory)) { - mLockedInventory = getNameOfTankArrayFromIndex(controller, mLockedInventoryIndex); - if (mLockedInventory.equals(Controller.ALL_INVENTORIES_NAME)) { - mLockedInventory = ""; - } + @Override + public UUID getLockedInventory() { + return lockedInventory; + } + + public void setTarget(IMultiBlockController newTarget, int aAllowedModes) { + IMultiBlockController currentTarget = getTarget(false); + if (currentTarget != null && currentTarget != newTarget) { + for (MultiTileCasingPurpose purpose : registeredPurposes) { + unregisterPurpose(purpose); } } - return mLockedInventory.equals("") ? null : mLockedInventory; + targetPosition = (newTarget == null ? null : newTarget.getCoords()); + allowedModes = aAllowedModes; + if (newTarget != null) { + registerCovers(newTarget); + registerPurposes(); + } } - public void setTarget(IMultiBlockController aTarget, int aAllowedModes) { - target = aTarget; - mTargetPos = (target == null ? null : target.getCoords()); - mAllowedModes = aAllowedModes; - if (target != null) registerCovers(target); + protected void registerPurpose(MultiTileCasingPurpose purpose) { + IMultiBlockController target = getTarget(false); + if (target != null) { + target.registerCaseWithPurpose(purpose, this); + registeredPurposes.add(purpose); + } + } + + protected void unregisterPurpose(MultiTileCasingPurpose purpose) { + IMultiBlockController target = getTarget(false); + if (target != null) { + target.unregisterCaseWithPurpose(purpose, this); + } + registeredPurposes.remove(purpose); } @Override @@ -125,14 +137,14 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } else { tList.add("No Controller"); } - tList.add("Casing Mode: " + getModeName(mMode)); + tList.add("Casing Mode: " + getModeName(mode)); } @Override public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { super.getWailaBody(itemStack, currentTip, accessor, config); - currentTip.add(String.format("Mode: %s", getModeName(mMode))); + currentTip.add(String.format("Mode: %s", getModeName(mode))); if (modeSelected(FLUID_OUT)) { if (configurationTank != null && configurationTank.get() != null) { currentTip.add( @@ -147,19 +159,22 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } public IMultiBlockController getTarget(boolean aCheckValidity) { - if (mTargetPos == null) return null; - if (target == null || target.isDead()) { - if (worldObj.blockExists(mTargetPos.posX, mTargetPos.posY, mTargetPos.posZ)) { - final TileEntity te = worldObj.getTileEntity(mTargetPos.posX, mTargetPos.posY, mTargetPos.posZ); - if (te instanceof IMultiBlockController) { - target = (IMultiBlockController) te; - // Register our covers with the controller - registerCovers(target); - } else { - mTargetPos = null; - } - } + if (targetPosition == null) { + return null; + } + + if (!worldObj.blockExists(targetPosition.posX, targetPosition.posY, targetPosition.posZ)) { + return null; + } + final TileEntity te = worldObj.getTileEntity(targetPosition.posX, targetPosition.posY, targetPosition.posZ); + IMultiBlockController target = null; + if (te instanceof IMultiBlockController targetFound) { + target = targetFound; + } else { + targetPosition = null; + return null; } + if (aCheckValidity) { return target != null && target.checkStructure(false) ? target : null; } @@ -175,17 +190,26 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } } + protected void registerPurposes() { + for (MultiTileCasingPurpose purpose : registeredPurposes) { + registerPurpose(purpose); + } + } + @Override public void setCoverItemAtSide(ForgeDirection side, ItemStack aCover) { super.setCoverItemAtSide(side, aCover); // TODO: Filter on tickable covers final IMultiBlockController tTarget = getTarget(true); - if (tTarget != null) { - final CoverInfo coverInfo = getCoverInfoAtSide(side); - if (coverInfo.isValid() && coverInfo.getTickRate() > 0) { - tTarget.registerCoveredPartOnSide(side, this); - } + if (tTarget == null) { + return; } + + final CoverInfo coverInfo = getCoverInfoAtSide(side); + if (coverInfo.isValid() && coverInfo.getTickRate() > 0) { + tTarget.registerCoveredPartOnSide(side, this); + } + } public void unregisterCovers(IMultiBlockController controller) { @@ -208,16 +232,16 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public void readMultiTileNBT(NBTTagCompound aNBT) { - if (aNBT.hasKey(NBT.ALLOWED_MODES)) mAllowedModes = aNBT.getInteger(NBT.ALLOWED_MODES); - if (aNBT.hasKey(NBT.MODE)) mMode = aNBT.getByte(NBT.MODE); + if (aNBT.hasKey(NBT.ALLOWED_MODES)) allowedModes = aNBT.getInteger(NBT.ALLOWED_MODES); + if (aNBT.hasKey(NBT.MODE)) setMode(aNBT.getByte(NBT.MODE)); if (aNBT.hasKey(NBT.TARGET)) { - mTargetPos = new ChunkCoordinates( + targetPosition = new ChunkCoordinates( aNBT.getInteger(NBT.TARGET_X), aNBT.getShort(NBT.TARGET_Y), aNBT.getInteger(NBT.TARGET_Z)); } if (aNBT.hasKey(NBT.LOCKED_INVENTORY)) { - mLockedInventory = aNBT.getString(NBT.LOCKED_INVENTORY); + lockedInventory = UUID.fromString(aNBT.getString(NBT.LOCKED_INVENTORY)); } if (aNBT.hasKey(NBT.LOCKED_INVENTORY_INDEX)) { mLockedInventoryIndex = aNBT.getInteger(NBT.LOCKED_INVENTORY_INDEX); @@ -225,20 +249,26 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity if (aNBT.hasKey(NBT.LOCKED_FLUID)) { configurationTank.readFromNBT(aNBT, NBT.LOCKED_FLUID); } + if (modeSelected(ITEM_OUT)) { + registeredPurposes.add(MultiTileCasingPurpose.ItemOutput); + } + if (modeSelected(FLUID_OUT)) { + registeredPurposes.add(MultiTileCasingPurpose.FluidOutput); + } } @Override public void writeMultiTileNBT(NBTTagCompound aNBT) { - if (mAllowedModes != NOTHING) aNBT.setInteger(NBT.ALLOWED_MODES, mAllowedModes); - if (mMode != 0) aNBT.setInteger(NBT.MODE, mMode); - if (mTargetPos != null) { + if (allowedModes != NOTHING) aNBT.setInteger(NBT.ALLOWED_MODES, allowedModes); + if (mode != 0) aNBT.setInteger(NBT.MODE, mode); + if (targetPosition != null) { aNBT.setBoolean(NBT.TARGET, true); - aNBT.setInteger(NBT.TARGET_X, mTargetPos.posX); - aNBT.setShort(NBT.TARGET_Y, (short) mTargetPos.posY); - aNBT.setInteger(NBT.TARGET_Z, mTargetPos.posZ); + aNBT.setInteger(NBT.TARGET_X, targetPosition.posX); + aNBT.setShort(NBT.TARGET_Y, (short) targetPosition.posY); + aNBT.setInteger(NBT.TARGET_Z, targetPosition.posZ); } - if (mLockedInventory != null) { - aNBT.setString(NBT.LOCKED_INVENTORY, mLockedInventory); + if (lockedInventory != null) { + aNBT.setString(NBT.LOCKED_INVENTORY, lockedInventory.toString()); } if (mLockedInventoryIndex != 0) { aNBT.setInteger(NBT.LOCKED_INVENTORY_INDEX, mLockedInventoryIndex); @@ -270,34 +300,47 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public void setTargetPos(ChunkCoordinates aTargetPos) { - mTargetPos = aTargetPos; - IMultiBlockController mTarget = getTarget(false); - setTarget(mTarget, mAllowedModes); + targetPosition = aTargetPos; + IMultiBlockController target = getTarget(false); + setTarget(target, allowedModes); } @Override public ChunkCoordinates getTargetPos() { - return mTargetPos; + return targetPosition; } @Override - public void setMode(byte aMode) { - mMode = aMode; + public void setMode(int mode) { + if (this.mode == mode) return; + if (modeSelected(FLUID_OUT)) { + unregisterPurpose(MultiTileCasingPurpose.FluidOutput); + } + if (modeSelected(ITEM_OUT)) { + unregisterPurpose(MultiTileCasingPurpose.ItemOutput); + } + this.mode = mode; + if (modeSelected(FLUID_OUT)) { + registerPurpose(MultiTileCasingPurpose.FluidOutput); + } + if (modeSelected(ITEM_OUT)) { + registerPurpose(MultiTileCasingPurpose.ItemOutput); + } } @Override - public byte getMode() { - return mMode; + public int getMode() { + return mode; } @Override public int getAllowedModes() { - return mAllowedModes; + return allowedModes; } @Override public void setAllowedModes(int aAllowedModes) { - mAllowedModes = aAllowedModes; + allowedModes = aAllowedModes; } /** @@ -305,7 +348,7 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity */ public boolean hasMode(int aMode) { // This is not sent to the client - return (mAllowedModes & aMode) != 0; + return (allowedModes & aMode) != 0; } /** @@ -313,7 +356,7 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity */ public boolean modeSelected(int... aModes) { for (int aMode : aModes) { - if (hasMode(aMode) && mMode == getModeOrdinal(aMode)) return true; + if (hasMode(aMode) && mode == getModeOrdinal(aMode)) return true; } return false; } @@ -344,39 +387,39 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public ITexture getTexture(ForgeDirection side) { ITexture texture = super.getTexture(side); - if (mMode != 0 && side == facing) { - if (mMode == getModeOrdinal(ITEM_IN)) { + if (mode != 0 && side == facing) { + if (mode == getModeOrdinal(ITEM_IN)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_IN), TextureFactory.of(ITEM_IN_SIGN), getCoverTexture(side)); } - if (mMode == getModeOrdinal(ITEM_OUT)) { + if (mode == getModeOrdinal(ITEM_OUT)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_OUT), TextureFactory.of(ITEM_OUT_SIGN), getCoverTexture(side)); } - if (mMode == getModeOrdinal(FLUID_IN)) { + if (mode == getModeOrdinal(FLUID_IN)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_IN), TextureFactory.of(FLUID_IN_SIGN), getCoverTexture(side)); } - if (mMode == getModeOrdinal(FLUID_OUT)) { + if (mode == getModeOrdinal(FLUID_OUT)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_OUT), TextureFactory.of(FLUID_OUT_SIGN), getCoverTexture(side)); } - if (mMode == getModeOrdinal(ENERGY_IN)) { + if (mode == getModeOrdinal(ENERGY_IN)) { return TextureFactory.of(texture, TextureFactory.of(OVERLAY_ENERGY_IN_MULTI), getCoverTexture(side)); } - if (mMode == getModeOrdinal(ENERGY_OUT)) { + if (mode == getModeOrdinal(ENERGY_OUT)) { return TextureFactory.of(texture, TextureFactory.of(OVERLAY_ENERGY_OUT_MULTI), getCoverTexture(side)); } } @@ -384,11 +427,6 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return TextureFactory.of(texture, getCoverTexture(side)); } - @Override - public boolean isUseableByPlayer(EntityPlayer entityPlayer) { - return false; - } - protected String getModeName(int aMode) { if (aMode == NOTHING) return "Nothing"; if (aMode == getModeOrdinal(ITEM_IN)) return "Item Input"; @@ -407,11 +445,11 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } protected byte getNextAllowedMode(List<Integer> allowedModes) { - if (mAllowedModes == NOTHING) return NOTHING; + if (this.allowedModes == NOTHING) return NOTHING; final int numModes = allowedModes.size(); for (byte i = 1; i <= numModes; i++) { - final byte curMode = (byte) ((mMode + i) % numModes); + final byte curMode = (byte) ((mode + i) % numModes); if (curMode == NOTHING || hasMode(1 << (curMode - 1))) return curMode; } // Nothing valid found @@ -420,16 +458,16 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public boolean onMalletRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, - float aY, float aZ, ItemStack aTool) { - if (mAllowedModes == NOTHING) return true; - if (mMode == NOTHING) { + float aY, float aZ) { + if (allowedModes == NOTHING) return true; + if (mode == NOTHING) { facing = wrenchSide; } - mMode = getNextAllowedMode(BASIC_MODES); + setMode(getNextAllowedMode(BASIC_MODES)); if (aPlayer.isSneaking()) { facing = wrenchSide; } - GT_Utility.sendChatToPlayer(aPlayer, "Mode set to `" + getModeName(mMode) + "' (" + mMode + ")"); + GT_Utility.sendChatToPlayer(aPlayer, "Mode set to `" + getModeName(mode) + "' (" + mode + ")"); sendClientData((EntityPlayerMP) aPlayer); return true; } @@ -447,109 +485,50 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return "gt.multitileentity.multiblock.part"; } + @Override + public boolean shouldTick(long tickTimer) { + return modeSelected(ITEM_OUT, FLUID_OUT); + } + /** * TODO: Make sure the energy/item/fluid hatch is facing that way! or has that mode enabled on that side Check * SIDE_UNKNOWN for or coverbehavior */ - /** - * Fluid - Depending on the part type - proxy it to the multiblock controller, if we have one - */ + // #region Fluid - Depending on the part type - proxy it to the multiblock controller, if we have one @Override - public int fill(ForgeDirection aDirection, FluidStack aFluidStack, boolean aDoFill) { - if (!modeSelected(FLUID_IN)) return 0; + @Nullable + public FluidInventoryLogic getFluidLogic(@Nonnull ForgeDirection side, @Nonnull InventoryType type) { + if (side != facing && side != ForgeDirection.UNKNOWN) return null; - if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return 0; - if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(aDirection) != 0 || !coverLetsFluidIn(aDirection, aFluidStack.getFluid()))) return 0; - final IMultiBlockController controller = getTarget(true); - return controller == null ? 0 : controller.fill(this, aDirection, aFluidStack, aDoFill); - } + if (!modeSelected(FLUID_IN, FLUID_OUT)) return null; - @Override - public FluidStack drain(ForgeDirection aDirection, FluidStack aFluidStack, boolean aDoDrain) { - if (!modeSelected(FLUID_OUT)) return null; - if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return null; - if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluidStack.getFluid()))) - return null; - final IMultiBlockController controller = getTarget(true); - return controller == null ? null : controller.drain(this, aDirection, aFluidStack, aDoDrain); - } - - @Override - public FluidStack drain(ForgeDirection aDirection, int aAmountToDrain, boolean aDoDrain) { - if (!modeSelected(FLUID_OUT)) return null; - final IMultiBlockController controller = getTarget(true); + IMultiBlockController controller = getTarget(false); if (controller == null) return null; - FluidStack aFluidStack = null; - if (getLockedFluid() != null) { - aFluidStack = controller.getDrainableFluid(aDirection, getLockedFluid()); - } else { - aFluidStack = controller.getDrainableFluid(aDirection); - } - if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return null; - if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluidStack.getFluid()))) - return null; - return controller.drain(this, aDirection, aFluidStack, aDoDrain); - } - - @Override - public boolean canFill(ForgeDirection aDirection, Fluid aFluid) { - if (!modeSelected(FLUID_IN)) return false; - - if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(aDirection) != 0 || !coverLetsFluidIn(aDirection, aFluid))) return false; - if (isWrongFluid(aFluid)) return false; - final IMultiBlockController controller = getTarget(true); - return controller != null && controller.canFill(this, aDirection, aFluid); + return controller + .getFluidLogic(modeSelected(FLUID_IN) ? InventoryType.Input : InventoryType.Output, lockedInventory); } - @Override - public boolean canDrain(ForgeDirection aDirection, Fluid aFluid) { - if (!modeSelected(FLUID_OUT)) return false; - if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluid))) return false; - if (isWrongFluid(aFluid)) return false; - final IMultiBlockController controller = getTarget(true); - return controller != null && controller.canDrain(this, aDirection, aFluid); - } - - @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aDirection) { - if (!modeSelected(FLUID_IN, FLUID_OUT) - || (aDirection != ForgeDirection.UNKNOWN && facing.compareTo(aDirection) != 0)) - return GT_Values.emptyFluidTankInfo; - final IMultiBlockController controller = getTarget(true); - if (controller == null) return GT_Values.emptyFluidTankInfo; - - final CoverInfo coverInfo = getCoverInfoAtSide(aDirection); - - if ((controller.isLiquidInput(aDirection) && coverInfo.letsFluidIn(null, controller)) - || (controller.isLiquidOutput(aDirection) && coverInfo.letsFluidOut(null, controller))) - return controller.getTankInfo(this, aDirection); - - return GT_Values.emptyFluidTankInfo; - } + // #endregion Fluid // #region Energy - Depending on the part type - proxy to the multiblock controller, if we have one @Override - public PowerLogic getPowerLogic(ForgeDirection side) { - if (facing == side) { - return null; + @Nonnull + public PowerLogic getPowerLogic(@Nonnull ForgeDirection side) { + if (side != facing && side != ForgeDirection.UNKNOWN) { + return new NullPowerLogic(); } if (!modeSelected(ENERGY_IN, ENERGY_OUT)) { - return null; + return new NullPowerLogic(); } final IMultiBlockController controller = getTarget(true); if (controller == null) { - return null; + return new NullPowerLogic(); } - return controller.getPowerLogic(this, side); + return controller.getPowerLogic(); } @Override @@ -562,119 +541,32 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return modeSelected(ENERGY_OUT); } - // #endregion - - /** - * Inventory - Depending on the part type - proxy to the multiblock controller, if we have one - */ - @Override - public boolean hasInventoryBeenModified() { - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.hasInventoryBeenModified(this)); - } - - @Override - public boolean isValidSlot(int aIndex) { - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.isValidSlot(this, aIndex)); - } - - @Override - public boolean addStackToSlot(int aIndex, ItemStack aStack) { - if (!modeSelected(ITEM_IN, ITEM_OUT)) return false; - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.addStackToSlot(this, aIndex, aStack)); - } - - @Override - public boolean addStackToSlot(int aIndex, ItemStack aStack, int aAmount) { - if (!modeSelected(ITEM_IN, ITEM_OUT)) return false; - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.addStackToSlot(this, aIndex, aStack, aAmount)); - } + // #endregion Energy - @Override - public int[] getAccessibleSlotsFromSide(int ordinalSide) { - final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); - if (!modeSelected(ITEM_IN, ITEM_OUT) || (facing != ForgeDirection.UNKNOWN && facing.compareTo(side) != 0)) - return GT_Values.emptyIntArray; - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getAccessibleSlotsFromSide(this, side) : GT_Values.emptyIntArray; - } + // #region Item - Depending on the part type - proxy to the multiblock controller, if we have one @Override - public boolean canInsertItem(int aSlot, ItemStack aStack, int ordinalSide) { - final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); - if (!modeSelected(ITEM_IN, ITEM_OUT) - || (facing != ForgeDirection.UNKNOWN && (facing.compareTo(side) != 0 || !coverLetsItemsIn(side, aSlot)))) - return false; - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.canInsertItem(this, aSlot, aStack, side)); - } + @Nullable + public ItemInventoryLogic getItemLogic(@Nonnull ForgeDirection side, @Nonnull InventoryType unused) { + if (side != facing && side != ForgeDirection.UNKNOWN) return null; - @Override - public boolean canExtractItem(int aSlot, ItemStack aStack, int ordinalSide) { - final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); - if (!modeSelected(ITEM_IN, ITEM_OUT) - || (facing != ForgeDirection.UNKNOWN && (facing.compareTo(side) != 0 || !coverLetsItemsOut(side, aSlot)))) - return false; - final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.canExtractItem(this, aSlot, aStack, side)); - } - - @Override - public int getSizeInventory() { - if (!modeSelected(ITEM_IN, ITEM_OUT)) return 0; - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getSizeInventory(this) : 0; - } - - @Override - public ItemStack getStackInSlot(int aSlot) { if (!modeSelected(ITEM_IN, ITEM_OUT)) return null; - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getStackInSlot(this, aSlot) : null; - } - - @Override - public ItemStack decrStackSize(int aSlot, int aDecrement) { - if (!modeSelected(ITEM_IN, ITEM_OUT)) return null; - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.decrStackSize(this, aSlot, aDecrement) : null; - } - @Override - public ItemStack getStackInSlotOnClosing(int aSlot) { - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getStackInSlotOnClosing(this, aSlot) : null; - } - - @Override - public void setInventorySlotContents(int aSlot, ItemStack aStack) { - final IMultiBlockController controller = getTarget(true); - if (controller != null) controller.setInventorySlotContents(this, aSlot, aStack); - } - - @Override - public String getInventoryName() { - final IMultiBlockController controller = getTarget(true); - if (controller != null) return controller.getInventoryName(this); - return firstNonNull(getCustomName(), getTileEntityName()); - } + final IMultiBlockController controller = getTarget(false); + if (controller == null) return null; - @Override - public int getInventoryStackLimit() { - final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getInventoryStackLimit(this) : 0; + return controller + .getItemLogic(modeSelected(ITEM_IN) ? InventoryType.Input : InventoryType.Output, lockedInventory); } @Override - public boolean isItemValidForSlot(int aSlot, ItemStack aStack) { - final IMultiBlockController controller = getTarget(true); - return controller != null && controller.isItemValidForSlot(this, aSlot, aStack); + @Nullable + public InventoryType getItemInventoryType() { + if (!modeSelected(ITEM_IN, ITEM_OUT)) return InventoryType.Both; + return modeSelected(ITEM_IN) ? InventoryType.Input : InventoryType.Output; } - // End Inventory + // #endregion Item // === Modular UI === @Override @@ -700,62 +592,6 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return getTarget(true) != null; } - protected void addItemInventory(Builder builder, UIBuildContext buildContext) { - final IMultiBlockController controller = getTarget(false); - if (controller == null) { - return; - } - final IItemHandlerModifiable inv = controller.getInventoryForGUI(this); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < Math.min(inv.getSlots(), 128); rows++) { - int columnsToMake = Math.min(Math.min(inv.getSlots(), 128) - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - scrollable.widget( - new SlotWidget(inv, rows * 4 + column).setPos(column * 18, rows * 18) - .setSize(18, 18)); - } - } - builder.widget( - scrollable.setSize(18 * 4 + 4, 18 * 4) - .setPos(52, 18)); - DropDownWidget dropDown = new DropDownWidget(); - dropDown.addDropDownItemsSimple( - controller.getInventoryNames(this), - (buttonWidget, index, label, setSelected) -> buttonWidget.setOnClick((clickData, widget) -> { - if (getNameOfInventoryFromIndex(controller, index).equals(Controller.ALL_INVENTORIES_NAME)) { - mLockedInventory = GT_Values.E; - mLockedInventoryIndex = 0; - } else { - mLockedInventory = getNameOfInventoryFromIndex(controller, index); - mLockedInventoryIndex = index; - } - setSelected.run(); - }), - true); - builder.widget( - dropDown.setSelected(mLockedInventoryIndex) - .setExpandedMaxHeight(60) - .setDirection(DropDownWidget.Direction.DOWN) - .setPos(53, 5) - .setSize(70, 11)); - } - - protected String getNameOfInventoryFromIndex(final IMultiBlockController controller, int index) { - final List<String> invNames = controller.getInventoryIDs(this); - if (index > invNames.size()) { - return invNames.get(0); - } - return invNames.get(index); - } - - protected String getNameOfTankArrayFromIndex(final IMultiBlockController controller, int index) { - final List<String> tankNames = controller.getTankArrayIDs(this); - if (index > tankNames.size()) { - return tankNames.get(0); - } - return tankNames.get(index); - } - protected boolean isWrongFluid(Fluid fluid) { if (fluid == null) { return true; @@ -776,98 +612,34 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity return null; } - protected void addFluidInventory(Builder builder, UIBuildContext buildContext) { - final IMultiBlockController controller = getTarget(false); + @Override + public void addUIWidgets(Builder builder, UIBuildContext buildContext) { + super.addUIWidgets(builder, buildContext); + IMultiBlockController controller = getTarget(false); if (controller == null) { return; } - builder.widget( - new DrawableWidget().setDrawable(GT_UITextures.PICTURE_SCREEN_BLACK) - .setPos(7, 4) - .setSize(85, 95)); - if (modeSelected(FLUID_OUT)) { + if ((modeSelected(ITEM_IN, ITEM_OUT))) { builder.widget( - new DrawableWidget().setDrawable(GT_UITextures.PICTURE_SCREEN_BLACK) - .setPos(getGUIWidth() - 77, 4) - .setSize(70, 40)) - .widget( - new TextWidget("Locked Fluid").setDefaultColor(COLOR_TEXT_WHITE.get()) - .setPos(getGUIWidth() - 72, 8)); - } - final IFluidTank[] tanks = controller.getFluidTanksForGUI(this); - final Scrollable scrollable = new Scrollable().setVerticalScroll(); - for (int rows = 0; rows * 4 < tanks.length; rows++) { - int columnsToMake = Math.min(tanks.length - rows * 4, 4); - for (int column = 0; column < columnsToMake; column++) { - FluidSlotWidget fluidSlot = new FluidSlotWidget(tanks[rows * 4 + column]); - if (modeSelected(FLUID_OUT)) { - fluidSlot.setInteraction(true, false); - } - scrollable.widget( - fluidSlot.setPos(column * 18, rows * 18) - .setSize(18, 18)); - } + controller + .getItemLogic(modeSelected(ITEM_IN) ? InventoryType.Input : InventoryType.Output, lockedInventory) + .getGuiPart() + .setSize(18 * 4 + 4, 18 * 5) + .setPos(52, 7)); } - builder.widget( - scrollable.setSize(18 * 4 + 4, 18 * 4) - .setPos(12, 21)); - DropDownWidget dropDown = new DropDownWidget(); - dropDown.addDropDownItemsSimple( - controller.getTankArrayNames(this), - (buttonWidget, index, label, setSelected) -> buttonWidget.setOnClick((clickData, widget) -> { - if (getNameOfTankArrayFromIndex(controller, index).equals(Controller.ALL_INVENTORIES_NAME)) { - mLockedInventory = GT_Values.E; - mLockedInventoryIndex = 0; - } else { - mLockedInventory = getNameOfTankArrayFromIndex(controller, index); - mLockedInventoryIndex = index; - } - setSelected.run(); - }), - true); - builder.widget( - dropDown.setSelected(mLockedInventoryIndex) - .setExpandedMaxHeight(60) - .setDirection(DropDownWidget.Direction.DOWN) - .setPos(13, 8) - .setSize(70, 11)); - } - @Override - public void addUIWidgets(Builder builder, UIBuildContext buildContext) { - if (modeSelected(ITEM_IN, ITEM_OUT)) { - addItemInventory(builder, buildContext); - return; - } - if (modeSelected(FLUID_IN, FLUID_OUT)) { - addFluidInventory(builder, buildContext); - if (modeSelected(FLUID_OUT)) { - builder.widget( - SlotGroup.ofFluidTanks(Collections.singletonList(configurationTank), 1) - .startFromSlot(0) - .endAtSlot(0) - .phantom(true) - .build() - .setPos(getGUIWidth() - 72, 20)); - } - return; + if ((modeSelected(FLUID_IN, FLUID_OUT))) { + builder.widget( + controller + .getFluidLogic(modeSelected(FLUID_IN) ? InventoryType.Input : InventoryType.Output, lockedInventory) + .getGuiPart() + .setSize(18 * 4 + 4, 18 * 5) + .setPos(52, 7)); } } - @Override - public ModularWindow createWindow(UIBuildContext buildContext) { - if (isServerSide()) { - issueClientUpdate(); - } - System.out.println("MultiBlockPart::createWindow"); - if (modeSelected(NOTHING, ENERGY_IN, ENERGY_OUT) || mMode == NOTHING) { - IMultiBlockController controller = getTarget(false); - if (controller == null) { - return super.createWindow(buildContext); - } - return controller.createWindowGUI(buildContext); - } - return super.createWindow(buildContext); + protected boolean canOpenControllerGui() { + return true; } @Override @@ -891,4 +663,62 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity super.addGregTechLogo(builder); } } + + @Override + public void addToolTips(List<String> list, ItemStack stack, boolean f3_h) { + list.add("A MultiTileEntity Casing"); + } + + public String getInventoryName() { + IMultiBlockController controller = getTarget(false); + if (controller == null) return ""; + if (modeSelected(ITEM_IN, ITEM_OUT)) { + InventoryType type = modeSelected(ITEM_IN) ? InventoryType.Input : InventoryType.Output; + ItemInventoryLogic itemLogic = controller.getItemLogic(type, lockedInventory); + return itemLogic.getDisplayName(); + } + if (modeSelected(FLUID_IN, FLUID_OUT)) { + InventoryType type = modeSelected(FLUID_IN) ? InventoryType.Input : InventoryType.Output; + FluidInventoryLogic fluidLogic = controller.getFluidLogic(type, lockedInventory); + return fluidLogic.getDisplayName(); + } + return ""; + } + + @Override + @Nonnull + public ForgeDirection getPowerOutputSide() { + if (!modeSelected(ENERGY_OUT)) return ForgeDirection.UNKNOWN; + return facing; + } + + @Nonnull + protected GUIProvider<?> createGUIProvider() { + return new PartGUIProvider<>(this); + } + + @Override + @Nonnull + public GUIProvider<?> getGUI(@Nonnull UIBuildContext uiContext) { + IMultiBlockController controller = getTarget(false); + if (controller == null) return guiProvider; + if (!modeSelected(NOTHING, ENERGY_IN, ENERGY_OUT)) return guiProvider; + if (!canOpenControllerGui()) return guiProvider; + if (uiContext.getPlayer() + .isSneaking()) return guiProvider; + GUIProvider<?> controllerGUI = controller.getGUI(uiContext); + return controllerGUI; + } + + @Override + public ItemStack getAsItem() { + return MultiTileEntityRegistry.getRegistry(getMultiTileEntityRegistryID()) + .getItem(getMultiTileEntityID()); + } + + @Override + public String getMachineName() { + return StatCollector.translateToLocal(getAsItem().getUnlocalizedName()); + } + } diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/PowerController.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/PowerController.java deleted file mode 100644 index 532f171717..0000000000 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/PowerController.java +++ /dev/null @@ -1,92 +0,0 @@ -package gregtech.api.multitileentity.multiblock.base; - -import java.util.List; - -import net.minecraft.entity.player.EntityPlayerMP; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.StatCollector; -import net.minecraft.world.World; -import net.minecraftforge.common.util.ForgeDirection; - -import gregtech.api.enums.GT_Values; -import gregtech.api.logic.PowerLogic; -import gregtech.api.logic.interfaces.PowerLogicHost; -import gregtech.api.util.GT_Utility; -import mcp.mobius.waila.api.IWailaConfigHandler; -import mcp.mobius.waila.api.IWailaDataAccessor; - -public abstract class PowerController<T extends PowerController<T>> extends Controller<T> implements PowerLogicHost { - - public PowerController() { - super(); - power = new PowerLogic().setType(PowerLogic.RECEIVER); - } - - protected PowerLogic power; - - @Override - public void writeMultiTileNBT(NBTTagCompound nbt) { - super.writeMultiTileNBT(nbt); - power.writeToNBT(nbt); - } - - @Override - public void readMultiTileNBT(NBTTagCompound nbt) { - super.readMultiTileNBT(nbt); - power.loadFromNBT(nbt); - } - - @Override - public PowerLogic getPowerLogic(ForgeDirection side) { - return power; - } - - @Override - public boolean checkMachine() { - boolean result = super.checkMachine(); - power.setEnergyCapacity(GT_Values.V[tier] * 2 * 60 * 20); - power.setAmperage(2); - power.setMaxVoltage(GT_Values.V[tier]); - return result; - } - - @Override - public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y, - int z) { - super.getWailaNBTData(player, tile, tag, world, x, y, z); - tag.setBoolean("isActive", isActive()); - if (isActive()) { - tag.setLong("energyUsage", eut); - tag.setLong("energyTier", tier); - } - } - - @Override - public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, - IWailaConfigHandler config) { - super.getWailaBody(itemStack, currentTip, accessor, config); - final NBTTagCompound tag = accessor.getNBTData(); - boolean isActive = tag.getBoolean("isActive"); - if (isActive) { - long energyTier = tag.getLong("energyTier"); - long actualEnergyUsage = tag.getLong("energyUsage"); - if (actualEnergyUsage > 0) { - currentTip.add( - StatCollector.translateToLocalFormatted( - "GT5U.waila.energy.use_with_amperage", - GT_Utility.formatNumbers(actualEnergyUsage), - GT_Utility.getAmperageForTier(actualEnergyUsage, (byte) energyTier), - GT_Utility.getColoredTierNameFromTier((byte) energyTier))); - } else if (actualEnergyUsage < 0) { - currentTip.add( - StatCollector.translateToLocalFormatted( - "GT5U.waila.energy.produce_with_amperage", - GT_Utility.formatNumbers(-actualEnergyUsage), - GT_Utility.getAmperageForTier(-actualEnergyUsage, (byte) energyTier), - GT_Utility.getColoredTierNameFromTier((byte) energyTier))); - } - } - } -} diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableController.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableController.java index 90a2742290..51feb363dd 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableController.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableController.java @@ -4,11 +4,15 @@ import net.minecraft.item.ItemStack; import com.gtnewhorizon.structurelib.util.Vec3Impl; -public abstract class StackableController<T extends StackableController<T>> extends PowerController<T> { +import gregtech.api.logic.MuTEProcessingLogic; - protected static String STACKABLE_TOP = "STACKABLE_TOP"; +public abstract class StackableController<C extends StackableController<C, P>, P extends MuTEProcessingLogic<P>> + extends Controller<C, P> { + + protected static String STACKABLE_STOP = "STACKABLE_STOP"; protected static String STACKABLE_MIDDLE = "STACKABLE_MIDDLE"; - protected static String STACKABLE_BOTTOM = "STACKABLE_BOTTOM"; + protected static String STACKABLE_START = "STACKABLE_START"; + protected int stackCount = 0; /** * construct implementation for stackable multi-blocks @@ -19,16 +23,16 @@ public abstract class StackableController<T extends StackableController<T>> exte final int stackCount = Math.min(blueprintCount, getMaxStacks()); buildState.startBuilding(getStartingStructureOffset()); - buildPiece(STACKABLE_BOTTOM, trigger, hintsOnly, buildState.getCurrentOffset()); + buildPiece(getStackableStart(), trigger, hintsOnly, buildState.getCurrentOffset()); buildState.addOffset(getStartingStackOffset()); for (int i = 0; i < stackCount; i++) { - buildPiece(STACKABLE_MIDDLE, trigger, hintsOnly, buildState.getCurrentOffset()); + buildPiece(getStackableMiddle(i), trigger, hintsOnly, buildState.getCurrentOffset()); buildState.addOffset(getPerStackOffset()); } if (hasTop()) { buildState.addOffset(getAfterLastStackOffset()); - buildPiece(STACKABLE_TOP, trigger, hintsOnly, buildState.stopBuilding()); + buildPiece(getStackableStop(), trigger, hintsOnly, buildState.stopBuilding()); } else { buildState.stopBuilding(); } @@ -85,27 +89,40 @@ public abstract class StackableController<T extends StackableController<T>> exte */ @Override public boolean checkMachine() { - int stackCount = 0; + stackCount = 0; buildState.startBuilding(getStartingStructureOffset()); - if (!checkPiece(STACKABLE_BOTTOM, buildState.getCurrentOffset())) return buildState.failBuilding(); + if (!checkPiece(getStackableStart(), buildState.getCurrentOffset())) return buildState.failBuilding(); buildState.addOffset(getStartingStackOffset()); for (int i = 0; i < getMaxStacks(); i++) { - if (checkPiece(STACKABLE_MIDDLE, buildState.getCurrentOffset())) { - buildState.addOffset(getPerStackOffset()); - stackCount++; - } else { + if (!checkPiece(getStackableMiddle(i), buildState.getCurrentOffset())) { break; } + + buildState.addOffset(getPerStackOffset()); + stackCount++; + } if (stackCount < getMinStacks()) return buildState.failBuilding(); buildState.addOffset(getAfterLastStackOffset()); - if (!checkPiece(STACKABLE_TOP, buildState.stopBuilding())) { + if (!checkPiece(getStackableStop(), buildState.stopBuilding())) { return buildState.failBuilding(); } return super.checkMachine(); } + + protected String getStackableStop() { + return STACKABLE_STOP; + } + + protected String getStackableMiddle(int stackIndex) { + return STACKABLE_MIDDLE; + } + + protected String getStackableStart() { + return STACKABLE_START; + } } diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableModularController.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableModularController.java new file mode 100644 index 0000000000..1dfd497151 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/StackableModularController.java @@ -0,0 +1,77 @@ +package gregtech.api.multitileentity.multiblock.base; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +import org.jetbrains.annotations.NotNull; + +import gregtech.api.logic.MuTEProcessingLogic; +import gregtech.api.multitileentity.interfaces.UpgradableModularMuTE; +import gregtech.api.util.GT_StructureUtilityMuTE.UpgradeCasings; + +public abstract class StackableModularController<C extends StackableModularController<C, P>, P extends MuTEProcessingLogic<P>> + extends StackableController<C, P> implements UpgradableModularMuTE { + + protected double durationMultiplier = 1; + protected double euTickMultiplier = 1; + + private Map<UpgradeCasings, int[]> mucMap; + + protected @NotNull Map<UpgradeCasings, int[]> getMucMap() { + if (mucMap == null) { + mucMap = createMucMap(); + } + return mucMap; + } + + protected static @NotNull Map<UpgradeCasings, int[]> createMucMap() { + Map<UpgradeCasings, int[]> mucCount = new HashMap<>(); + mucCount.put(UpgradeCasings.Heater, new int[] { 0, 0, 0, 0, 0 }); + mucCount.put(UpgradeCasings.Insulator, new int[] { 0, 0, 0, 0, 0 }); + return mucCount; + } + + @Override + public void increaseMucCount(UpgradeCasings casingType, int tier) { + Map<UpgradeCasings, int[]> mucCounters = getMucMap(); + int[] casingCount = mucCounters.get(casingType); + + switch (tier) { + case 0, 1, 2 -> casingCount[0] += 1; + case 3, 4, 5 -> casingCount[1] += 1; + case 6, 7, 8 -> casingCount[2] += 1; + case 9, 10, 11 -> casingCount[3] += 1; + default -> casingCount[4] += 1; + } + } + + @Override + public void resetMucCount() { + Map<UpgradeCasings, int[]> mucCounters = getMucMap(); + mucCounters.forEach((type, casingCount) -> { Arrays.fill(casingCount, 0); }); + } + + // Returns the cheapest MUC that is possible for the multi, which gets the minimum bonuses. + protected abstract UpgradeCasings getBaseMucType(); + + // Minimum parallel bonus per MUC. Higher tier MUCs multiply with this value for even more parallels. + protected abstract int getParallelFactor(); + + protected void calculateParallels() { + int parallelCount = 0; + int parallelFactor = getParallelFactor(); + int[] parallelCasingList = mucMap.get(getBaseMucType()); + + for (int i = 0; i < 5; i++) { + // (i * 3 + 1) -> Convert MUC tier into minimum GT tier, in groups of 3 (LV, EV, LuV, UHV, UMV) + // If higher than multi tier, upgrade casing has no effect + if (i * 3 + 1 <= tier) { + parallelCount += parallelCasingList[i] * (i + 1) * parallelFactor; + } + } + maxParallel = parallelCount == 0 ? 1 : parallelCount; + } + + protected abstract boolean calculateMucMultipliers(); +} diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java index 62beb64022..ccde0c49e6 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java @@ -2,6 +2,7 @@ package gregtech.api.multitileentity.multiblock.base; import java.util.ArrayList; import java.util.List; +import java.util.UUID; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; @@ -12,50 +13,39 @@ import gregtech.api.multitileentity.interfaces.IMultiBlockController; public class WallShareablePart extends MultiBlockPart { protected List<ChunkCoordinates> targetPositions = new ArrayList<>(); - protected List<IMultiBlockController> targets = new ArrayList<>(); @Override public void setTarget(IMultiBlockController aTarget, int aAllowedModes) { - if (targets.size() > 1 || targetPositions.size() > 1) { - mAllowedModes = 0; - mMode = 0; + if (targetPositions.size() >= 1) { + allowedModes = 0; + setMode((byte) 0); + targetPosition = null; } else { - mAllowedModes = aAllowedModes; + allowedModes = aAllowedModes; } if (aTarget == null) { return; } - targets.add(aTarget); targetPositions.add(aTarget.getCoords()); } @Override - public String getLockedInventory() { - issueClientUpdate(); - if (targets.size() > 1 || targetPositions.size() > 1) { + public UUID getLockedInventory() { + if (targetPositions.size() > 1) { return null; } - - IMultiBlockController controller = getTarget(false); - if (!getNameOfInventoryFromIndex(controller, mLockedInventoryIndex).equals(mLockedInventory)) { - mLockedInventory = getNameOfInventoryFromIndex(controller, mLockedInventoryIndex); - if (mLockedInventory.equals("all")) { - mLockedInventory = ""; - } - } - return mLockedInventory.equals("") ? null : mLockedInventory; + return super.getLockedInventory(); } @Override public IMultiBlockController getTarget(boolean aCheckValidity) { - if (targets.size() > 1 || targetPositions.size() > 1 || targets.size() <= 0 || targetPositions.size() <= 0) { + if (targetPositions.size() != 1) { return null; } - target = targets.get(0); - mTargetPos = targetPositions.get(0); + targetPosition = targetPositions.get(0); return super.getTarget(aCheckValidity); } |