diff --git a/src/main/java/gregtech/api/gui/resources/EmptyTextureArea.java b/src/main/java/gregtech/api/gui/resources/EmptyTextureArea.java new file mode 100644 index 00000000000..00f646f277d --- /dev/null +++ b/src/main/java/gregtech/api/gui/resources/EmptyTextureArea.java @@ -0,0 +1,20 @@ +package gregtech.api.gui.resources; + +public class EmptyTextureArea extends TextureArea { + public EmptyTextureArea(double width, double height) { + super(null, 0, 0, width, height); + } + + @Override + public TextureArea getSubArea(double offsetX, double offsetY, double width, double height) { + return new EmptyTextureArea(width, height); + } + + @Override + public void draw(double x, double y, int width, int height) { + } + + @Override + public void drawSubArea(double x, double y, int width, int height, double drawnU, double drawnV, double drawnWidth, double drawnHeight) { + } +} diff --git a/src/main/java/gregtech/api/gui/widgets/TextFieldWidgetInfiniteEnergy.java b/src/main/java/gregtech/api/gui/widgets/TextFieldWidgetInfiniteEnergy.java new file mode 100644 index 00000000000..74367199174 --- /dev/null +++ b/src/main/java/gregtech/api/gui/widgets/TextFieldWidgetInfiniteEnergy.java @@ -0,0 +1,61 @@ +package gregtech.api.gui.widgets; + +import gregtech.common.metatileentities.electric.MetaTileEntityInfiniteEmitter; +import net.minecraft.client.Minecraft; +import net.minecraft.network.PacketBuffer; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import org.lwjgl.input.Keyboard; + +public class TextFieldWidgetInfiniteEnergy extends TextFieldWidget { + private final MetaTileEntityInfiniteEmitter.InfiniteEnergyUIData data; + + public TextFieldWidgetInfiniteEnergy( + int xPosition, + int yPosition, + int width, + int height, + boolean enableBackground, + MetaTileEntityInfiniteEmitter.InfiniteEnergyUIData data) { + super(xPosition, yPosition, width, height, enableBackground, data::getEnergyText, data::setEnergyText); + this.data = data; + if (FMLCommonHandler.instance().getSide().isClient()) { + this.textField.setCanLoseFocus(false); + this.textField.setFocused(true); + } + } + + @Override + public void handleClientAction(int id, PacketBuffer buffer) { + super.handleClientAction(id, buffer); + if (id == 35) { + if (buffer.readBoolean()) data.markDirty(false); + this.gui.entityPlayer.closeScreen(); + } + } + + @Override + public boolean keyTyped(char charTyped, int keyCode) { + if (!super.keyTyped(charTyped, keyCode)) { + GuiCloseAction action = GuiCloseAction.getFromKey(keyCode); + if (action == GuiCloseAction.NONE) return false; + else writeClientAction(35, buffer -> buffer.writeBoolean(action == GuiCloseAction.CLOSE_WITHOUT_SAVE)); + } + return true; + } + + @SideOnly(Side.CLIENT) + private enum GuiCloseAction { + CLOSE, + CLOSE_WITHOUT_SAVE, + NONE; + + private static GuiCloseAction getFromKey(int keyCode) { + if (keyCode == Keyboard.KEY_RETURN) return CLOSE; + else if (keyCode == 1 || Minecraft.getMinecraft().gameSettings.keyBindInventory.isActiveAndMatches(keyCode)) + return CLOSE_WITHOUT_SAVE; + else return NONE; + } + } +} diff --git a/src/main/java/gregtech/api/metatileentity/InfiniteEnergyTileEntityBase.java b/src/main/java/gregtech/api/metatileentity/InfiniteEnergyTileEntityBase.java new file mode 100644 index 00000000000..200c28fc64d --- /dev/null +++ b/src/main/java/gregtech/api/metatileentity/InfiniteEnergyTileEntityBase.java @@ -0,0 +1,64 @@ +package gregtech.api.metatileentity; + +import codechicken.lib.raytracer.CuboidRayTraceResult; +import codechicken.lib.render.CCRenderState; +import codechicken.lib.render.pipeline.IVertexOperation; +import codechicken.lib.vec.Matrix4; +import gregtech.api.GTValues; +import gregtech.api.render.SimpleOverlayRenderer; +import gregtech.api.render.SimpleSidedCubeRenderer; +import gregtech.api.render.Textures; +import gregtech.common.metatileentities.traits.TraitInfiniteEnergy; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import org.apache.commons.lang3.tuple.Pair; + +import java.text.DateFormat; +import java.text.SimpleDateFormat; + +public abstract class InfiniteEnergyTileEntityBase extends MetaTileEntity { + private static final DateFormat DATE_FORMAT = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss"); + + protected final TRAIT trait; + + public InfiniteEnergyTileEntityBase(ResourceLocation metaTileEntityId) { + super(metaTileEntityId); + trait = createTrait(); + } + + protected abstract TRAIT createTrait(); + + @Override + public void renderMetaTileEntity(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) { + Textures.VOLTAGE_CASINGS[GTValues.MAX].render(renderState, translation, pipeline); + for (EnumFacing facing : EnumFacing.VALUES) + getOverlay().renderSided(facing, renderState, translation, pipeline); + } + + @Override + public boolean onWrenchClick(EntityPlayer player, EnumHand hand, EnumFacing wrenchSide, CuboidRayTraceResult hitResult) { + if (!player.isCreative() || player.isSneaking()) + return super.onWrenchClick(player, hand, wrenchSide, hitResult); + return true; + } + + @Override + public void update() { + super.update(); + } + + + @SideOnly(Side.CLIENT) + protected abstract SimpleOverlayRenderer getOverlay(); + + @Override + @SideOnly(Side.CLIENT) + public Pair getParticleTexture() { + return Pair.of(Textures.VOLTAGE_CASINGS[GTValues.MAX].getSpriteOnSide(SimpleSidedCubeRenderer.RenderSide.TOP), 0xFFFFFF); + } +} diff --git a/src/main/java/gregtech/api/render/Textures.java b/src/main/java/gregtech/api/render/Textures.java index 5253a1f15e8..6d3aad49278 100644 --- a/src/main/java/gregtech/api/render/Textures.java +++ b/src/main/java/gregtech/api/render/Textures.java @@ -27,32 +27,27 @@ public class Textures { + public static final SimpleOverlayRenderer INFINITE_EMITTER_FACE = new SimpleOverlayRenderer("overlay/machine/energy_emitter"); private static final ThreadLocal blockFaces = ThreadLocal.withInitial(BlockFace::new); public static List iconRegisters = new ArrayList<>(); - public static ChestRenderer WOODEN_CHEST = new ChestRenderer("storage/wooden_chest"); public static ChestRenderer METAL_CHEST = new ChestRenderer("storage/metal_chest"); public static SafeRenderer SAFE = new SafeRenderer("storage/safe"); public static DrumRenderer WOODEN_DRUM = new DrumRenderer("storage/drums/wooden_drum"); public static DrumRenderer DRUM = new DrumRenderer("storage/drums/drum"); - public static TankRenderer WOODEN_TANK = new TankRenderer("storage/tank/wooden"); public static TankRenderer METAL_TANK = new TankRenderer("storage/tank/metal"); public static CrateRenderer WOODEN_CRATE = new CrateRenderer("storage/crates/wooden_crate"); public static CrateRenderer METAL_CRATE = new CrateRenderer("storage/crates/metal_crate"); - public static SimpleSidedCubeRenderer STEAM_CASING_BRONZE = new SimpleSidedCubeRenderer("casings/steam/bronze"); public static SimpleSidedCubeRenderer STEAM_CASING_STEEL = new SimpleSidedCubeRenderer("casings/steam/steel"); public static SimpleSidedCubeRenderer STEAM_BRICKED_CASING_BRONZE = new SimpleSidedCubeRenderer("casings/steam/bricked_bronze"); public static SimpleSidedCubeRenderer STEAM_BRICKED_CASING_STEEL = new SimpleSidedCubeRenderer("casings/steam/bricked_steel"); public static SimpleSidedCubeRenderer[] VOLTAGE_CASINGS = new SimpleSidedCubeRenderer[GTValues.V.length]; - public static SimpleSidedCubeRenderer MAGIC_ENERGY_ABSORBER = new SimpleSidedCubeRenderer("casings/magic/absorber/normal"); public static SimpleSidedCubeRenderer MAGIC_ENERGY_ABSORBER_ACTIVE = new SimpleSidedCubeRenderer("casings/magic/absorber/active"); - public static SimpleSidedCubeRenderer MAGIC_ENERGY_CONVERTER = new SimpleSidedCubeRenderer("casings/magic/converter/normal"); public static SimpleSidedCubeRenderer MAGIC_ENERGY_CONVERTER_ACTIVE = new SimpleSidedCubeRenderer("casings/magic/converter/active"); - public static SimpleCubeRenderer BRONZE_PLATED_BRICKS = new SimpleCubeRenderer("casings/solid/machine_bronze_plated_bricks"); public static SimpleCubeRenderer PRIMITIVE_BRICKS = new SimpleCubeRenderer("casings/solid/machine_primitive_bricks"); public static SimpleCubeRenderer COKE_BRICKS = new SimpleCubeRenderer("casings/solid/machine_coke_bricks"); @@ -63,7 +58,6 @@ public class Textures { public static SimpleCubeRenderer STABLE_TITANIUM_CASING = new SimpleCubeRenderer("casings/solid/machine_casing_stable_titanium"); public static SimpleCubeRenderer ROBUST_TUNGSTENSTEEL_CASING = new SimpleCubeRenderer("casings/solid/machine_casing_robust_tungstensteel"); public static SimpleCubeRenderer INERT_PTFE_CASING = new SimpleCubeRenderer("casings/solid/machine_casing_inert_ptfe"); - public static SimpleCubeRenderer BRONZE_FIREBOX = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_bronze"); public static SimpleCubeRenderer BRONZE_FIREBOX_ACTIVE = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_bronze_active"); public static SimpleCubeRenderer STEEL_FIREBOX = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_steel"); @@ -72,14 +66,11 @@ public class Textures { public static SimpleCubeRenderer TITANIUM_FIREBOX_ACTIVE = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_titanium_active"); public static SimpleCubeRenderer TUNGSTENSTEEL_FIREBOX = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_tungstensteel"); public static SimpleCubeRenderer TUNGSTENSTEEL_FIREBOX_ACTIVE = new SimpleCubeRenderer("casings/firebox/machine_casing_firebox_tungstensteel_active"); - public static SimpleSidedCubeRenderer TESLA_COIL = new SimpleSidedCubeRenderer("casings/tesla_coil"); public static SimpleOrientedCubeRenderer CRAFTING_TABLE = new SimpleOrientedCubeRenderer("casings/crafting_table"); - public static OrientedOverlayRenderer COAL_BOILER_OVERLAY = new OrientedOverlayRenderer("generators/boiler/coal", FRONT); public static OrientedOverlayRenderer LAVA_BOILER_OVERLAY = new OrientedOverlayRenderer("generators/boiler/lava", FRONT); public static OrientedOverlayRenderer SOLAR_BOILER_OVERLAY = new OrientedOverlayRenderer("generators/boiler/solar", TOP); - public static OrientedOverlayRenderer PRIMITIVE_BLAST_FURNACE_OVERLAY = new OrientedOverlayRenderer("machines/primitive_blast_furnace", FRONT); public static OrientedOverlayRenderer COKE_OVEN_OVERLAY = new OrientedOverlayRenderer("machines/coke_oven", FRONT); public static OrientedOverlayRenderer MULTIBLOCK_WORKABLE_OVERLAY = new OrientedOverlayRenderer("machines/multiblock_workable", FRONT); @@ -103,7 +94,6 @@ public class Textures { public static OrientedOverlayRenderer FUSION_REACTOR_OVERLAY = new OrientedOverlayRenderer("machines/fusion_reactor", OrientedOverlayRenderer.OverlayFace.FRONT); public static SimpleCubeRenderer FUSION_TEXTURE = new SimpleCubeRenderer("casings/fusion/machine_casing_fusion_glass"); public static SimpleCubeRenderer ACTIVE_FUSION_TEXTURE = new SimpleCubeRenderer("casings/fusion/machine_casing_fusion_glass_yellow"); - public static OrientedOverlayRenderer ALLOY_SMELTER_OVERLAY = new OrientedOverlayRenderer("machines/alloy_smelter", FRONT); public static OrientedOverlayRenderer FURNACE_OVERLAY = new OrientedOverlayRenderer("machines/furnace", FRONT); public static OrientedOverlayRenderer ELECTRIC_FURNACE_OVERLAY = new OrientedOverlayRenderer("machines/electric_furnace", FRONT); @@ -145,18 +135,14 @@ public class Textures { public static OrientedOverlayRenderer SIFTER_OVERLAY = new OrientedOverlayRenderer("machines/sifter", FRONT, TOP); public static OrientedOverlayRenderer THERMAL_CENTRIFUGE_OVERLAY = new OrientedOverlayRenderer("machines/thermal_centrifuge", FRONT); public static OrientedOverlayRenderer WIREMILL_OVERLAY = new OrientedOverlayRenderer("machines/wiremill", FRONT, TOP); - public static OrientedOverlayRenderer COMBUSTION_GENERATOR_OVERLAY = new OrientedOverlayRenderer("generators/combustion", TOP); public static OrientedOverlayRenderer GAS_TURBINE_OVERLAY = new OrientedOverlayRenderer("generators/gas_turbine", SIDE); public static OrientedOverlayRenderer STEAM_TURBINE_OVERLAY = new OrientedOverlayRenderer("generators/steam_turbine", SIDE); - public static SimpleOverlayRenderer SCREEN = new SimpleOverlayRenderer("overlay/machine/overlay_screen"); public static SimpleOverlayRenderer SHUTTER = new SimpleOverlayRenderer("overlay/machine/overlay_shutter"); public static SimpleOverlayRenderer SOLAR_PANEL = new SimpleOverlayRenderer("cover/overlay_solar_panel"); - public static SimpleOverlayRenderer ROCK_CRUSHER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_rock_crusher"); public static SimpleOverlayRenderer ROCK_CRUSHER_ACTIVE_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_rock_crusher_active"); - public static SimpleOverlayRenderer PIPE_OUT_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_pipe_out"); public static SimpleOverlayRenderer PIPE_IN_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_pipe_in"); public static SimpleOverlayRenderer FLUID_HATCH_OUTPUT_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_fluid_hatch_output"); @@ -169,22 +155,18 @@ public class Textures { public static SimpleOverlayRenderer ADV_PUMP_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_adv_pump"); public static SimpleOverlayRenderer FILTER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_filter"); public static SimpleOverlayRenderer HATCH_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_hatch"); - public static SimpleOverlayRenderer FLUID_FILTER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_fluid_filter"); public static SimpleOverlayRenderer ITEM_FILTER_FILTER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_item_filter"); public static SimpleOverlayRenderer ORE_DICTIONARY_FILTER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_ore_dictionary_filter"); public static SimpleOverlayRenderer SMART_FILTER_FILTER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_smart_item_filter"); public static SimpleOverlayRenderer MACHINE_CONTROLLER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_controller"); - public static SimpleOverlayRenderer ENERGY_OUT = new SimpleOverlayRenderer("overlay/machine/overlay_energy_out"); public static SimpleOverlayRenderer ENERGY_IN = new SimpleOverlayRenderer("overlay/machine/overlay_energy_in"); public static SimpleOverlayRenderer ENERGY_OUT_MULTI = new SimpleOverlayRenderer("overlay/machine/overlay_energy_out_multi"); public static SimpleOverlayRenderer ENERGY_IN_MULTI = new SimpleOverlayRenderer("overlay/machine/overlay_energy_in_multi"); - public static SimpleOverlayRenderer CONVEYOR_OVERLAY = new SimpleOverlayRenderer("cover/overlay_conveyor"); public static SimpleOverlayRenderer ARM_OVERLAY = new SimpleOverlayRenderer("cover/overlay_arm"); public static SimpleOverlayRenderer PUMP_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_pump"); - public static SimpleOverlayRenderer AIR_VENT_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_air_vent"); public static SimpleOverlayRenderer BLOWER_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_blower"); public static SimpleOverlayRenderer BLOWER_ACTIVE_OVERLAY = new SimpleOverlayRenderer("overlay/machine/overlay_blower_active"); diff --git a/src/main/java/gregtech/common/ConfigHolder.java b/src/main/java/gregtech/common/ConfigHolder.java index 3ae769cbfaf..58e04120252 100644 --- a/src/main/java/gregtech/common/ConfigHolder.java +++ b/src/main/java/gregtech/common/ConfigHolder.java @@ -66,13 +66,13 @@ public class ConfigHolder { public static boolean insufficientEnergySupplyWipesRecipeProgress = false; @Config.Comment("Whether to use modPriorities setting in config for prioritizing ore dictionary item registrations. " + - "By default, GTCE will sort ore dictionary registrations alphabetically comparing their owner ModIDs. Default: false") + "By default, GTCE will sort ore dictionary registrations alphabetically comparing their owner ModIDs. Default: false") @Config.RequiresMcRestart public static boolean useCustomModPriorities = false; @Config.Comment("Specifies priorities of mods in ore dictionary item registration. First ModID has highest priority, last - lowest. " + - "Unspecified ModIDs follow standard sorting, but always have lower priority than last specified ModID." + - "\nFor this to work \"useCustomModPriorities\" has to be set to true.") + "Unspecified ModIDs follow standard sorting, but always have lower priority than last specified ModID." + + "\nFor this to work \"useCustomModPriorities\" has to be set to true.") @Config.RequiresMcRestart public static String[] modPriorities = new String[0]; diff --git a/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java b/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java index b0d039c17a3..b655fbe6542 100644 --- a/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java +++ b/src/main/java/gregtech/common/metatileentities/MetaTileEntities.java @@ -190,6 +190,8 @@ public class MetaTileEntities { public static MetaTileEntityQuantumTank[] QUANTUM_TANK = new MetaTileEntityQuantumTank[4]; public static MetaTileEntityFisher[] FISHER = new MetaTileEntityFisher[4]; + public static MetaTileEntityInfiniteEmitter INFINITE_EMITTER; + public static void init() { GTLog.logger.info("Registering MetaTileEntities"); @@ -644,6 +646,7 @@ public static void init() { //PRIMITIVE_WATER_PUMP = GregTechAPI.registerMetaTileEntity(1628, new MetaTileEntityWaterPump(gregtechId("primitive_pump"))); //PUMP_OUTPUT_HATCH = GregTechAPI.registerMetaTileEntity(1629, new MetaTileEntityPumpHatch(gregtechId("pump_hatch"))); + INFINITE_EMITTER = GregTechAPI.registerMetaTileEntity(1630, new MetaTileEntityInfiniteEmitter(gregtechId("infinite_emitter"))); /* diff --git a/src/main/java/gregtech/common/metatileentities/electric/MetaTileEntityInfiniteEmitter.java b/src/main/java/gregtech/common/metatileentities/electric/MetaTileEntityInfiniteEmitter.java new file mode 100644 index 00000000000..ea045d6b23f --- /dev/null +++ b/src/main/java/gregtech/common/metatileentities/electric/MetaTileEntityInfiniteEmitter.java @@ -0,0 +1,247 @@ +package gregtech.common.metatileentities.electric; + +import gregtech.api.GTValues; +import gregtech.api.gui.IUIHolder; +import gregtech.api.gui.ModularUI; +import gregtech.api.gui.Widget; +import gregtech.api.gui.resources.EmptyTextureArea; +import gregtech.api.gui.widgets.ClickButtonWidget; +import gregtech.api.gui.widgets.CycleButtonWidget; +import gregtech.api.gui.widgets.LabelWidget; +import gregtech.api.gui.widgets.TextFieldWidgetInfiniteEnergy; +import gregtech.api.metatileentity.InfiniteEnergyTileEntityBase; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.MetaTileEntityHolder; +import gregtech.api.render.SimpleOverlayRenderer; +import gregtech.api.render.Textures; +import gregtech.api.util.function.BooleanConsumer; +import gregtech.common.metatileentities.traits.TraitInfiniteEmitter; +import net.minecraft.client.Minecraft; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.network.PacketBuffer; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fml.client.config.GuiUtils; + +import java.math.BigInteger; +import java.util.ArrayDeque; +import java.util.Collections; +import java.util.function.Consumer; +import java.util.function.IntConsumer; +import java.util.function.Predicate; +import java.util.regex.Pattern; + +public class MetaTileEntityInfiniteEmitter extends InfiniteEnergyTileEntityBase { + public MetaTileEntityInfiniteEmitter(ResourceLocation metaTileEntityId) { + super(metaTileEntityId); + } + + @Override + protected TraitInfiniteEmitter createTrait() { + return new TraitInfiniteEmitter(this); + } + + @Override + public MetaTileEntity createMetaTileEntity(MetaTileEntityHolder holder) { + return new MetaTileEntityInfiniteEmitter(metaTileEntityId); + } + + @Override + protected ModularUI createUI(EntityPlayer entityPlayer) { + InfiniteEnergyUIData d = new InfiniteEnergyUIData(); + d.setEnergy(trait.getEnergy()); + d.setInfinite(trait.isInfinite()); + d.setTier(trait.getTier()); + return d.guiBuilder() + .buttonInfinite(trait::setInfinite) + .energyInput("EU", trait::setEnergy) + .buttonTier(trait::setTier) + .buttonAcceptDecline() + .createUI(getHolder(), entityPlayer); + } + + @Override + protected SimpleOverlayRenderer getOverlay() { + return Textures.INFINITE_EMITTER_FACE; + } + + public static class InfiniteEnergyUIData { + private static final Pattern NUMBER_PATTERN = Pattern.compile("[0-9]*"); + private static final Predicate NUMBER_PATTERN_VALIDATOR = s -> NUMBER_PATTERN.matcher(s).matches(); + private static final String[] TRANSLATABLE_VOLTAGE_NAMES; + + static { + TRANSLATABLE_VOLTAGE_NAMES = new String[GTValues.V.length]; + for (int i = 0; i < GTValues.V.length; i++) + TRANSLATABLE_VOLTAGE_NAMES[i] = "info.infinite_energy." + GTValues.VN[i].toLowerCase(); + } + + private boolean isDirty; + + private String energyText; + private int tier; + private boolean isInfinite; + + public InfiniteEnergyGuiBuilder guiBuilder() { + return new InfiniteEnergyGuiBuilder(); + } + + public void markDirty(boolean isDirty) { + this.isDirty = isDirty; + } + + public boolean isDirty() { + return this.isDirty; + } + + public String getEnergyText() { + return energyText; + } + + public void setEnergyText(String energyText) { + markDirty(true); + this.energyText = energyText; + } + + public BigInteger parseEnergyFromText() { + return energyText.isEmpty() ? BigInteger.ZERO : new BigInteger(energyText); + } + + public void setEnergy(BigInteger energy) { + setEnergyText(energy.toString()); + } + + public int getTier() { + return tier; + } + + public void setTier(int tier) { + markDirty(true); + this.tier = tier; + } + + public boolean isInfinite() { + return isInfinite; + } + + public void setInfinite(boolean infinite) { + markDirty(true); + isInfinite = infinite; + } + + public final class InfiniteEnergyGuiBuilder { + private final ArrayDeque widgets = new ArrayDeque<>(); + + private int y; + private boolean infinite; + private boolean energy; + private boolean tier; + + private BooleanConsumer applyInfiniteFlagChange; + private Consumer applyEnergyChange; + private IntConsumer applyTierChange; + + public InfiniteEnergyGuiBuilder buttonInfinite(BooleanConsumer applyInfiniteFlagChange) { + this.applyInfiniteFlagChange = applyInfiniteFlagChange; + if (!widgets.isEmpty()) y += 4; + widgets.add(new CycleButtonWidget( + 0, + y, + 200, + 20, + new String[]{"info.infinite_energy.finite", "info.infinite_energy.infinite"}, + () -> isInfinite() ? 1 : 0, + i -> setInfinite(i != 0) + )); + y += 20; + infinite = true; + return this; + } + + public InfiniteEnergyGuiBuilder energyInput(String labelText, Consumer applyEnergyChange) { + this.applyEnergyChange = applyEnergyChange; + if (!widgets.isEmpty()) y += 4; + widgets.add(new TextFieldWidgetInfiniteEnergy( + 2, + y, + 180, + 12, + true, + InfiniteEnergyUIData.this + ).setValidator(NUMBER_PATTERN_VALIDATOR)); + widgets.add(new LabelWidget(188, y + 2, labelText, -1)); + y += 12; + energy = true; + return this; + } + + public InfiniteEnergyGuiBuilder buttonTier(IntConsumer applyTierChange) { + this.applyTierChange = applyTierChange; + if (!widgets.isEmpty()) y += 4; + widgets.add(new CycleButtonWidget( + 0, + y, + 200, + 20, + TRANSLATABLE_VOLTAGE_NAMES, + InfiniteEnergyUIData.this::getTier, + InfiniteEnergyUIData.this::setTier + )); + y += 20; + tier = true; + return this; + } + + public InfiniteEnergyGuiBuilder buttonAcceptDecline() { + if (!widgets.isEmpty()) y += 16; + buttonClose(true); + buttonClose(false); + y += 20; + return this; + } + + private void buttonClose(boolean setDirty) { + widgets.add(new ClickButtonWidget( + setDirty ? 0 : 200 - 98, y, + 98, + 20, + setDirty ? "info.infinite_energy.accept" : "info.infinite_energy.decline", + c -> markDirty(setDirty)) { + @Override + public void handleClientAction(int id, PacketBuffer buffer) { + super.handleClientAction(id, buffer); + this.gui.entityPlayer.closeScreen(); + } + + @Override + public void drawInForeground(int mouseX, int mouseY) { + if (isMouseOver(getPosition().x, getPosition().y, getSize().width, getSize().height, mouseX, mouseY)) { + GuiUtils.drawHoveringText( + Collections.singletonList(I18n.format(setDirty ? "info.button.accept" : "info.button.decline")), + mouseX, + mouseY, + this.gui.getScreenWidth(), + this.gui.getScreenHeight(), + -1, + Minecraft.getMinecraft().fontRenderer); + } + } + }); + } + + public ModularUI createUI(IUIHolder holder, EntityPlayer player) { + ModularUI.Builder b = new ModularUI.Builder(new EmptyTextureArea(200, y), 200, y); + for (Widget w : widgets) b.widget(w); + b.bindCloseListener(() -> { + if (!player.world.isRemote && isDirty()) { + if (infinite) applyInfiniteFlagChange.apply(isInfinite()); + if (energy) applyEnergyChange.accept(parseEnergyFromText()); + if (tier) applyTierChange.accept(getTier()); + } + }); + return b.build(holder, player); + } + } + } + +} diff --git a/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEmitter.java b/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEmitter.java new file mode 100644 index 00000000000..7f1562f47f7 --- /dev/null +++ b/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEmitter.java @@ -0,0 +1,141 @@ +package gregtech.common.metatileentities.traits; + +import gregtech.api.GTValues; +import gregtech.api.capability.GregtechCapabilities; +import gregtech.api.capability.IEnergyContainer; +import gregtech.api.metatileentity.InfiniteEnergyTileEntityBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.common.capabilities.Capability; + +import javax.annotation.Nullable; +import java.math.BigInteger; + + +public class TraitInfiniteEmitter extends TraitInfiniteEnergy implements IEnergyContainer { + private boolean isInfinite; + private int tier = GTValues.MAX; + private long voltage = GTValues.V[GTValues.MAX]; + + public TraitInfiniteEmitter(InfiniteEnergyTileEntityBase mte) { + super(mte); + } + + public boolean isInfinite() { + return isInfinite; + } + + public void setInfinite(boolean infinite) { + this.isInfinite = infinite; + } + + @Override + public void update() { + if (!metaTileEntity.getWorld().isRemote) { + if (isInfinite) for (EnumFacing facing : EnumFacing.VALUES) send(facing); + else if (energy.signum() == 1) for (EnumFacing facing : EnumFacing.VALUES) + if (send(facing) && energy.signum() != 1) break; + } + } + + + public int getTier() { + return tier; + } + + public void setTier(int tier) { + voltage = GTValues.V[this.tier = tier]; + } + + @Override + public String getName() { + return "infinite_gteu_emitter"; + } + + @Override + public int getNetworkID() { + return TraitNetworkIds.TRAIT_ID_ENERGY_CONTAINER; + } + + protected boolean send(EnumFacing facing) { + TileEntity te = metaTileEntity.getWorld().getTileEntity(this.metaTileEntity.getPos().offset(facing)); + if (te != null) { + IEnergyContainer s = te.getCapability(GregtechCapabilities.CAPABILITY_ENERGY_CONTAINER, facing.getOpposite()); + if (s != null && s.inputsEnergy(facing.getOpposite())) { + long stored = getEnergyStored(), voltage = Math.min(this.voltage, s.getInputVoltage()); + if (stored / voltage > 0) { + long accepted = s.acceptEnergyFromNetwork(facing.getOpposite(), voltage, Math.min(s.getInputAmperage(), stored / voltage)) * voltage; + if (accepted > 0) { + if (!isInfinite()) subtract(BigInteger.valueOf(accepted)); + return true; + } + } + } + } + return false; + } + + @Override + public long acceptEnergyFromNetwork(EnumFacing side, long voltage, long amperage) { + return 0; + } + + @Override + public boolean inputsEnergy(EnumFacing side) { + return false; + } + + @Override + public boolean outputsEnergy(EnumFacing side) { + return true; + } + + @Override + public long changeEnergy(long differenceAmount) { + add(BigInteger.valueOf(differenceAmount)); + return differenceAmount; + } + + @Override + public long getInputAmperage() { + return 64; + } + + @Override + public long getInputVoltage() { + return voltage; + } + + @Override + public long getEnergyStored() { + return isInfinite() || energy.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) >= 0 ? Long.MAX_VALUE : energy.longValueExact(); + } + + @Override + public long getEnergyCapacity() { + return getEnergyStored(); + } + + @Nullable + @Override + @SuppressWarnings("unchecked") + public T getCapability(Capability capability) { + return capability == GregtechCapabilities.CAPABILITY_ENERGY_CONTAINER ? (T) this : null; + } + + @Override + public NBTTagCompound serializeNBT() { + NBTTagCompound nbt = super.serializeNBT(); + if (isInfinite) nbt.setBoolean("infinite", true); + nbt.setByte("tier", (byte) tier); + return nbt; + } + + @Override + public void deserializeNBT(NBTTagCompound nbt) { + super.deserializeNBT(nbt); + setInfinite(nbt.getBoolean("infinite")); + setTier(nbt.getByte("tier")); + } +} diff --git a/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEnergy.java b/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEnergy.java new file mode 100644 index 00000000000..fd924599064 --- /dev/null +++ b/src/main/java/gregtech/common/metatileentities/traits/TraitInfiniteEnergy.java @@ -0,0 +1,57 @@ +package gregtech.common.metatileentities.traits; + +import gregtech.api.metatileentity.InfiniteEnergyTileEntityBase; +import gregtech.api.metatileentity.MTETrait; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.Constants.NBT; + +import java.math.BigInteger; + +public abstract class TraitInfiniteEnergy extends MTETrait { + protected final InfiniteEnergyTileEntityBase mte; + protected BigInteger energy = BigInteger.ZERO; + + public TraitInfiniteEnergy(InfiniteEnergyTileEntityBase mte) { + super(mte); + this.mte = mte; + } + + public BigInteger getEnergy() { + return energy; + } + + public void setEnergy(BigInteger bigInteger) { + energy = bigInteger.signum() == 1 ? bigInteger : BigInteger.ZERO; + } + + protected void add(BigInteger bInt) { + switch (bInt.signum()) { + case 1: + energy = energy.add(bInt); + break; + case -1: + subtract(bInt.negate()); + } + } + + protected void subtract(BigInteger bInt) { + if (energy.compareTo(bInt) > 0) { + energy = energy.subtract(bInt); + } else energy = BigInteger.ZERO; + } + + @Override + public NBTTagCompound serializeNBT() { + NBTTagCompound nbt = new NBTTagCompound(); + if (energy.signum() > 0) nbt.setByteArray("energy", energy.toByteArray()); + return nbt; + } + + @Override + public void deserializeNBT(NBTTagCompound nbt) { + if (nbt.hasKey("energy", NBT.TAG_BYTE_ARRAY)) { + byte[] bArr = nbt.getByteArray("energy"); + energy = bArr.length > 0 ? new BigInteger(bArr) : BigInteger.ZERO; + } else energy = BigInteger.ZERO; + } +} diff --git a/src/main/resources/assets/gregtech/lang/en_us.lang b/src/main/resources/assets/gregtech/lang/en_us.lang index 681589e8918..4126be976b5 100644 --- a/src/main/resources/assets/gregtech/lang/en_us.lang +++ b/src/main/resources/assets/gregtech/lang/en_us.lang @@ -2837,6 +2837,9 @@ gregtech.machine.circuit_assembler.iv.name=Elite Circuit Assembler gregtech.machine.circuit_assembler.luv.name=Elite Circuit Assembler II gregtech.machine.circuit_assembler.zpm.name=Elite Circuit Assembler III +gregtech.machine.infinite_emitter.name=Infinite GT Energy Unit Emitter +gregtech.machine.infinite_emitter.tooltip=§fYou just need §5C§dr§4e§ca§et§ai§bv§3e §7m§1o§5d§de§f to use this + # Machine hulls gregtech.machine.hull.tooltip=§fYou just need §5I§dm§4a§cg§ei§an§ba§3t§7i§1o§5n§f to use this @@ -3504,3 +3507,25 @@ gregtech.command.util.hand.tool_stats=Tool Stats Class: %s gregtech.command.util.hand.meta_item=Meta Item Name: %s gregtech.command.util.hand.not_a_player=This command is only usable by a player. gregtech.command.util.hand.no_item=You must hold something in mainhand before executing this command. + +info.infinite_energy.infinite=Infinite: §lOn§r +info.infinite_energy.finite=Infinite: §lOff§r +info.button.accept=Press §lENTER§r to accept changes +info.button.decline=Press §lESC§r to decline changes +info.infinite_energy.accept=Accept +info.infinite_energy.decline=Decline +info.infinite_energy.ulv=Voltage: ULV +info.infinite_energy.lv=Voltage: LV +info.infinite_energy.mv=Voltage: MV +info.infinite_energy.hv=Voltage: HV +info.infinite_energy.ev=Voltage: EV +info.infinite_energy.iv=Voltage: IV +info.infinite_energy.luv=Voltage: LUV +info.infinite_energy.zpm=Voltage: ZPM +info.infinite_energy.uv=Voltage: UV +info.infinite_energy.uhv=Voltage: UHV +info.infinite_energy.uev=Voltage: UEV +info.infinite_energy.uiv=Voltage: UIV +info.infinite_energy.umv=Voltage: UMV +info.infinite_energy.uxv=Voltage: UXV +info.infinite_energy.max=Voltage: MAX diff --git a/src/main/resources/assets/gregtech/textures/blocks/overlay/machine/energy_emitter.png b/src/main/resources/assets/gregtech/textures/blocks/overlay/machine/energy_emitter.png new file mode 100644 index 00000000000..07f6c5703e6 Binary files /dev/null and b/src/main/resources/assets/gregtech/textures/blocks/overlay/machine/energy_emitter.png differ