diff --git a/src/main/java/com/github/gtexpert/core/common/metatileentities/GTEMetaTileEntities.java b/src/main/java/com/github/gtexpert/core/common/metatileentities/GTEMetaTileEntities.java index ebbf35a6..c04aa151 100644 --- a/src/main/java/com/github/gtexpert/core/common/metatileentities/GTEMetaTileEntities.java +++ b/src/main/java/com/github/gtexpert/core/common/metatileentities/GTEMetaTileEntities.java @@ -24,6 +24,7 @@ public class GTEMetaTileEntities { public static MetaTileEntityVoidOreMiner VOIDOREMINER; public static MetaTileEntityAdvancedChemicalPlant ADVANCED_CHEMICAL_PLANT; public static MetaTileEntityLargeGasCollector LARGE_GAS_COLLECTOR; + public static MetaTileEntityLargeTransformer LARGE_TRANSFORMER; public static void init() { // Single Machine @@ -42,6 +43,8 @@ public static void init() { LARGE_GAS_COLLECTOR = registerMetaTileEntity(12007, new MetaTileEntityLargeGasCollector(gteId(GTEConfigHolder.gteFlag.featureFlag ? "large_gas_collector" : "advanced_gas_collector"))); + LARGE_TRANSFORMER = registerMetaTileEntity(12008, + new MetaTileEntityLargeTransformer(gteId("large_transformer"))); } public static void registerGTESimpleMetaTileEntity(GTESimpleMachineMetaTileEntity[] machines, int startId, diff --git a/src/main/java/com/github/gtexpert/core/common/metatileentities/multi/MetaTileEntityLargeTransformer.java b/src/main/java/com/github/gtexpert/core/common/metatileentities/multi/MetaTileEntityLargeTransformer.java new file mode 100644 index 00000000..c74568f0 --- /dev/null +++ b/src/main/java/com/github/gtexpert/core/common/metatileentities/multi/MetaTileEntityLargeTransformer.java @@ -0,0 +1,333 @@ +package com.github.gtexpert.core.common.metatileentities.multi; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.client.resources.I18n; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.PacketBuffer; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.text.ITextComponent; +import net.minecraft.util.text.TextComponentString; +import net.minecraft.util.text.TextFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import gregtech.api.GTValues; +import gregtech.api.capability.GregtechDataCodes; +import gregtech.api.capability.GregtechTileCapabilities; +import gregtech.api.capability.IControllable; +import gregtech.api.capability.IEnergyContainer; +import gregtech.api.capability.impl.EnergyContainerList; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.interfaces.IGregTechTileEntity; +import gregtech.api.metatileentity.multiblock.IMultiblockPart; +import gregtech.api.metatileentity.multiblock.MultiblockAbility; +import gregtech.api.metatileentity.multiblock.MultiblockDisplayText; +import gregtech.api.metatileentity.multiblock.MultiblockWithDisplayBase; +import gregtech.api.pattern.BlockPattern; +import gregtech.api.pattern.FactoryBlockPattern; +import gregtech.api.pattern.PatternMatchContext; +import gregtech.api.util.GTUtility; +import gregtech.api.util.TextComponentUtil; +import gregtech.api.util.TextFormattingUtil; +import gregtech.client.renderer.ICubeRenderer; +import gregtech.client.renderer.texture.Textures; +import gregtech.common.blocks.BlockMetalCasing; +import gregtech.common.blocks.MetaBlocks; + +import codechicken.lib.render.CCRenderState; +import codechicken.lib.render.pipeline.IVertexOperation; +import codechicken.lib.vec.Matrix4; + +public class MetaTileEntityLargeTransformer extends MultiblockWithDisplayBase implements IControllable { + + private EnergyContainerList input; + private ExtendedEnergyContainerList output; + private boolean isWorkingEnabled = true; + private boolean isActive = true; + + public MetaTileEntityLargeTransformer(ResourceLocation metaTileEntityId) { + super(metaTileEntityId); + this.input = new EnergyContainerList(new ArrayList<>()); + this.output = new ExtendedEnergyContainerList(new ArrayList<>()); + } + + @Override + public MetaTileEntity createMetaTileEntity(IGregTechTileEntity tileEntity) { + return new MetaTileEntityLargeTransformer(metaTileEntityId); + } + + @Override + protected void updateFormedValid() { + if (isWorkingEnabled()) { + long canDrain = input.getEnergyStored(); + long totalDrained = output.changeEnergy(canDrain); + input.removeEnergy(totalDrained); + } + } + + @Override + protected @NotNull BlockPattern createStructurePattern() { + return FactoryBlockPattern.start() + .aisle("XSX", "XXX") + .where('X', abilities(MultiblockAbility.MAINTENANCE_HATCH).setExactLimit(1) + .or(abilities(MultiblockAbility.INPUT_ENERGY).setExactLimit(1)) + .or(abilities(MultiblockAbility.OUTPUT_ENERGY).setExactLimit(1)) + .or(states( + MetaBlocks.METAL_CASING.getState(BlockMetalCasing.MetalCasingType.PALLADIUM_SUBSTATION)) + .setExactLimit(2))) + .where('S', selfPredicate()) + .build(); + } + + @Override + protected void formStructure(PatternMatchContext context) { + super.formStructure(context); + List powerInput = new ArrayList<>(getAbilities(MultiblockAbility.INPUT_ENERGY)); + + List powerOutput = new ArrayList<>(getAbilities(MultiblockAbility.OUTPUT_ENERGY)); + + // Invalidate the structure if there is not at least one output and one input + if (powerInput.isEmpty() || powerOutput.isEmpty()) { + this.invalidateStructure(); + } + + this.input = new EnergyContainerList(powerInput); + this.output = new ExtendedEnergyContainerList(powerOutput); + } + + @Override + public void invalidateStructure() { + super.invalidateStructure(); + this.input = new EnergyContainerList(new ArrayList<>()); + this.output = new ExtendedEnergyContainerList(new ArrayList<>()); + setActive(false); + } + + @Override + protected boolean shouldShowVoidingModeButton() { + return false; + } + + @Override + public boolean isWorkingEnabled() { + return isWorkingEnabled; + } + + @Override + public void setWorkingEnabled(boolean isWorkingAllowed) { + this.isWorkingEnabled = isWorkingAllowed; + markDirty(); + World world = getWorld(); + if (world != null && !world.isRemote) { + writeCustomData(GregtechDataCodes.WORKING_ENABLED, buf -> buf.writeBoolean(isWorkingEnabled)); + } + } + + @Override + public boolean isActive() { + return super.isActive() && this.isWorkingEnabled; + } + + public void setActive(boolean active) { + if (this.isActive != active) { + this.isActive = active; + markDirty(); + World world = getWorld(); + if (world != null && !world.isRemote) { + writeCustomData(GregtechDataCodes.WORKABLE_ACTIVE, buf -> buf.writeBoolean(active)); + } + } + } + + @Override + public NBTTagCompound writeToNBT(NBTTagCompound data) { + super.writeToNBT(data); + data.setBoolean("isActive", this.isActive); + data.setBoolean("isWorkingEnabled", this.isWorkingEnabled); + return data; + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + this.isActive = data.getBoolean("isActive"); + this.isWorkingEnabled = data.getBoolean("isWorkingEnabled"); + } + + @Override + public void writeInitialSyncData(PacketBuffer buf) { + super.writeInitialSyncData(buf); + buf.writeBoolean(this.isActive); + buf.writeBoolean(this.isWorkingEnabled); + } + + @Override + public void receiveInitialSyncData(PacketBuffer buf) { + super.receiveInitialSyncData(buf); + this.isActive = buf.readBoolean(); + this.isWorkingEnabled = buf.readBoolean(); + } + + @Override + public void receiveCustomData(int dataId, @NotNull PacketBuffer buf) { + super.receiveCustomData(dataId, buf); + if (dataId == GregtechDataCodes.WORKABLE_ACTIVE) { + this.isActive = buf.readBoolean(); + scheduleRenderUpdate(); + } else if (dataId == GregtechDataCodes.WORKING_ENABLED) { + this.isWorkingEnabled = buf.readBoolean(); + scheduleRenderUpdate(); + } + } + + @Override + public T getCapability(Capability capability, EnumFacing side) { + if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) { + return GregtechTileCapabilities.CAPABILITY_CONTROLLABLE.cast(this); + } + return super.getCapability(capability, side); + } + + @SideOnly(Side.CLIENT) + @Override + public ICubeRenderer getBaseTexture(IMultiblockPart sourcePart) { + return Textures.PALLADIUM_SUBSTATION_CASING; + } + + @SideOnly(Side.CLIENT) + @Override + protected @NotNull ICubeRenderer getFrontOverlay() { + return Textures.DATA_BANK_OVERLAY; + } + + @Override + public void renderMetaTileEntity(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) { + super.renderMetaTileEntity(renderState, translation, pipeline); + getFrontOverlay().renderOrientedState(renderState, translation, pipeline, getFrontFacing(), this.isActive(), + this.isWorkingEnabled()); + } + + @Override + protected void addDisplayText(List textList) { + MultiblockDisplayText.builder(textList, isStructureFormed()) + .setWorkingStatus(true, isActive() && isWorkingEnabled()) + .addCustom(tl -> { + if (isStructureFormed()) { + // input + String inputEnergyFormatted = TextFormattingUtil.formatNumbers(getInputVolt()); + ITextComponent inputVoltageName = new TextComponentString( + GTValues.VNF[GTUtility.getFloorTierByVoltage(getInputVolt())]); + ITextComponent inputAmp = TextComponentUtil.stringWithColor( + TextFormatting.YELLOW, + TextFormattingUtil.formatNumbers(getInputAmp())); + tl.add(TextComponentUtil.translationWithColor( + TextFormatting.GRAY, + "gtexpert.multiblock.large_transformer.max_input_energy_per_tick_amps", + inputEnergyFormatted, inputVoltageName, inputAmp)); + // output + String outputEnergyFormatted = TextFormattingUtil.formatNumbers(getOutputVolt()); + ITextComponent outputVoltageName = new TextComponentString( + GTValues.VNF[GTUtility.getFloorTierByVoltage(getOutputVolt())]); + ITextComponent outputAmp = TextComponentUtil.stringWithColor( + TextFormatting.YELLOW, + TextFormattingUtil.formatNumbers(getOutputAmp())); + tl.add(TextComponentUtil.translationWithColor( + TextFormatting.GRAY, + "gtexpert.multiblock.large_transformer.max_output_energy_per_tick_amps", + outputEnergyFormatted, outputVoltageName, outputAmp)); + } + }) + .addWorkingStatusLine(); + } + + @Override + protected void addWarningText(List textList) { + super.addWarningText(textList); + if (isStructureFormed() && this.getOutput() > this.getInput()) { + textList.add(TextComponentUtil.translationWithColor( + TextFormatting.YELLOW, + "gtexpert.multiblock.large_transformer.not_enough_input")); + } + } + + @Override + public void addInformation(ItemStack stack, @Nullable World world, @NotNull List tooltip, + boolean advanced) { + tooltip.add(I18n.format("gtexpert.machine.large_transformer.tooltip.1")); + tooltip.add(I18n.format("gtexpert.machine.large_transformer.tooltip.2")); + } + + private long getInput() { + return input.getInputVoltage() * input.getInputAmperage(); + } + + private long getOutput() { + return output.getOutputVoltage() * output.getOutputAmperage(); + } + + private long getInputAmp() { + return getInput() / input.getHighestInputVoltage(); + } + + private long getInputVolt() { + return input.getHighestInputVoltage(); + } + + private long getOutputAmp() { + return getOutput() / output.getHighestOutputVoltage(); + } + + private long getOutputVolt() { + return output.getHighestOutputVoltage(); + } + + private static class ExtendedEnergyContainerList extends EnergyContainerList { + + private final List energyContainerList; + /** The highest single energy container's input voltage in the list. */ + private final long highestOutputVoltage; + /** The number of energy containers at the highest input voltage in the list. */ + private final int numHighestOutputContainers; + + public ExtendedEnergyContainerList(@NotNull List energyContainerList) { + super(energyContainerList); + this.energyContainerList = energyContainerList; + long highestOutputVoltage = 0; + int numHighestOutputContainers = 0; + for (IEnergyContainer container : energyContainerList) { + if (container.getOutputVoltage() > highestOutputVoltage) { + highestOutputVoltage = container.getOutputVoltage(); + } + } + for (IEnergyContainer container : energyContainerList) { + if (container.getOutputVoltage() == highestOutputVoltage) { + numHighestOutputContainers++; + } + } + this.highestOutputVoltage = highestOutputVoltage; + this.numHighestOutputContainers = numHighestOutputContainers; + } + + /** The highest single voltage of an energy container in this list. */ + public long getHighestOutputVoltage() { + return highestOutputVoltage; + } + + /** + * The number of parts with voltage specified in {@link ExtendedEnergyContainerList#getHighestOutputVoltage()} + * in this list. + */ + public int getNumHighestOutputContainers() { + return numHighestOutputContainers; + } + } +} diff --git a/src/main/java/com/github/gtexpert/core/loaders/recipe/GTERecipe.java b/src/main/java/com/github/gtexpert/core/loaders/recipe/GTERecipe.java index f227315a..068c7cd7 100644 --- a/src/main/java/com/github/gtexpert/core/loaders/recipe/GTERecipe.java +++ b/src/main/java/com/github/gtexpert/core/loaders/recipe/GTERecipe.java @@ -858,6 +858,14 @@ private static void blocks() { ConfigHolder.recipes.casingsPerCraft)) .duration(100).EUt(VA[ZPM]) .buildAndRegister(); + + // Large Adjustable Transformer + ModHandler.addShapedRecipe(true, "gtexpert.machine.large_transformer", + GTEMetaTileEntities.LARGE_TRANSFORMER.getStackForm(), "DPD", "CHC", "DPD", + 'D', MetaItems.SMD_DIODE, + 'P', new UnificationEntry(plate, Materials.Palladium), + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.EV), + 'H', MetaTileEntities.HULL[EV].getStackForm()); } private static void tools() { diff --git a/src/main/resources/assets/gtexpert/lang/en_us.lang b/src/main/resources/assets/gtexpert/lang/en_us.lang index b24f2109..752b274d 100644 --- a/src/main/resources/assets/gtexpert/lang/en_us.lang +++ b/src/main/resources/assets/gtexpert/lang/en_us.lang @@ -27,6 +27,10 @@ gtexpert.machine.advanced_gas_collector.tooltip.1=§dAuthor:§f @tier940 gtexpert.machine.large_gas_collector.name=Large Gas Collector gtexpert.machine.large_gas_collector.tooltip=Squeeze air out of dust gtexpert.machine.large_gas_collector.tooltip.1=§dAuthor:§f @tier940 +gtexpert.machine.large_transformer.name=Large Adjustable Transformer +gtexpert.machine.large_transformer.tooltip=The one that was in the old Gregicality +gtexpert.machine.large_transformer.tooltip.1=Simplified version of active transformers +gtexpert.machine.large_transformer.tooltip.2=§dAuthor:§f @MrKono # singleblock # Auto Chisel @@ -238,3 +242,8 @@ recipemap.steam_circuit_assembler.name=Steam Circuit Assembler gtexpert.gui.electric_spawner_mode.spawn=Spawn Mode gtexpert.gui.electric_spawner_mode.capture=Capture Mode gtexpert.gui.needs_redstone=Needs Redstone signal to work + +#multiblock display +gtexpert.multiblock.large_transformer.max_input_energy_per_tick_amps=Max Input: %s EU/t (%s) / %s A +gtexpert.multiblock.large_transformer.max_output_energy_per_tick_amps=Max Output: %s EU/t (%s) / %s A +gtexpert.multiblock.large_transformer.not_enough_input=Max Output exceeds Max Input! diff --git a/src/main/resources/assets/gtexpert/lang/ja_jp.lang b/src/main/resources/assets/gtexpert/lang/ja_jp.lang index 58263bc9..bac81f64 100644 --- a/src/main/resources/assets/gtexpert/lang/ja_jp.lang +++ b/src/main/resources/assets/gtexpert/lang/ja_jp.lang @@ -27,6 +27,10 @@ gtexpert.machine.advanced_gas_collector.tooltip.1=§d作者:§f @tier940 gtexpert.machine.large_gas_collector.name=大型ガス収集機 gtexpert.machine.large_gas_collector.tooltip=粉から空気を搾り取る gtexpert.machine.large_gas_collector.tooltip.1=§d作者:§f @tier940 +gtexpert.machine.large_transformer.name=大型可変変圧器 +gtexpert.machine.large_transformer.tooltip=昔のGregicalityには居たやつ +gtexpert.machine.large_transformer.tooltip.1=大型変圧器の簡易版 +gtexpert.machine.large_transformer.tooltip.2=§d作者:§f @MrKono # singleblock # Auto Chisel @@ -238,3 +242,8 @@ recipemap.steam_circuit_assembler.name=蒸気式回路作成機 gtexpert.gui.electric_spawner_mode.spawn=スポーンモード gtexpert.gui.electric_spawner_mode.capture=捕獲モード gtexpert.gui.needs_redstone=動作にはレッドストーン入力が必要です + +#multiblock display +gtexpert.multiblock.large_transformer.max_input_energy_per_tick_amps=最大入力: %s EU/t (%s) / %s A +gtexpert.multiblock.large_transformer.max_output_energy_per_tick_amps=最大出力: %s EU/t (%s) / %s A +gtexpert.multiblock.large_transformer.not_enough_input=最大出力が最大入力を超過している! \ No newline at end of file