diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/xmod/gregtech/common/covers')
| -rw-r--r-- | src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java | 198 | ||||
| -rw-r--r-- | src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java | 389 |
2 files changed, 389 insertions, 198 deletions
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java deleted file mode 100644 index f93b371aa3..0000000000 --- a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflow.java +++ /dev/null @@ -1,198 +0,0 @@ -package gtPlusPlus.xmod.gregtech.common.covers; - -import java.util.concurrent.atomic.AtomicBoolean; - -import net.minecraft.entity.player.EntityPlayer; -import net.minecraftforge.common.util.ForgeDirection; -import net.minecraftforge.fluids.Fluid; -import net.minecraftforge.fluids.FluidStack; -import net.minecraftforge.fluids.IFluidHandler; - -import com.gtnewhorizons.modularui.api.screen.ModularWindow; -import com.gtnewhorizons.modularui.common.widget.TextWidget; - -import gregtech.api.gui.modularui.CoverUIBuildContext; -import gregtech.api.interfaces.tileentity.ICoverable; -import gregtech.api.util.CoverBehavior; -import gregtech.api.util.GTUtility; -import gregtech.api.util.ISerializableObject; -import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; -import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget; - -public class CoverOverflow extends CoverBehavior { - - public final int mTransferRate; - public final int mInitialTransferRate; - public final int mMaxTransferRate; - - public CoverOverflow(int aTransferRate) { - this.mTransferRate = aTransferRate * 1000 / 10; - this.mInitialTransferRate = aTransferRate; - this.mMaxTransferRate = aTransferRate * 1000; - } - - public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, - ICoverable aTileEntity, long aTimer) { - if (aCoverVariable == 0) { - return aCoverVariable; - } - if ((aTileEntity instanceof IFluidHandler)) { - // Logger.INFO("Trying to Void via Overflow."); - IFluidHandler tTank1; - ForgeDirection directionFrom; - directionFrom = ForgeDirection.UNKNOWN; - tTank1 = (IFluidHandler) aTileEntity; - if (tTank1 != null) { - FluidStack aTankStack = tTank1.getTankInfo(directionFrom)[0].fluid; - if (aTankStack != null) { - // Logger.INFO("Found Fluid inside self - "+aTankStack.getLocalizedName()+", overflow point set at - // "+aCoverVariable+"L and we have "+aTankStack.amount+"L inside."); - if (aTankStack.amount > aCoverVariable) { - int aAmountToDrain = aTankStack.amount - aCoverVariable; - // Logger.INFO("There is "+aAmountToDrain+" more fluid in the tank than we would like."); - if (aAmountToDrain > 0) { - FluidStack tLiquid = tTank1.drain(directionFrom, Math.abs(aAmountToDrain), true); - if (tLiquid != null) { - // Logger.INFO("Drained "+aAmountToDrain+"L."); - } - } - } - } else { - // Logger.INFO("Could not simulate drain on self."); - } - } - } - return aCoverVariable; - } - - public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, - EntityPlayer aPlayer, float aX, float aY, float aZ) { - if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) { - aCoverVariable += (mMaxTransferRate * (aPlayer.isSneaking() ? 0.1f : 0.01f)); - } else { - aCoverVariable -= (mMaxTransferRate * (aPlayer.isSneaking() ? 0.1f : 0.01f)); - } - if (aCoverVariable > mMaxTransferRate) { - aCoverVariable = mInitialTransferRate; - } - if (aCoverVariable <= 0) { - aCoverVariable = mMaxTransferRate; - } - GTUtility.sendChatToPlayer( - aPlayer, - GTUtility.trans("322", "Overflow point: ") + aCoverVariable + GTUtility.trans("323", "L")); - return aCoverVariable; - } - - public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, - EntityPlayer aPlayer, float aX, float aY, float aZ) { - boolean aShift = aPlayer.isSneaking(); - int aAmount = aShift ? 128 : 8; - if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) { - aCoverVariable += aAmount; - } else { - aCoverVariable -= aAmount; - } - if (aCoverVariable > mMaxTransferRate) { - aCoverVariable = mInitialTransferRate; - } - if (aCoverVariable <= 0) { - aCoverVariable = mMaxTransferRate; - } - GTUtility.sendChatToPlayer( - aPlayer, - GTUtility.trans("322", "Overflow point: ") + aCoverVariable + GTUtility.trans("323", "L")); - aTileEntity.setCoverDataAtSide(side, new ISerializableObject.LegacyCoverData(aCoverVariable)); - return true; - } - - public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return true; - } - - public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return true; - } - - public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return true; - } - - public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return true; - } - - public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, - ICoverable aTileEntity) { - return true; - } - - public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, - ICoverable aTileEntity) { - return true; - } - - public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, - ICoverable aTileEntity) { - return false; - } - - public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, - ICoverable aTileEntity) { - return true; - } - - public boolean alwaysLookConnected(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return true; - } - - public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return 5; - } - - // GUI - - @Override - public boolean hasCoverGUI() { - return true; - } - - @Override - public ModularWindow createWindow(CoverUIBuildContext buildContext) { - return new OverflowUIFactory(buildContext).createWindow(); - } - - private class OverflowUIFactory extends UIFactory { - - private static final int startX = 10; - private static final int startY = 25; - private static final int spaceX = 18; - private static final int spaceY = 18; - - public OverflowUIFactory(CoverUIBuildContext buildContext) { - super(buildContext); - } - - @SuppressWarnings("PointlessArithmeticExpression") - @Override - protected void addUIWidgets(ModularWindow.Builder builder) { - AtomicBoolean warn = new AtomicBoolean(false); - - builder - .widget( - new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflow.this) - .addFollower( - new CoverDataFollowerNumericWidget<>(), - coverData -> (double) convert(coverData), - (coverData, state) -> new ISerializableObject.LegacyCoverData(state.intValue()), - widget -> widget.setBounds(0, mMaxTransferRate) - .setScrollValues(1000, 144, 100000) - .setFocusOnGuiOpen(true) - .setPos(startX + spaceX * 0, startY + spaceY * 1 + 8) - .setSize(spaceX * 4 - 3, 12))) - .widget( - new TextWidget(GTUtility.trans("322", "Overflow point: ")).setDefaultColor(COLOR_TEXT_GRAY.get()) - .setPos(startX, 4 + startY + spaceY * 0 + 8)); - } - } -} diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java new file mode 100644 index 0000000000..fb1c58bd62 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/common/covers/CoverOverflowValve.java @@ -0,0 +1,389 @@ +package gtPlusPlus.xmod.gregtech.common.covers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.StatCollector; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import com.google.common.io.ByteArrayDataInput; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.metatileentity.CommonMetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEBasicTank; +import gregtech.api.metatileentity.implementations.MTEFluid; +import gregtech.api.util.CoverBehaviorBase; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; +import io.netty.buffer.ByteBuf; + +public class CoverOverflowValve extends CoverBehaviorBase<CoverOverflowValve.OverflowValveData> { + + private final int minOverflowPoint = 0; + private final int maxOverflowPoint; + + public CoverOverflowValve(int maxOverflowPoint) { + super(OverflowValveData.class); + this.maxOverflowPoint = maxOverflowPoint; + } + + @Override + public OverflowValveData createDataObject() { + return new OverflowValveData(0, 0, false, true); + } + + @Override + public OverflowValveData createDataObject(int aLegacyData) { + return new OverflowValveData(aLegacyData, maxOverflowPoint / 10, false, true); + } + + private FluidStack doOverflowThing(FluidStack fluid, OverflowValveData data) { + if (fluid != null && fluid.amount > data.overflowPoint) + fluid.amount = Math.max(fluid.amount - data.voidingRate, data.overflowPoint); + return fluid; + } + + private void doOverflowThings(FluidStack[] fluids, OverflowValveData data) { + for (FluidStack fluid : fluids) doOverflowThing(fluid, data); + } + + @Override + protected OverflowValveData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + OverflowValveData data, ICoverable aTileEntity, long aTimer) { + if (data == null) return new OverflowValveData(0, 0, false, true); + + if (data.voidingRate == 0 || data.voidingRate > data.overflowPoint) return data; + + if (aTileEntity instanceof CommonMetaTileEntity common) { + IMetaTileEntity tile = common.getMetaTileEntity(); + if (tile instanceof MTEBasicTank fluidTank) { + fluidTank.setDrainableStack(doOverflowThing(fluidTank.getDrainableStack(), data)); + return data; + } else if (tile instanceof MTEFluid fluidPipe && fluidPipe.isConnectedAtSide(side)) { + doOverflowThings(fluidPipe.mFluids, data); + return data; + } + } + + return data; + } + + // Overrides methods + + @Override + protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity) { + return true; + } + + @Override + protected int getTickRateImpl(ForgeDirection side, int aCoverID, OverflowValveData data, ICoverable aTileEntity) { + return 5; + } + + @Override + protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, Fluid aFluid, + ICoverable aTileEntity) { + return data.canFluidOutput; + } + + @Override + protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, Fluid aFluid, + ICoverable aTileEntity) { + return data.canFluidInput; + } + + @Override + protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity) { + return true; + } + + @Override + protected OverflowValveData onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) { + data.overflowPoint += (int) (maxOverflowPoint * (aPlayer.isSneaking() ? 0.1f : 0.01f)); + } else { + data.overflowPoint -= (int) (maxOverflowPoint * (aPlayer.isSneaking() ? 0.1f : 0.01f)); + } + + if (data.overflowPoint > maxOverflowPoint) data.overflowPoint = minOverflowPoint; + if (data.overflowPoint <= minOverflowPoint) data.overflowPoint = maxOverflowPoint; + + GTUtility.sendChatToPlayer( + aPlayer, + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point") + data.overflowPoint + + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second")); + return data; + } + + @Override + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, OverflowValveData data, + ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + boolean aShift = aPlayer.isSneaking(); + int aAmount = aShift ? 128 : 8; + if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) { + data.overflowPoint += aAmount; + } else { + data.overflowPoint -= aAmount; + } + + if (data.overflowPoint > maxOverflowPoint) data.overflowPoint = minOverflowPoint; + if (data.overflowPoint <= minOverflowPoint) data.overflowPoint = maxOverflowPoint; + + GTUtility.sendChatToPlayer( + aPlayer, + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point") + data.overflowPoint + + StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second")); + aTileEntity.setCoverDataAtSide(side, data); + return true; + } + + // GUI + + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new OverflowUIFactory(buildContext).createWindow(); + } + + private final class OverflowUIFactory extends UIFactory { + + // width and height of text input for "Overflow Point" and "Voiding Rate" + private static final int width = 73; + private static final int height = 12; + + public OverflowUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + builder + .widget( + new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_overflow_point")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(57, 35)) + .widget( + new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_second")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(77, 35)) + .widget( + new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflowValve.this) + .addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.overflowPoint, + (coverData, state) -> { + coverData.overflowPoint = state.intValue(); + return coverData; + }, + widget -> widget.setBounds(minOverflowPoint, maxOverflowPoint) + .setScrollValues(1000, 144, 100000) + .setFocusOnGuiOpen(true) + .setPos(57, 45) + .setSize(width, height))) + .widget( + new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_voiding_rate")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(63, 77)) + .widget( + new TextWidget(StatCollector.translateToLocal("GTPP.gui.text.cover_overflow_valve_l_per_update")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(77, 35)) + .widget( + new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverOverflowValve.this) + .addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.voidingRate, + (coverData, state) -> { + coverData.voidingRate = Math.min(state.intValue(), coverData.overflowPoint); + return coverData; + }, + widget -> widget.setBounds(minOverflowPoint, maxOverflowPoint) + .setScrollValues(1000, 144, 100000) + .setFocusOnGuiOpen(true) + .setPos(57, 87) + .setSize(width, height))) + .widget( + new CoverDataControllerWidget.CoverDataIndexedControllerWidget_ToggleButtons<>( + this::getCoverData, + this::setCoverData, + CoverOverflowValve.this, + this::getClickable, + this::updateData) + .addToggleButton( + 0, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_ALLOW_INPUT) + .addTooltip( + StatCollector + .translateToLocal("GTPP.gui.text.cover_overflow_valve_allow_fluid_input")) + .setPos(21, 69)) + .addToggleButton( + 1, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_BLOCK_INPUT) + .addTooltip( + StatCollector + .translateToLocal("GTPP.gui.text.cover_overflow_valve_block_fluid_input")) + .setPos(12, 69)) + .addToggleButton( + 2, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_ALLOW_OUTPUT) + .addTooltip( + StatCollector + .translateToLocal("GTPP.gui.text.cover_overflow_valve_allow_fluid_output")) + .setPos(21, 86)) + .addToggleButton( + 3, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_BLOCK_OUTPUT) + .addTooltip( + StatCollector + .translateToLocal("GTPP.gui.text.cover_overflow_valve_block_fluid_output")) + .setPos(12, 86))); + } + + private boolean getClickable(int id, OverflowValveData data) { + return switch (id) { + case 0 -> data.canFluidInput; + case 1 -> !data.canFluidInput; + case 2 -> data.canFluidOutput; + case 3 -> !data.canFluidOutput; + default -> throw new IllegalStateException("Wrong button id: " + id); + }; + } + + private OverflowValveData updateData(int id, OverflowValveData data) { + return switch (id) { + case 0 -> { + data.canFluidInput = true; + yield data; + } + case 1 -> { + data.canFluidInput = false; + yield data; + } + case 2 -> { + data.canFluidOutput = true; + yield data; + } + case 3 -> { + data.canFluidOutput = false; + yield data; + } + default -> throw new IllegalStateException("Wrong button id: " + id); + }; + } + } + + public static class OverflowValveData implements ISerializableObject { + + private int overflowPoint; + private int voidingRate; + private boolean canFluidInput; + private boolean canFluidOutput; + + public OverflowValveData(int overflowPoint, int voidingRate, boolean canFluidInput, boolean canFluidOutput) { + this.overflowPoint = overflowPoint; + this.voidingRate = voidingRate; + this.canFluidInput = canFluidInput; + this.canFluidOutput = canFluidOutput; + } + + @Override + @NotNull + public ISerializableObject copy() { + return new OverflowValveData(overflowPoint, voidingRate, canFluidInput, canFluidOutput); + } + + @Override + @NotNull + public NBTBase saveDataToNBT() { + NBTTagCompound tag = new NBTTagCompound(); + tag.setInteger("overflowPoint", overflowPoint); + tag.setInteger("voidingRate", voidingRate); + tag.setBoolean("canFluidInput", canFluidInput); + tag.setBoolean("canFluidOutput", canFluidOutput); + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + aBuf.writeInt(overflowPoint) + .writeInt(voidingRate) + .writeBoolean(canFluidInput) + .writeBoolean(canFluidOutput); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + if (aNBT instanceof NBTTagCompound tag) { + overflowPoint = tag.getInteger("overflowPoint"); + voidingRate = tag.getInteger("voidingRate"); + canFluidInput = tag.getBoolean("canFluidInput"); + canFluidOutput = tag.getBoolean("canFluidOutput"); + } + } + + @Override + @NotNull + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, @Nullable EntityPlayerMP aPlayer) { + overflowPoint = aBuf.readInt(); + voidingRate = aBuf.readInt(); + canFluidInput = aBuf.readBoolean(); + canFluidOutput = aBuf.readBoolean(); + return this; + } + } +} |