diff options
Diffstat (limited to 'src/main/java/goodgenerator')
8 files changed, 602 insertions, 13 deletions
diff --git a/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java new file mode 100644 index 0000000000..8387662298 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java @@ -0,0 +1,106 @@ +package goodgenerator.blocks.regularBlock; + +import goodgenerator.client.render.BlockRenderHandler; +import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase; +import goodgenerator.main.GoodGenerator; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.render.TextureFactory; +import net.minecraft.block.Block; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.IBlockAccess; + +public class TurbineCasing extends Casing { + + public static IIconContainer[][] turbineShape = new IIconContainer[3][9]; + public IIconContainer base; + + static { + for (int i = 0; i < 3; i ++) + for (int j = 1; j <= 9; j ++) + turbineShape[i][j - 1] = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_" + i + "" + j); + } + + public TurbineCasing(String name, String texture) { + super(name, new String[]{GoodGenerator.MOD_ID + ":" + texture}); + base = new Textures.BlockIcons.CustomIcon("icons/" + texture); + } + + private static int isTurbineControllerWithSide(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (!(tTileEntity instanceof IGregTechTileEntity)) return 0; + IGregTechTileEntity tTile = (IGregTechTileEntity) tTileEntity; + if (tTile.getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase && tTile.getFrontFacing() == aSide) { + if (tTile.isActive()) return 1; + return ((GT_MetaTileEntity_LargeTurbineBase) tTile.getMetaTileEntity()).hasTurbine() ? 2 : 3; + } + return 0; + } + + public ITexture[] getTurbineCasing(int iconIndex, boolean active, boolean hasTurbine) { + int states = active ? 0 : hasTurbine ? 1 : 2; + return new ITexture[] { + TextureFactory.of(base), + TextureFactory.of(turbineShape[states][iconIndex]) + }; + } + + public ITexture[] getTexture(Block aBlock, byte aSide) { + return new ITexture[] { + TextureFactory.of(base) + }; + } + + public ITexture[] getTexture(Block aBlock, byte aSide, IBlockAccess aWorld, int xCoord, int yCoord, int zCoord) { + int tInvertLeftRightMod = aSide % 2 * 2 - 1; + switch (aSide / 2) { + case 0: + for (int i = -1; i < 2; i++) { + for (int j = -1; j < 2; j++) { + if (i == 0 && j == 0) + continue; + int tState; + if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord, zCoord + i, aSide)) != 0) { + return getTurbineCasing(4 - i * 3 - j, tState == 1, tState == 2); + } + } + } + break; + case 1: + for (int i = -1; i < 2; i++) { + for (int j = -1; j < 2; j++) { + if (i == 0 && j == 0) + continue; + int tState; + if ((tState = isTurbineControllerWithSide(aWorld, xCoord + j, yCoord + i, zCoord, aSide)) != 0) { + return getTurbineCasing(4 + i * 3 - j * tInvertLeftRightMod, tState == 1, tState == 2); + } + } + } + break; + case 2: + for (int i = -1; i < 2; i++) { + for (int j = -1; j < 2; j++) { + if (i == 0 && j == 0) + continue; + int tState; + if ((tState = isTurbineControllerWithSide(aWorld, xCoord, yCoord + i, zCoord + j, aSide)) != 0) { + return getTurbineCasing(4 + i * 3 + j * tInvertLeftRightMod, tState == 1, tState == 2); + } + } + } + break; + } + return getTexture(aBlock, aSide); + } + + @Override + public int getRenderType() { + if (BlockRenderHandler.INSTANCE == null) { + return super.getRenderType(); + } + return BlockRenderHandler.INSTANCE.mRenderID; + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java new file mode 100644 index 0000000000..95fd4b3396 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/ExtremeHeatExchanger.java @@ -0,0 +1,36 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; +import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.item.ItemStack; + +public class ExtremeHeatExchanger extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { + + protected IStructureDefinition<ExtremeHeatExchanger> multiDefinition = null; + + public ExtremeHeatExchanger(String name) { + super(name); + } + + public ExtremeHeatExchanger(int id, String name, String nameRegional) { + super(id, name, nameRegional); + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return new String[0]; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new ExtremeHeatExchanger(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java b/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java deleted file mode 100644 index 29aa1f3e1c..0000000000 --- a/src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java +++ /dev/null @@ -1,5 +0,0 @@ -package goodgenerator.blocks.tileEntity; - -public class MetalVaporTurbine{ - -} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java b/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java new file mode 100644 index 0000000000..f2f63f5e01 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/SupercriticalFluidTurbine.java @@ -0,0 +1,84 @@ +package goodgenerator.blocks.tileEntity; + +import goodgenerator.blocks.tileEntity.base.GT_MetaTileEntity_LargeTurbineBase; +import goodgenerator.loader.Loaders; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import net.minecraft.block.Block; +import net.minecraftforge.fluids.FluidStack; + +import java.util.ArrayList; + +public class SupercriticalFluidTurbine extends GT_MetaTileEntity_LargeTurbineBase { + + private static final IIconContainer turbineOn = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_05"); + private static final IIconContainer turbineOff = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_15"); + private static final IIconContainer turbineEmpty = new Textures.BlockIcons.CustomIcon("icons/turbines/TURBINE_25"); + + public SupercriticalFluidTurbine(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public SupercriticalFluidTurbine(String aName) { + super(aName); + } + + @Override + public int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff) { + return 0; + } + + @Override + public Block getCasingBlock() { + return Loaders.supercriticalFluidTurbineCasing; + } + + @Override + public int getCasingMeta() { + return 0; + } + + @Override + public int getCasingTextureIndex() { + return 1538; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Supercritical Fluid Turbine") + .addInfo("Controller block for Supercritical Fluid Turbine") + .addInfo("Needs a Turbine, place inside controller") + .addInfo("The Supercritical Fluid's temperature gives extra efficiency.") + .addSeparator() + .beginStructureBlock(3, 3, 4, true) + .addController("Front center") + .addCasingInfo("SC Turbine Casing", 24) + .addDynamoHatch("Back center", 1) + .addMaintenanceHatch("Side centered", 2) + .addMufflerHatch("Side centered", 2) + .addInputHatch("Supercritical Fluid, Side centered", 2) + .toolTipFinisher("Good Generator"); + return tt; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new SupercriticalFluidTurbine(mName); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] { + Textures.BlockIcons.getCasingTextureForId(1538), + aFacing == aSide ? + (aActive ? TextureFactory.of(turbineOn) : hasTurbine() ? TextureFactory.of(turbineOff) : TextureFactory.of(turbineEmpty)) + : Textures.BlockIcons.getCasingTextureForId(1538) + }; + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java new file mode 100644 index 0000000000..5b9bfaaf79 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/base/GT_MetaTileEntity_LargeTurbineBase.java @@ -0,0 +1,256 @@ +//copied from gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine +//The origin one in gt made the abstract method private so i can't imp it. +package goodgenerator.blocks.tileEntity.base; + +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.IStructureElementCheckOnly; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import gregtech.api.gui.GT_GUIContainer_MultiMachine; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.GT_MetaGenerated_Tool_01; +import net.minecraft.block.Block; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.FluidStack; + +import java.util.ArrayList; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional; + +public abstract class GT_MetaTileEntity_LargeTurbineBase extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_LargeTurbineBase> { + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase>>() { + @Override + protected IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> computeValue(Class<?> type) { + return StructureDefinition.<GT_MetaTileEntity_LargeTurbineBase>builder() + .addShape(STRUCTURE_PIECE_MAIN, transpose(new String[][]{ + {" ", "xxxxx", "xxxxx", "xxxxx", "xxxxx",}, + {" --- ", "xcccx", "xchcx", "xchcx", "xcccx",}, + {" --- ", "xc~cx", "xh-hx", "xh-hx", "xcdcx",}, + {" --- ", "xcccx", "xchcx", "xchcx", "xcccx",}, + {" ", "xxxxx", "xxxxx", "xxxxx", "xxxxx",}, + })) + .addElement('c', lazy(t -> ofBlock(t.getCasingBlock(), t.getCasingMeta()))) + .addElement('d', lazy(t -> ofHatchAdder(GT_MetaTileEntity_LargeTurbineBase::addDynamoToMachineList, t.getCasingTextureIndex(), 1))) + .addElement('h', lazy(t -> ofHatchAdderOptional(GT_MetaTileEntity_LargeTurbineBase::addToMachineList, t.getCasingTextureIndex(), 2, t.getCasingBlock(), t.getCasingMeta()))) + .addElement('x', (IStructureElementCheckOnly<GT_MetaTileEntity_LargeTurbineBase>) (aContext, aWorld, aX, aY, aZ) -> { + TileEntity tTile = aWorld.getTileEntity(aX, aY, aZ); + return !(tTile instanceof IGregTechTileEntity) || !(((IGregTechTileEntity) tTile).getMetaTileEntity() instanceof GT_MetaTileEntity_LargeTurbineBase); + }) + .build(); + } + }; + + protected int baseEff = 0; + protected int optFlow = 0; + protected double realOptFlow = 0; + protected int storedFluid = 0; + protected int counter = 0; + protected boolean looseFit = false; + + public GT_MetaTileEntity_LargeTurbineBase(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_LargeTurbineBase(String aName) { + super(aName); + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return getMaxEfficiency(aStack) > 0; + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "LargeTurbine.png"); + } + + @Override + public IStructureDefinition<GT_MetaTileEntity_LargeTurbineBase> getStructureDefinition() { + return STRUCTURE_DEFINITION.get(getClass()); + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + return checkPiece(STRUCTURE_PIECE_MAIN, 2, 2, 1) && mMaintenanceHatches.size() == 1 && mMufflerHatches.isEmpty() == (getPollutionPerTick(null) == 0); + } + + public abstract Block getCasingBlock(); + + public abstract int getCasingMeta(); + + public abstract int getCasingTextureIndex(); + + @Override + public boolean addToMachineList(IGregTechTileEntity tTileEntity, int aBaseCasingIndex) { + return addMaintenanceToMachineList(tTileEntity, getCasingTextureIndex()) || addInputToMachineList(tTileEntity, getCasingTextureIndex()) || addOutputToMachineList(tTileEntity, getCasingTextureIndex()) || addMufflerToMachineList(tTileEntity, getCasingTextureIndex()); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + } + + @Override + public boolean checkRecipe(ItemStack aStack) { + if ((counter & 7) == 0 && (aStack == null || !(aStack.getItem() instanceof GT_MetaGenerated_Tool) || aStack.getItemDamage() < 170 || aStack.getItemDamage() > 179)) { + stopMachine(); + return false; + } + ArrayList<FluidStack> tFluids = getStoredFluids(); + if (tFluids.size() > 0) { + if (baseEff == 0 || optFlow == 0 || counter >= 512 || this.getBaseMetaTileEntity().hasWorkJustBeenEnabled() + || this.getBaseMetaTileEntity().hasInventoryBeenModified()) { + counter = 0; + baseEff = GT_Utility.safeInt((long) ((5F + ((GT_MetaGenerated_Tool) aStack.getItem()).getToolCombatDamage(aStack)) * 1000F)); + optFlow = GT_Utility.safeInt((long) Math.max(Float.MIN_NORMAL, + ((GT_MetaGenerated_Tool) aStack.getItem()).getToolStats(aStack).getSpeedMultiplier() + * GT_MetaGenerated_Tool.getPrimaryMaterial(aStack).mToolSpeed + * 50)); + if(optFlow<=0 || baseEff<=0){ + stopMachine();//in case the turbine got removed + return false; + } + } else { + counter++; + } + } + + int newPower = fluidIntoPower(tFluids, optFlow, baseEff); // How much the turbine should be producing with this flow + int difference = newPower - this.mEUt; // difference between current output and new output + + // Magic numbers: can always change by at least 10 eu/t, but otherwise by at most 1 percent of the difference in power level (per tick) + // This is how much the turbine can actually change during this tick + int maxChangeAllowed = Math.max(10, GT_Utility.safeInt((long)Math.abs(difference)/100)); + + if (Math.abs(difference) > maxChangeAllowed) { // If this difference is too big, use the maximum allowed change + int change = maxChangeAllowed * (difference > 0 ? 1 : -1); // Make the change positive or negative. + this.mEUt += change; // Apply the change + } else + this.mEUt = newPower; + + if (this.mEUt <= 0) { + //stopMachine(); + this.mEUt=0; + this.mEfficiency=0; + return false; + } else { + this.mMaxProgresstime = 1; + this.mEfficiencyIncrease = 10; + // Overvoltage is handled inside the MultiBlockBase when pushing out to dynamos. no need to do it here. + return true; + } + } + + public abstract int fluidIntoPower(ArrayList<FluidStack> aFluids, int aOptFlow, int aBaseEff); + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 1; + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack)) { + return 0; + } + if (aStack.getItem() instanceof GT_MetaGenerated_Tool_01) { + return 10000; + } + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return true; + } + + @Override + public String[] getInfoData() { + int mPollutionReduction=0; + for (GT_MetaTileEntity_Hatch_Muffler tHatch : mMufflerHatches) { + if (isValidMetaTileEntity(tHatch)) { + mPollutionReduction=Math.max(tHatch.calculatePollutionReduction(100),mPollutionReduction); + } + } + + String tRunning = mMaxProgresstime>0 ? + + EnumChatFormatting.GREEN+StatCollector.translateToLocal("GT5U.turbine.running.true")+EnumChatFormatting.RESET : + EnumChatFormatting.RED+StatCollector.translateToLocal("GT5U.turbine.running.false")+EnumChatFormatting.RESET; + String tMaintainance = getIdealStatus() == getRepairStatus() ? + EnumChatFormatting.GREEN+StatCollector.translateToLocal("GT5U.turbine.maintenance.false")+EnumChatFormatting.RESET : + EnumChatFormatting.RED+StatCollector.translateToLocal("GT5U.turbine.maintenance.true")+EnumChatFormatting.RESET ; + int tDura = 0; + + if (mInventory[1] != null && mInventory[1].getItem() instanceof GT_MetaGenerated_Tool_01) { + tDura = GT_Utility.safeInt((long)(100.0f / GT_MetaGenerated_Tool.getToolMaxDamage(mInventory[1]) * (GT_MetaGenerated_Tool.getToolDamage(mInventory[1]))+1)); + } + + long storedEnergy=0; + long maxEnergy=0; + for(GT_MetaTileEntity_Hatch_Dynamo tHatch : mDynamoHatches) { + if (isValidMetaTileEntity(tHatch)) { + storedEnergy+=tHatch.getBaseMetaTileEntity().getStoredEU(); + maxEnergy+=tHatch.getBaseMetaTileEntity().getEUCapacity(); + } + } + String[] ret = new String[]{ + // 8 Lines available for information panels + tRunning + ": " + EnumChatFormatting.RED + GT_Utility.formatNumbers(mEUt) + EnumChatFormatting.RESET + " EU/t", /* 1 */ + tMaintainance, /* 2 */ + StatCollector.translateToLocal("GT5U.turbine.efficiency") + ": " + + EnumChatFormatting.YELLOW + (mEfficiency / 100F) + EnumChatFormatting.RESET + "%", /* 2 */ + StatCollector.translateToLocal("GT5U.multiblock.energy") + ": " + + EnumChatFormatting.GREEN + GT_Utility.formatNumbers(storedEnergy) + EnumChatFormatting.RESET + " EU / " + /* 3 */ + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(maxEnergy) + EnumChatFormatting.RESET + " EU", + StatCollector.translateToLocal("GT5U.turbine.flow") + ": " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(GT_Utility.safeInt((long) realOptFlow)) + EnumChatFormatting.RESET + " L/t" + /* 4 */ + EnumChatFormatting.YELLOW + " (" + (looseFit ? StatCollector.translateToLocal("GT5U.turbine.loose") : StatCollector.translateToLocal("GT5U.turbine.tight")) + ")", /* 5 */ + StatCollector.translateToLocal("GT5U.turbine.fuel") + ": " + + EnumChatFormatting.GOLD + GT_Utility.formatNumbers(storedFluid) + EnumChatFormatting.RESET + "L", /* 6 */ + StatCollector.translateToLocal("GT5U.turbine.dmg") + ": " + + EnumChatFormatting.RED + tDura + EnumChatFormatting.RESET + "%", /* 7 */ + StatCollector.translateToLocal("GT5U.multiblock.pollution") + ": " + + EnumChatFormatting.GREEN + mPollutionReduction + EnumChatFormatting.RESET + " %" /* 8 */ + }; + if (!this.getClass().getName().contains("Steam")) + ret[4] = StatCollector.translateToLocal("GT5U.turbine.flow") + ": " + EnumChatFormatting.YELLOW + GT_Utility.safeInt((long) realOptFlow) + EnumChatFormatting.RESET + " L/t"; + return ret; + + + } + + public boolean hasTurbine() { + return this.getMaxEfficiency(mInventory[1]) > 0; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 2, 1); + } +} diff --git a/src/main/java/goodgenerator/client/render/BlockRenderHandler.java b/src/main/java/goodgenerator/client/render/BlockRenderHandler.java new file mode 100644 index 0000000000..3d705baae6 --- /dev/null +++ b/src/main/java/goodgenerator/client/render/BlockRenderHandler.java @@ -0,0 +1,103 @@ +package goodgenerator.client.render; + +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; +import goodgenerator.blocks.regularBlock.TurbineCasing; +import gregtech.GT_Mod; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.world.IBlockAccess; +import org.lwjgl.opengl.GL11; + +import static gregtech.common.render.GT_Renderer_Block.*; +import static net.minecraftforge.common.util.ForgeDirection.*; +import static net.minecraftforge.common.util.ForgeDirection.EAST; + +public class BlockRenderHandler implements ISimpleBlockRenderingHandler { + + public static final float blockMin = 0.0F; + public static final float blockMax = 1.0F; + public static BlockRenderHandler INSTANCE; + public final int mRenderID; + + public BlockRenderHandler() { + this.mRenderID = RenderingRegistry.getNextAvailableRenderId(); + INSTANCE = this; + RenderingRegistry.registerBlockHandler(this); + } + + @Override + public void renderInventoryBlock(Block aBlock, int metadata, int modelId, RenderBlocks aRenderer) { + aRenderer.enableAO = false; + aRenderer.useInventoryTint = true; + + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + + if (aBlock instanceof TurbineCasing) { + TurbineCasing tc = (TurbineCasing) aBlock; + aBlock.setBlockBoundsForItemRender(); + aRenderer.setRenderBoundsFromBlock(aBlock); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0, -1, 0); + renderNegativeYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) DOWN.ordinal()), true); + Tessellator.instance.draw(); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0, 1, 0); + renderPositiveYFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) UP.ordinal()), true); + Tessellator.instance.draw(); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0, 0, -1); + renderNegativeZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) NORTH.ordinal()), true); + Tessellator.instance.draw(); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(0, 0, 1); + renderPositiveZFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) SOUTH.ordinal()), true); + Tessellator.instance.draw(); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(-1, 0, 0); + renderNegativeXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) WEST.ordinal()), true); + Tessellator.instance.draw(); + Tessellator.instance.startDrawingQuads(); + Tessellator.instance.setNormal(1, 0, 0); + renderPositiveXFacing(null, aRenderer, aBlock, 0, 0, 0, tc.getTexture(aBlock, (byte) EAST.ordinal()), true); + Tessellator.instance.draw(); + } + + aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax); + aRenderer.setRenderBoundsFromBlock(aBlock); + + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + aRenderer.useInventoryTint = false; + } + + @Override + public boolean renderWorldBlock(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, int aModelID, RenderBlocks aRenderer) { + aRenderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion; + aRenderer.useInventoryTint = false; + if (aBlock instanceof TurbineCasing) { + aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax); + aRenderer.setRenderBoundsFromBlock(aBlock); + TurbineCasing tc = (TurbineCasing) aBlock; + renderNegativeYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) DOWN.ordinal(), aWorld, aX, aY, aZ), true); + renderPositiveYFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) UP.ordinal(), aWorld, aX, aY, aZ), true); + renderNegativeZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) NORTH.ordinal(), aWorld, aX, aY, aZ), true); + renderPositiveZFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) SOUTH.ordinal(), aWorld, aX, aY, aZ), true); + renderNegativeXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) WEST.ordinal(), aWorld, aX, aY, aZ), true); + renderPositiveXFacing(aWorld, aRenderer, aBlock, aX, aY, aZ, tc.getTexture(aBlock, (byte) EAST.ordinal(), aWorld, aX, aY, aZ), true); + } + return false; + } + + @Override + public boolean shouldRender3DInInventory(int modelId) { + return true; + } + + @Override + public int getRenderId() { + return this.mRenderID; + } +} diff --git a/src/main/java/goodgenerator/loader/Loaders.java b/src/main/java/goodgenerator/loader/Loaders.java index 7883459194..6b0b3477bc 100644 --- a/src/main/java/goodgenerator/loader/Loaders.java +++ b/src/main/java/goodgenerator/loader/Loaders.java @@ -1,10 +1,8 @@ package goodgenerator.loader; import goodgenerator.blocks.myFluids.FluidsBuilder; -import goodgenerator.blocks.regularBlock.Casing; -import goodgenerator.blocks.regularBlock.ComplexTextureCasing; -import goodgenerator.blocks.regularBlock.Frame; -import goodgenerator.blocks.regularBlock.TEBlock; +import goodgenerator.blocks.regularBlock.*; +import goodgenerator.client.render.BlockRenderHandler; import goodgenerator.blocks.tileEntity.*; import goodgenerator.blocks.tileEntity.GTMetaTileEntity.DieselGenerator; import goodgenerator.blocks.tileEntity.GTMetaTileEntity.NeutronAccelerator; @@ -82,6 +80,8 @@ public class Loaders { public static final Block yottaFluidTankCell = new Casing("yottaFluidTankCell", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCell/1", GoodGenerator.MOD_ID+":yottaFluidTankCell/2", GoodGenerator.MOD_ID+":yottaFluidTankCell/3", GoodGenerator.MOD_ID+":yottaFluidTankCell/4", GoodGenerator.MOD_ID+":yottaFluidTankCell/5", GoodGenerator.MOD_ID+":yottaFluidTankCell/6", GoodGenerator.MOD_ID+":yottaFluidTankCell/7", GoodGenerator.MOD_ID+":yottaFluidTankCell/8", GoodGenerator.MOD_ID+":yottaFluidTankCell/9", GoodGenerator.MOD_ID+":yottaFluidTankCell/10",}); public static final Block yottaFluidTankCasing = new ComplexTextureCasing("yottaFluidTankCasing", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_SIDE"}, new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_TOP"}); + public static final Block supercriticalFluidTurbineCasing = new TurbineCasing("supercriticalFluidTurbineCasing", "supercriticalFluidTurbineCasing"); + public static final Block pressureResistantWalls = new Casing("pressureResistantWalls", new String[]{GoodGenerator.MOD_ID+":pressureResistantWalls"}); public static Block essentiaHatch; @@ -93,6 +93,7 @@ public class Loaders { public static ItemStack NA; public static ItemStack YFT; public static ItemStack YFH; + public static ItemStack SCTurbine; public static ItemStack[] NeutronAccelerators = new ItemStack[9]; public static ItemStack[] Generator_Diesel = new ItemStack[2]; @@ -109,9 +110,10 @@ public class Loaders { Loaders.NS = new NeutronSensor(IDOffset + 11, "Neutron Sensor", "Neutron Sensor", 5).getStackForm(1L); Loaders.NA = new NeutronActivator(IDOffset + 12, "NeutronActivator", "Neutron Activator").getStackForm(1L); Loaders.YFT = new YottaFluidTank(IDOffset + 13, "YottaFluidTank", "YOTTank").getStackForm(1L); - Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1); - Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1); - Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1); + Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L); + Loaders.SCTurbine = new SupercriticalFluidTurbine(IDOffset + 15, "SupercriticalFluidTurbine", "SC Fluid Turbine").getStackForm(1L); + Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1L); + Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1L); } public static void Register() { @@ -131,6 +133,8 @@ public class Loaders { GameRegistry.registerBlock(speedingPipe, MyItemBlocks.class, "speedingPipe"); GameRegistry.registerBlock(yottaFluidTankCell, MyItemBlocks.class, "yottaFluidTankCells"); GameRegistry.registerBlock(yottaFluidTankCasing, MyItemBlocks.class, "yottaFluidTankCasing"); + GameRegistry.registerBlock(supercriticalFluidTurbineCasing, MyItemBlocks.class, "supercriticalFluidTurbineCasing"); + GameRegistry.registerBlock(pressureResistantWalls, MyItemBlocks.class, "pressureResistantWalls"); GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID); GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID); GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID); @@ -182,10 +186,11 @@ public class Loaders { Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128]; Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][0] = TextureFactory.of(magicCasing); Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory.of(yottaFluidTankCasing); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory.of(supercriticalFluidTurbineCasing); } } - public static void preInitLoad(){ + public static void preInitLoad() { Register(); addOreDic(); addTexturePage(); @@ -196,6 +201,7 @@ public class Loaders { } public static void initLoad(){ + new BlockRenderHandler(); GTMetaTileRegister(); initLoadRecipes(); IMCForNEI.IMCSender(); diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java index 8bb80e10df..f666fea41d 100644 --- a/src/main/java/goodgenerator/util/ItemRefer.java +++ b/src/main/java/goodgenerator/util/ItemRefer.java @@ -94,6 +94,8 @@ public final class ItemRefer { public static ItemRefer YOTTank_Cell_T8 = getItemStack(yottaFluidTankCell, 7); public static ItemRefer YOTTank_Cell_T9 = getItemStack(yottaFluidTankCell, 8); public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9); + public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing); + public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls); public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR); public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF); @@ -102,6 +104,7 @@ public final class ItemRefer { public static ItemRefer YOTTank = getItemStack(YFT); public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]); public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]); + public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine); private Item mItem = null; private Block mBlock = null; |