diff options
Diffstat (limited to 'src/main/java/tectech/thing/metaTileEntity/single')
8 files changed, 1907 insertions, 0 deletions
diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEBuckConverter.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEBuckConverter.java new file mode 100644 index 0000000000..3f2c66276d --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEBuckConverter.java @@ -0,0 +1,265 @@ +package tectech.thing.metaTileEntity.single; + +import static gregtech.api.enums.GTValues.V; +import static gregtech.api.enums.GTValues.VN; +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.function.Consumer; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizons.modularui.api.NumberFormatMUI; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; +import gregtech.api.objects.GTRenderedTexture; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTEBuckConverter extends MTETieredMachineBlock implements IAddUIWidgets, IAddGregtechLogo { + + private static GTRenderedTexture BUCK, BUCK_ACTIVE; + public int EUT = 0, AMP = 0; + private static NumberFormatMUI numberFormat = new NumberFormatMUI(); + + public MTEBuckConverter(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, translateToLocal("gt.blockmachines.machine.tt.buck.desc.0"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.machine.tt.buck.desc.1"), }); + TTUtility.setTier(aTier, this); + } + + public MTEBuckConverter(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEBuckConverter(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + BUCK = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/BUCK")); + BUCK_ACTIVE = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/BUCK_ACTIVE")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { tectech.thing.metaTileEntity.Textures.MACHINE_CASINGS_TT[mTier][colorIndex + 1], + side == facing ? (aActive ? BUCK_ACTIVE : BUCK) + : (side == facing.getOpposite() + ? tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] + : (aActive ? tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_OUT_POWER_TT[mTier] + : tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier])) }; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("eEUT", EUT); + aNBT.setInteger("eAMP", AMP); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + EUT = aNBT.getInteger("eEUT"); + AMP = aNBT.getInteger("eAMP"); + getBaseMetaTileEntity().setActive((long) AMP * EUT >= 0); + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isElectric() { + return true; + } + + @Override + public boolean isEnetOutput() { + return true; + } + + @Override + public boolean isEnetInput() { + return true; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getBackFacing(); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return getBaseMetaTileEntity().isActive() && side != getBaseMetaTileEntity().getFrontFacing() + && side != getBaseMetaTileEntity().getBackFacing(); + } + + @Override + public long maxAmperesIn() { + return 2; + } + + @Override + public long maxAmperesOut() { + return getBaseMetaTileEntity().isActive() ? Math.min(Math.abs(AMP), 64) : 0; + } + + @Override + public long maxEUInput() { + return V[mTier]; + } + + @Override + public long maxEUOutput() { + return getBaseMetaTileEntity().isActive() ? Math.min(Math.abs(EUT), maxEUInput()) : 0; + } + + @Override + public long maxEUStore() { + return V[mTier] << 4; + } + + @Override + public long getMinimumStoredEU() { + return V[mTier] << 2; + } + + @Override + public int getProgresstime() { + return (int) getBaseMetaTileEntity().getUniversalEnergyStored(); + } + + @Override + public int maxProgresstime() { + return (int) getBaseMetaTileEntity().getUniversalEnergyCapacity(); + } + + @Override + public void addGregTechLogo(ModularWindow.Builder builder) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_GT_LOGO_17x17_TRANSPARENT_GRAY) + .setSize(17, 17) + .setPos(113, 56)); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_SCREEN_BLACK) + .setSize(90, 72) + .setPos(43, 4)) + .widget( + new TextWidget().setStringSupplier(() -> "EUT: " + numberFormat.format(EUT)) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 8)) + .widget( + new TextWidget().setStringSupplier(() -> "TIER: " + VN[TTUtility.getTier(Math.abs(EUT))]) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 16)) + .widget( + new TextWidget().setStringSupplier(() -> "AMP: " + numberFormat.format(AMP)) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 24)) + .widget( + new TextWidget().setStringSupplier(() -> "SUM: " + numberFormat.format((long) AMP * EUT)) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 32)); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> EUT -= val, 512, 64, 7, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> EUT /= val, 512, 64, 7, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> AMP -= val, 512, 64, 7, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> AMP /= val, 512, 64, 7, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> EUT -= val, 16, 1, 25, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> EUT /= val, 16, 2, 25, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> AMP -= val, 16, 1, 25, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> AMP /= val, 16, 2, 25, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> EUT += val, 16, 1, 133, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> EUT *= val, 16, 2, 133, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> AMP += val, 16, 1, 133, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> AMP *= val, 16, 2, 133, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> EUT += val, 512, 64, 151, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> EUT *= val, 512, 64, 151, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> AMP += val, 512, 64, 151, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> AMP *= val, 512, 64, 151, 58); + } + + private void addChangeNumberButton(ModularWindow.Builder builder, IDrawable overlay, Consumer<Integer> setter, + int changeNumberShift, int changeNumber, int xPos, int yPos) { + builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> { + setter.accept(clickData.shift ? changeNumberShift : changeNumber); + getBaseMetaTileEntity().setActive((long) AMP * EUT >= 0); + }) + .setBackground(GTUITextures.BUTTON_STANDARD, overlay) + .setSize(18, 18) + .setPos(xPos, yPos)); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPollutor.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPollutor.java new file mode 100644 index 0000000000..d70a0e3c43 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPollutor.java @@ -0,0 +1,217 @@ +package tectech.thing.metaTileEntity.single; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.function.Consumer; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizons.modularui.api.NumberFormatMUI; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; +import gregtech.api.objects.GTRenderedTexture; +import gregtech.common.Pollution; +import tectech.TecTech; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by Tec on 23.03.2017. + */ +public class MTEDebugPollutor extends MTETieredMachineBlock implements IAddUIWidgets, IAddGregtechLogo { + + private static GTRenderedTexture POLLUTOR; + public int pollution = 0; + private static final NumberFormatMUI numberFormat = new NumberFormatMUI(); + + public MTEDebugPollutor(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, translateToLocal("gt.blockmachines.debug.tt.pollutor.desc.0"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.pollutor.desc.1"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.pollutor.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEDebugPollutor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEDebugPollutor(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + POLLUTOR = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/POLLUTOR")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { tectech.thing.metaTileEntity.Textures.MACHINE_CASINGS_TT[mTier][colorIndex + 1], + (side == facing) ? POLLUTOR : tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] }; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("ePollution", pollution); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + pollution = aNBT.getInteger("ePollution"); + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + if (pollution > 0) { + Pollution.addPollution(aBaseMetaTileEntity, pollution); + } + } else if (aBaseMetaTileEntity.isClientSide() && aBaseMetaTileEntity.isActive()) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (side != aBaseMetaTileEntity.getFrontFacing()) { + TecTech.proxy.em_particle(aBaseMetaTileEntity, side); + TecTech.proxy.pollutor_particle(aBaseMetaTileEntity, side); + } + } + } + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isElectric() { + return false; + } + + @Override + public void addGregTechLogo(ModularWindow.Builder builder) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_GT_LOGO_17x17_TRANSPARENT_GRAY) + .setSize(17, 17) + .setPos(113, 56)); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_SCREEN_BLACK) + .setSize(90, 72) + .setPos(43, 4)) + .widget( + new TextWidget().setStringSupplier(() -> "Pollution: " + numberFormat.format(pollution)) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 8)); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> pollution -= val, 512, 64, 7, 4); + addChangeNumberButton( + builder, + GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, + val -> pollution /= val, + 512, + 64, + 7, + 22); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> pollution -= val, 16, 1, 25, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> pollution /= val, 16, 2, 25, 22); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> pollution += val, 16, 1, 133, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> pollution *= val, 16, 2, 133, 22); + + addChangeNumberButton( + builder, + GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, + val -> pollution += val, + 512, + 64, + 151, + 4); + addChangeNumberButton( + builder, + GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, + val -> pollution *= val, + 512, + 64, + 151, + 22); + + } + + private void addChangeNumberButton(ModularWindow.Builder builder, IDrawable overlay, Consumer<Integer> setter, + int changeNumberShift, int changeNumber, int xPos, int yPos) { + builder.widget( + new ButtonWidget() + .setOnClick((clickData, widget) -> setter.accept(clickData.shift ? changeNumberShift : changeNumber)) + .setBackground(GTUITextures.BUTTON_STANDARD, overlay) + .setSize(18, 18) + .setPos(xPos, yPos)); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPowerGenerator.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPowerGenerator.java new file mode 100644 index 0000000000..b82e0036c0 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugPowerGenerator.java @@ -0,0 +1,383 @@ +package tectech.thing.metaTileEntity.single; + +import static gregtech.api.enums.GTValues.VN; +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.function.Consumer; +import java.util.function.IntConsumer; +import java.util.function.IntSupplier; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizons.modularui.api.NumberFormatMUI; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; +import gregtech.api.objects.GTRenderedTexture; +import gregtech.api.util.GTUtility; +import tectech.mechanics.pipe.IConnectsToEnergyTunnel; +import tectech.thing.metaTileEntity.hatch.MTEHatchEnergyTunnel; +import tectech.thing.metaTileEntity.pipe.MTEPipeEnergy; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by Tec on 23.03.2017. + */ +public class MTEDebugPowerGenerator extends MTETieredMachineBlock + implements IConnectsToEnergyTunnel, IAddUIWidgets, IAddGregtechLogo { + + public static GTRenderedTexture GENNY; + private boolean LASER = false; + public int EUT = 0, AMP = 0; + public boolean producing = true; + private static final NumberFormatMUI numberFormat = new NumberFormatMUI(); + + public MTEDebugPowerGenerator(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, translateToLocal("gt.blockmachines.debug.tt.genny.desc.0"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.debug.tt.genny.desc.3"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.genny.desc.1"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.genny.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEDebugPowerGenerator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEDebugPowerGenerator(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public final void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + LASER = !LASER; + GTUtility.sendChatToPlayer( + aPlayer, + String.format(StatCollector.translateToLocal("tt.chat.debug.generator"), LASER ? "ON" : "OFF")); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + GENNY = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/GENNY")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { tectech.thing.metaTileEntity.Textures.MACHINE_CASINGS_TT[mTier][colorIndex + 1], + side != facing + ? LASER + ? (aActive ? tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] + : tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_IN_LASER_TT[mTier]) + : (aActive ? tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_OUT_POWER_TT[mTier] + : tectech.thing.metaTileEntity.Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier]) + : GENNY }; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("eEUT", EUT); + aNBT.setInteger("eAMP", AMP); + aNBT.setBoolean("eLaser", LASER); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + EUT = aNBT.getInteger("eEUT"); + AMP = aNBT.getInteger("eAMP"); + LASER = aNBT.getBoolean("eLaser"); + producing = (long) AMP * EUT >= 0; + getBaseMetaTileEntity().setActive(producing); + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + aBaseMetaTileEntity.setActive(producing); + if (!LASER) { + if (aBaseMetaTileEntity.isActive()) { + setEUVar(maxEUStore()); + } else { + setEUVar(0); + } + } else { + byte Tick = (byte) (aTick % 20); + if (aBaseMetaTileEntity.isActive() && CommonValues.TRANSFER_AT == Tick) { + setEUVar(maxEUStore()); + moveAround(aBaseMetaTileEntity); + } else if (CommonValues.TRANSFER_AT == Tick) { + setEUVar(0); + } + } + } + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isElectric() { + return true; + } + + @Override + public boolean isEnetOutput() { + return !LASER; + } + + @Override + public boolean isEnetInput() { + return !LASER; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return !producing && side != getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return producing && side != getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public long maxAmperesIn() { + return producing ? 0 : Math.abs(AMP); + } + + @Override + public long maxAmperesOut() { + return producing ? Math.abs(AMP) : 0; + } + + @Override + public long maxEUInput() { + return producing ? 0 : Integer.MAX_VALUE; + } + + @Override + public long maxEUOutput() { + return producing ? Math.abs(EUT) : 0; + } + + @Override + public long maxEUStore() { + return LASER ? Math.abs((long) EUT * AMP * 24) : Math.abs((long) EUT * AMP) << 2; + } + + @Override + public long getMinimumStoredEU() { + return Math.abs((long) EUT * AMP); + } + + @Override + public int getProgresstime() { + return (int) getBaseMetaTileEntity().getUniversalEnergyStored(); + } + + @Override + public int maxProgresstime() { + return (int) getBaseMetaTileEntity().getUniversalEnergyCapacity(); + } + + public int getEUT() { + return EUT; + } + + public void setEUT(int EUT) { + this.EUT = EUT; + } + + public int getAMP() { + return AMP; + } + + public void setAMP(int AMP) { + this.AMP = AMP; + } + + @Override + public boolean canConnect(ForgeDirection side) { + return LASER && side != getBaseMetaTileEntity().getFrontFacing(); + } + + private void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + for (final ForgeDirection face : ForgeDirection.VALID_DIRECTIONS) { + if (face == aBaseMetaTileEntity.getFrontFacing()) continue; + final ForgeDirection opposite = face.getOpposite(); + for (short dist = 1; dist < 1000; dist++) { + IGregTechTileEntity tGTTileEntity = aBaseMetaTileEntity + .getIGregTechTileEntityAtSideAndDistance(face, dist); + if (tGTTileEntity != null) { + IMetaTileEntity aMetaTileEntity = tGTTileEntity.getMetaTileEntity(); + if (aMetaTileEntity != null) { + if (aMetaTileEntity instanceof MTEHatchEnergyTunnel + && opposite == tGTTileEntity.getFrontFacing()) { + if (maxEUOutput() > ((MTEHatchEnergyTunnel) aMetaTileEntity).maxEUInput()) { + aMetaTileEntity.doExplosion(maxEUOutput()); + } else { + long diff = Math.min( + AMP * 20L * maxEUOutput(), + Math.min( + ((MTEHatchEnergyTunnel) aMetaTileEntity).maxEUStore() + - aMetaTileEntity.getBaseMetaTileEntity() + .getStoredEU(), + aBaseMetaTileEntity.getStoredEU())); + ((MTEHatchEnergyTunnel) aMetaTileEntity).setEUVar( + aMetaTileEntity.getBaseMetaTileEntity() + .getStoredEU() + diff); + } + } else if (aMetaTileEntity instanceof MTEPipeEnergy) { + if (((MTEPipeEnergy) aMetaTileEntity).connectionCount < 2) {} else { + ((MTEPipeEnergy) aMetaTileEntity).markUsed(); + } + } + } + } + } + } + } + + @Override + public void addGregTechLogo(ModularWindow.Builder builder) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_GT_LOGO_17x17_TRANSPARENT_GRAY) + .setSize(17, 17) + .setPos(113, 56)); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_SCREEN_BLACK) + .setSize(90, 72) + .setPos(43, 4)) + + .widget( + new TextWidget().setStringSupplier(() -> "TIER: " + VN[TTUtility.getTier(Math.abs(EUT))]) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 22)) + + .widget( + new TextWidget().setStringSupplier(() -> "SUM: " + numberFormat.format((long) AMP * EUT)) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 46)); + + addLabelledIntegerTextField(builder, "EUT: ", 24, this::getEUT, this::setEUT, 46, 8); + addLabelledIntegerTextField(builder, "AMP: ", 24, this::getAMP, this::setAMP, 46, 34); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> EUT -= val, 512, 64, 7, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> EUT /= val, 512, 64, 7, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> AMP -= val, 512, 64, 7, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, val -> AMP /= val, 512, 64, 7, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> EUT -= val, 16, 1, 25, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> EUT /= val, 16, 2, 25, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> AMP -= val, 16, 1, 25, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, val -> AMP /= val, 16, 2, 25, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> EUT += val, 16, 1, 133, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> EUT *= val, 16, 2, 133, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> AMP += val, 16, 1, 133, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, val -> AMP *= val, 16, 2, 133, 58); + + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> EUT += val, 512, 64, 151, 4); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> EUT *= val, 512, 64, 151, 22); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> AMP += val, 512, 64, 151, 40); + addChangeNumberButton(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, val -> AMP *= val, 512, 64, 151, 58); + } + + private void addLabelledIntegerTextField(ModularWindow.Builder builder, String label, int labelWidth, + IntSupplier getter, IntConsumer setter, int xPos, int yPos) { + builder.widget( + new TextWidget(label).setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(xPos, yPos)) + .widget( + new NumericWidget().setGetter(getter::getAsInt) + .setSetter(val -> setter.accept((int) val)) + .setTextColor(COLOR_TEXT_WHITE.get()) + .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD.withOffset(-1, -1, 2, 2)) + .setPos(xPos + labelWidth, yPos - 1) + .setSize(56, 10)); + } + + private void addChangeNumberButton(ModularWindow.Builder builder, IDrawable overlay, Consumer<Integer> setter, + int changeNumberShift, int changeNumber, int xPos, int yPos) { + builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> { + setter.accept(clickData.shift ? changeNumberShift : changeNumber); + producing = (long) AMP * EUT >= 0; + }) + .setBackground(GTUITextures.BUTTON_STANDARD, overlay) + .setSize(18, 18) + .setPos(xPos, yPos)); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugStructureWriter.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugStructureWriter.java new file mode 100644 index 0000000000..a03266ac89 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEDebugStructureWriter.java @@ -0,0 +1,292 @@ +package tectech.thing.metaTileEntity.single; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.function.Consumer; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing; +import com.gtnewhorizon.structurelib.structure.StructureUtility; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; +import gregtech.api.objects.GTRenderedTexture; +import tectech.TecTech; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by Tec on 23.03.2017. + */ +public class MTEDebugStructureWriter extends MTETieredMachineBlock implements IAddUIWidgets, IAddGregtechLogo { + + private static GTRenderedTexture MARK; + public short[] numbers = new short[6]; + public boolean size = false; + public String[] result = new String[] { "Undefined" }; + + public MTEDebugStructureWriter(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, translateToLocal("gt.blockmachines.debug.tt.writer.desc.0"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.writer.desc.1"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.debug.tt.writer.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEDebugStructureWriter(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEDebugStructureWriter(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + MARK = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/MARK")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { tectech.thing.metaTileEntity.Textures.MACHINE_CASINGS_TT[mTier][colorIndex + 1], + side != facing ? new GTRenderedTexture(Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE) : MARK }; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + for (int i = 0; i < numbers.length; i++) { + aNBT.setShort("eData" + i, numbers[i]); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + for (int i = 0; i < numbers.length; i++) { + numbers[i] = aNBT.getShort("eData" + i); + } + } + + @Override + public boolean isSimpleMachine() { + return false; + } + + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + super.onFirstTick(aBaseMetaTileEntity); + aBaseMetaTileEntity.disableWorking(); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isAllowedToWork()) { + + String pseudoJavaCode = StructureUtility.getPseudoJavaCode( + aBaseMetaTileEntity.getWorld(), + ExtendedFacing.of(aBaseMetaTileEntity.getFrontFacing()), + aBaseMetaTileEntity.getXCoord(), + aBaseMetaTileEntity.getYCoord(), + aBaseMetaTileEntity.getZCoord(), + numbers[0], + numbers[1], + numbers[2], + te -> te.getClass() + .getCanonicalName(), + numbers[3], + numbers[4], + numbers[5], + false); + TecTech.LOGGER.info(pseudoJavaCode); + result = pseudoJavaCode.split("\\n"); + aBaseMetaTileEntity.disableWorking(); + } + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + IGregTechTileEntity aBaseMetaTileEntity = getBaseMetaTileEntity(); + + String pseudoJavaCode = StructureUtility.getPseudoJavaCode( + aBaseMetaTileEntity.getWorld(), + ExtendedFacing.of(aBaseMetaTileEntity.getFrontFacing()), + aBaseMetaTileEntity.getXCoord(), + aBaseMetaTileEntity.getYCoord(), + aBaseMetaTileEntity.getZCoord(), + numbers[0], + numbers[1], + numbers[2], + te -> te.getClass() + .getCanonicalName(), + numbers[3], + numbers[4], + numbers[5], + false); + TecTech.LOGGER.info(pseudoJavaCode); + result = pseudoJavaCode.split("\\n"); + aBaseMetaTileEntity.disableWorking(); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isElectric() { + return false; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + return result; + } + + @Override + public void addGregTechLogo(ModularWindow.Builder builder) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_GT_LOGO_17x17_TRANSPARENT_GRAY) + .setSize(17, 17) + .setPos(113, 56)); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + new DrawableWidget().setDrawable(GTUITextures.PICTURE_SCREEN_BLACK) + .setSize(90, 72) + .setPos(43, 4)) + .widget( + new TextWidget().setStringSupplier(() -> size ? "Structure size" : "My position") + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 8)) + .widget( + new TextWidget().setStringSupplier(() -> size ? "(Changing scan size)" : "(Moving origin)") + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 16)) + .widget( + new TextWidget().setStringSupplier(() -> "A: " + numbers[size ? 3 : 0]) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 24)) + .widget( + new TextWidget().setStringSupplier(() -> "B: " + numbers[size ? 4 : 1]) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 32)) + .widget( + new TextWidget().setStringSupplier(() -> "C: " + numbers[size ? 5 : 2]) + .setDefaultColor(COLOR_TEXT_WHITE.get()) + .setPos(46, 40)); + + addChangeNumberButtons(builder, GTUITextures.OVERLAY_BUTTON_MINUS_LARGE, -512, -64, 7); + addChangeNumberButtons(builder, GTUITextures.OVERLAY_BUTTON_MINUS_SMALL, -16, -1, 25); + addChangeNumberButtons(builder, GTUITextures.OVERLAY_BUTTON_PLUS_SMALL, 16, 1, 133); + addChangeNumberButtons(builder, GTUITextures.OVERLAY_BUTTON_PLUS_LARGE, 512, 16, 151); + } + + private void addChangeNumberButtons(ModularWindow.Builder builder, IDrawable overlay, int addNumberShift, + int addNumber, int xPos) { + addChangeNumberButton( + builder, + overlay, + val -> numbers[size ? 3 : 0] += val, + addNumberShift, + addNumber, + xPos, + 4); + addChangeNumberButton( + builder, + overlay, + val -> numbers[size ? 4 : 1] += val, + addNumberShift, + addNumber, + xPos, + 22); + addChangeNumberButton( + builder, + overlay, + val -> numbers[size ? 5 : 2] += val, + addNumberShift, + addNumber, + xPos, + 40); + builder.widget( + new ButtonWidget().setOnClick((clickData, widget) -> { size = !size; }) + .setBackground(GTUITextures.BUTTON_STANDARD, overlay) + .setSize(18, 18) + .setPos(xPos, 58)); + } + + private void addChangeNumberButton(ModularWindow.Builder builder, IDrawable overlay, Consumer<Integer> setter, + int changeNumberShift, int changeNumber, int xPos, int yPos) { + builder.widget( + new ButtonWidget() + .setOnClick( + (clickData, widget) -> { setter.accept(clickData.shift ? changeNumberShift : changeNumber); }) + .setBackground(GTUITextures.BUTTON_STANDARD, overlay) + .setSize(18, 18) + .setPos(xPos, yPos)); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEOwnerDetector.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEOwnerDetector.java new file mode 100644 index 0000000000..15cd63d6c9 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEOwnerDetector.java @@ -0,0 +1,237 @@ +package tectech.thing.metaTileEntity.single; + +import static net.minecraft.util.StatCollector.translateToLocal; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; +import gregtech.api.objects.GTRenderedTexture; +import gregtech.api.util.GTUtility; +import tectech.TecTech; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by Tec on 23.03.2017. + */ +public class MTEOwnerDetector extends MTETieredMachineBlock { + + private static GTRenderedTexture OWNER_ONLINE, OWNER_OFFLINE; + private String uuid; + private boolean interdimensional = true; + + public MTEOwnerDetector(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, + translateToLocal("gt.blockmachines.machine.tt.ownerdetector.desc.0"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.machine.tt.ownerdetector.desc.1"), + EnumChatFormatting.BLUE + translateToLocal("gt.blockmachines.machine.tt.ownerdetector.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEOwnerDetector(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEOwnerDetector(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + OWNER_ONLINE = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/OWNER_ONLINE")); + OWNER_OFFLINE = new GTRenderedTexture(new Textures.BlockIcons.CustomIcon("iconsets/OWNER_OFFLINE")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { tectech.thing.metaTileEntity.Textures.MACHINE_CASINGS_TT[mTier][colorIndex + 1], + aActive ? OWNER_ONLINE : OWNER_OFFLINE }; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, ForgeDirection side, + ItemStack itemStack) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setString("eUUID", uuid); + aNBT.setBoolean("eInterDim", interdimensional); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + uuid = aNBT.getString("eUUID"); + interdimensional = aNBT.getBoolean("eInterDim"); + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + if (aBaseMetaTileEntity.isServerSide()) { + if (uuid == null || uuid.length() == 0) { + String name = aBaseMetaTileEntity.getOwnerName(); + if (!("Player".equals(name))) { + uuid = TecTech.proxy.getUUID(name); + } + } + } + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide() && aTick % 20 == CommonValues.RECIPE_AT) { + boolean detected = TecTech.proxy.isOnlineUUID(uuid) || (uuid != null && uuid.length() > 0 + && TecTech.proxy.isOnlineName(aBaseMetaTileEntity.getOwnerName())); + aBaseMetaTileEntity.setActive(detected); + aBaseMetaTileEntity.setGenericRedstoneOutput(detected); + byte value = (byte) (detected ? 15 : 0); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + aBaseMetaTileEntity.setStrongOutputRedstoneSignal(side, value); + } + } + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + String clientLocale; + try { + EntityPlayerMP player = (EntityPlayerMP) aPlayer; + clientLocale = (String) FieldUtils.readField(player, "translator", true); + } catch (Exception e) { + clientLocale = "en_US"; + } + interdimensional ^= true; + GTUtility.sendChatToPlayer( + aPlayer, + interdimensional ? translateToLocalFormatted("tt.keyphrase.Running_interdimensional_scan", clientLocale) + : translateToLocalFormatted("tt.keyphrase.Running_local_dimension_scan", clientLocale)); + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isElectric() { + return false; + } + + @Override + public boolean isEnetOutput() { + return false; + } + + @Override + public boolean isEnetInput() { + return false; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return false; + } + + @Override + public long maxAmperesIn() { + return 0; + } + + @Override + public long maxAmperesOut() { + return 0; + } + + @Override + public long maxEUInput() { + return Integer.MAX_VALUE; + } + + @Override + public long maxEUOutput() { + return 0; + } + + @Override + public long maxEUStore() { + return 0; + } + + @Override + public long getMinimumStoredEU() { + return 0; + } + + @Override + public int getProgresstime() { + return interdimensional ? 1 : 0; + } + + @Override + public int maxProgresstime() { + return 1; + } + + @Override + public boolean hasSidedRedstoneOutputBehavior() { + return true; + } + + @Override + public boolean allowGeneralRedstoneOutput() { + return true; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTETeslaCoil.java b/src/main/java/tectech/thing/metaTileEntity/single/MTETeslaCoil.java new file mode 100644 index 0000000000..b053cd656c --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTETeslaCoil.java @@ -0,0 +1,396 @@ +package tectech.thing.metaTileEntity.single; + +import static gregtech.api.enums.GTValues.V; +import static java.lang.Math.round; +import static net.minecraft.util.StatCollector.translateToLocal; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; + +import java.util.Arrays; +import java.util.HashSet; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.commons.lang3.ArrayUtils; +import org.apache.commons.lang3.reflect.FieldUtils; + +import com.google.common.collect.Multimap; +import com.google.common.collect.MultimapBuilder; +import com.gtnewhorizon.structurelib.util.Vec3Impl; + +import eu.usrv.yamcore.auxiliary.PlayerChatHelper; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEBasicBatteryBuffer; +import tectech.TecTech; +import tectech.loader.NetworkDispatcher; +import tectech.mechanics.spark.RendererMessage; +import tectech.mechanics.spark.ThaumSpark; +import tectech.mechanics.tesla.ITeslaConnectable; +import tectech.mechanics.tesla.ITeslaConnectableSimple; +import tectech.thing.metaTileEntity.Textures; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTETeslaCoil extends MTEBasicBatteryBuffer implements ITeslaConnectable { + + // Interface fields + private final Multimap<Integer, ITeslaConnectableSimple> teslaNodeMap = MultimapBuilder.treeKeys() + .linkedListValues() + .build(); + private final HashSet<ThaumSpark> sparkList = new HashSet<>(); + private int sparkCount = 10; + + private static final int transferRadiusMax = TecTech.configTecTech.TESLA_SINGLE_RANGE; // Default is 20 + private static final int perBlockLoss = TecTech.configTecTech.TESLA_SINGLE_LOSS_PER_BLOCK; // Default is 1 + private static final float overDriveLoss = TecTech.configTecTech.TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE; // Default is + // 0.25F + private static final int transferRadiusMin = 4; // Minimum user configurable + private int transferRadius = transferRadiusMax; // Default transferRadius setting + + public boolean powerPassToggle = false; // Power Pass for public viewing + private static final int histSteps = 20; // Hysteresis Resolution + private int histSettingLow = 3; // Hysteresis Low Limit + private int histSettingHigh = 15; // Hysteresis High Limit + private static final int histLowLimit = 1; // How low can you configure it? + private static final int histHighLimit = 19; // How high can you configure it? + private float histLow = (float) histSettingLow / histSteps; // Power pass is disabled if power is under this + // fraction + private float histHigh = (float) histSettingHigh / histSteps; // Power pass is enabled if power is over this + // fraction + + private final long outputVoltage = V[mTier]; + private boolean overdriveToggle = false; + + private String clientLocale = "en_US"; + + public MTETeslaCoil(int aID, String aName, String aNameRegional, int aTier, int aSlotCount) { + super(aID, aName, aNameRegional, aTier, "", aSlotCount); + TTUtility.setTier(aTier, this); + } + + public MTETeslaCoil(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures, int aSlotCount) { + super(aName, aTier, aDescription, aTextures, aSlotCount); + } + + @Override + public String[] getDescription() { + String[] jargon = new String[] { CommonValues.THETA_MOVEMENT, + translateToLocal("gt.blockmachines.machine.tt.tesla.desc.0"), // Your Tesla I/O machine of choice + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.machine.tt.tesla.desc.1") // Lightning + // stoves for the + // rich + }; + String[] sDesc = super.getDescription(); + sDesc = Arrays.copyOfRange(sDesc, 1, sDesc.length); // Removes first element from array + return ArrayUtils.addAll(jargon, sDesc); + } + + @Override + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { + if (overdriveToggle) { + overdriveToggle = false; + PlayerChatHelper + .SendInfo(aPlayer, translateToLocalFormatted("tt.keyphrase.Overdrive_disengaged", clientLocale)); + } else { + overdriveToggle = true; + PlayerChatHelper + .SendInfo(aPlayer, translateToLocalFormatted("tt.keyphrase.Overdrive_engaged", clientLocale)); + } + return true; + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (aPlayer.isSneaking()) { + if (histSettingHigh < histHighLimit) { + histSettingHigh++; + } else { + histSettingHigh = histSettingLow + 1; + } + histHigh = (float) histSettingHigh / histSteps; + PlayerChatHelper.SendInfo( + aPlayer, + translateToLocalFormatted("tt.keyphrase.Hysteresis_high_set_to", clientLocale) + " " + + round(histHigh * 100F) + + "%"); + } else { + if (histSettingLow > histLowLimit) { + histSettingLow--; + } else { + histSettingLow = histSettingHigh - 1; + } + histLow = (float) histSettingLow / histSteps; + PlayerChatHelper.SendInfo( + aPlayer, + translateToLocalFormatted("tt.keyphrase.Hysteresis_low_set_to", clientLocale) + " " + + round(histLow * 100F) + + "%"); + } + } + + @Override + public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { + if (aPlayer.isSneaking()) { + if (transferRadius > transferRadiusMin) { + transferRadius--; + } + } else { + if (transferRadius < transferRadiusMax) { + transferRadius++; + } + } + PlayerChatHelper.SendInfo( + aPlayer, + translateToLocalFormatted("tt.keyphrase.Tesla_radius_set_to", clientLocale) + " " + transferRadius + "m"); + return false; + } + + // Cheeky skrub stuff to get machine to switch powerPass on soft mallet + @Override + public boolean hasAlternativeModeText() { + return true; + } + + @Override + public String getAlternativeModeText() { + // Hysteresis based ePowerPass Config + long energyMax = getStoredEnergy()[1]; + long energyStored = getStoredEnergy()[0]; + float energyFrac = (float) energyStored / energyMax; + + // ePowerPass hist toggle + if (energyFrac > histHigh) { + powerPassToggle = true; + } else if (energyFrac < histLow) { + powerPassToggle = false; + } else { + powerPassToggle = !powerPassToggle; + } + + // And after this cheeky-ness, toss the string XD + return powerPassToggle ? translateToLocalFormatted("tt.keyphrase.Sending_power", clientLocale) + "!" + : translateToLocalFormatted("tt.keyphrase.Receiving_power", clientLocale) + "!"; + } + + @Override + public boolean isFacingValid(ForgeDirection side) { + return side != ForgeDirection.UP; + } // Prevents output at the top side + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + ITexture[][][] rTextures = new ITexture[3][17][]; + for (byte i = -1; i < 16; ++i) { + rTextures[0][i + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[this.mTier][i + 1] }; + rTextures[1][i + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[this.mTier][i + 1], + Textures.TESLA_TRANSCEIVER_TOP_BA }; + rTextures[2][i + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[this.mTier][i + 1], + this.mInventory.length == 16 ? Textures.OVERLAYS_ENERGY_OUT_POWER_TT[this.mTier] + : (this.mInventory.length > 4 ? Textures.OVERLAYS_ENERGY_OUT_MULTI_TT[this.mTier] + : Textures.OVERLAYS_ENERGY_OUT_TT[this.mTier]) }; + } + return rTextures; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return this.mTextures[side == facing ? 2 : side == ForgeDirection.UP ? 1 : 0][colorIndex + 1]; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTETeslaCoil(mName, mTier, mDescriptionArray, mTextures, mInventory.length); + } + + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + super.onFirstTick(aBaseMetaTileEntity); + if (!aBaseMetaTileEntity.isClientSide()) { + TeslaUtil.teslaSimpleNodeSetAdd(this); + TeslaUtil.generateTeslaNodeMap(this); + } + } + + @Override + public void onRemoval() { + super.onRemoval(); + if (!this.getBaseMetaTileEntity() + .isClientSide()) { + TeslaUtil.teslaSimpleNodeSetRemove(this); + } + } + + @Override + public void onUnload() { + if (!this.getBaseMetaTileEntity() + .isClientSide()) { + TeslaUtil.teslaSimpleNodeSetRemove(this); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + TeslaUtil.teslaSimpleNodeSetAdd(this); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + if (aBaseMetaTileEntity.isClientSide()) { + return; + } + + // Hysteresis based ePowerPass Config + long energyMax = getStoredEnergy()[1]; + long energyStored = getStoredEnergy()[0]; + float energyFrac = (float) energyStored / energyMax; + + // ePowerPass hist toggle + if (!powerPassToggle && energyFrac > histHigh) { + powerPassToggle = true; + } else if (powerPassToggle && energyFrac < histLow) { + powerPassToggle = false; + } + + // Send Power + TeslaUtil.powerTeslaNodeMap(this); + + // TODO Encapsulate the spark sender + sparkCount--; + if (sparkCount == 0) { + sparkCount = 10; + if (!sparkList.isEmpty()) { + NetworkDispatcher.INSTANCE.sendToAllAround( + new RendererMessage.RendererData(sparkList), + aBaseMetaTileEntity.getWorld().provider.dimensionId, + aBaseMetaTileEntity.getXCoord(), + aBaseMetaTileEntity.getYCoord(), + aBaseMetaTileEntity.getZCoord(), + 256); + sparkList.clear(); + } + } + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isServerSide()) { + try { + EntityPlayerMP player = (EntityPlayerMP) aPlayer; + clientLocale = (String) FieldUtils.readField(player, "translator", true); + } catch (Exception e) { + clientLocale = "en_US"; + } + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + } + return true; + } + + @Override + public byte getTeslaReceptionCapability() { + return 1; + } + + @Override + public float getTeslaReceptionCoefficient() { + return 1; + } + + @Override + public Multimap<Integer, ITeslaConnectableSimple> getTeslaNodeMap() { + return teslaNodeMap; + } + + @Override + public HashSet<ThaumSpark> getSparkList() { + return sparkList; + } + + @Override + public byte getTeslaTransmissionCapability() { + return 2; + } + + @Override + public int getTeslaTransmissionRange() { + return transferRadius; + } + + @Override + public boolean isOverdriveEnabled() { + return overdriveToggle; + } + + @Override + public int getTeslaEnergyLossPerBlock() { + return perBlockLoss; + } + + @Override + public float getTeslaOverdriveLossCoefficient() { + return overDriveLoss; + } + + @Override + public long getTeslaOutputVoltage() { + return outputVoltage; + } + + @Override + public long getTeslaOutputCurrent() { + return mBatteryCount; + } + + @Override + public boolean teslaDrainEnergy(long teslaVoltageDrained) { + if (getEUVar() < teslaVoltageDrained) { + return false; + } + + setEUVar(getEUVar() - teslaVoltageDrained); + return true; + } + + @Override + public boolean isTeslaReadyToReceive() { + return !this.powerPassToggle; + } + + @Override + public long getTeslaStoredEnergy() { + return getEUVar(); + } + + @Override + public Vec3Impl getTeslaPosition() { + return new Vec3Impl( + this.getBaseMetaTileEntity() + .getXCoord(), + this.getBaseMetaTileEntity() + .getYCoord(), + this.getBaseMetaTileEntity() + .getZCoord()); + } + + @Override + public Integer getTeslaDimension() { + return this.getBaseMetaTileEntity() + .getWorld().provider.dimensionId; + } + + @Override + public boolean teslaInjectEnergy(long teslaVoltageInjected) { + return this.getBaseMetaTileEntity() + .injectEnergyUnits(ForgeDirection.UP, teslaVoltageInjected, 1L) > 0L; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTETransformerTT.java b/src/main/java/tectech/thing/metaTileEntity/single/MTETransformerTT.java new file mode 100644 index 0000000000..e0c52e64c7 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTETransformerTT.java @@ -0,0 +1,68 @@ +package tectech.thing.metaTileEntity.single; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.MTETransformer; +import tectech.thing.metaTileEntity.Textures; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTETransformerTT extends MTETransformer { + + public MTETransformerTT(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, ""); + TTUtility.setTier(aTier, this); + } + + public MTETransformerTT(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + TTUtility.setTier(aTier, this); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTETransformerTT(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + ITexture[][][] rTextures = new ITexture[12][17][]; + for (byte b = -1; b < 16; b++) { + rTextures[0][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_MULTI_TT[mTier] }; + rTextures[1][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_MULTI_TT[mTier] }; + rTextures[2][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_MULTI_TT[mTier] }; + rTextures[3][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier + 1] }; + rTextures[4][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier + 1] }; + rTextures[5][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier + 1] }; + rTextures[6][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_MULTI_TT[mTier] }; + rTextures[7][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_MULTI_TT[mTier] }; + rTextures[8][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_IN_MULTI_TT[mTier] }; + rTextures[9][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_POWER_TT[mTier + 1] }; + rTextures[10][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_POWER_TT[mTier + 1] }; + rTextures[11][b + 1] = new ITexture[] { Textures.MACHINE_CASINGS_TT[mTier][b + 1], + Textures.OVERLAYS_ENERGY_OUT_POWER_TT[mTier + 1] }; + } + return rTextures; + } + + @Override + public String[] getDescription() { + return new String[] { + translateToLocal("gt.blockmachines.tt.transformer.tier." + (mTier > 9 ? "" : "0") + mTier + ".desc"), + CommonValues.TEC_MARK_GENERAL }; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/single/MTEWetTransformer.java b/src/main/java/tectech/thing/metaTileEntity/single/MTEWetTransformer.java new file mode 100644 index 0000000000..4e42619376 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/single/MTEWetTransformer.java @@ -0,0 +1,49 @@ +package tectech.thing.metaTileEntity.single; + +import static gregtech.api.enums.GTValues.V; +import static net.minecraft.util.StatCollector.translateToLocal; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import tectech.util.CommonValues; + +@Deprecated +public class MTEWetTransformer extends MTETransformerTT { + + public MTEWetTransformer(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEWetTransformer(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public String[] getDescription() { + return new String[] { + translateToLocal("gt.blockmachines.wetransformer.tier." + (mTier > 9 ? "" : "0") + mTier + ".desc"), + "Accepts 16A and outputs 64A", CommonValues.TEC_MARK_GENERAL }; + } + + @Override + public long getMinimumStoredEU() { + return V[mTier + 1]; + } + + @Override + public long maxEUStore() { + return 512L + V[mTier + 1] * 128L; + } + + @Override + public long maxAmperesOut() { + return getBaseMetaTileEntity().isAllowedToWork() ? 64 : 16; + } + + @Override + public long maxAmperesIn() { + return getBaseMetaTileEntity().isAllowedToWork() ? 16 : 64; + } +} |