From bea4cfc54566b4f3b9971d1da93782b03410f669 Mon Sep 17 00:00:00 2001 From: Shawn Buckley Date: Wed, 21 Oct 2015 20:47:13 -0400 Subject: Bring in experimental branch --- .../basic/GT_MetaTileEntity_Boxinator.java | 11 +- .../machines/basic/GT_MetaTileEntity_Charger.java | 79 ++++++ .../basic/GT_MetaTileEntity_Massfabricator.java | 8 +- ..._MetaTileEntity_MicrowaveEnergyTransmitter.java | 296 +++++++++++++++++++++ .../machines/basic/GT_MetaTileEntity_Pump.java | 5 +- .../machines/basic/GT_MetaTileEntity_Scanner.java | 14 + .../basic/GT_MetaTileEntity_SeismicProspector.java | 109 ++++++++ .../basic/GT_MetaTileEntity_Teleporter.java | 49 +++- .../multi/GT_MetaTileEntity_AdvMiner2.java | 261 ++++++++++++++++++ .../multi/GT_MetaTileEntity_Charcoal_Pit.java | 214 +++++++++++++++ .../multi/GT_MetaTileEntity_DistillationTower.java | 10 +- .../multi/GT_MetaTileEntity_FusionComputer.java | 7 +- .../multi/GT_MetaTileEntity_FusionComputer1.java | 2 +- .../multi/GT_MetaTileEntity_FusionComputer2.java | 1 - .../multi/GT_MetaTileEntity_FusionComputer3.java | 2 - .../multi/GT_MetaTileEntity_HeatExchanger.java | 1 + .../multi/GT_MetaTileEntity_LargeBoiler.java | 26 +- .../GT_MetaTileEntity_LargeBoiler_Bronze.java | 5 + .../multi/GT_MetaTileEntity_LargeBoiler_Steel.java | 5 + .../GT_MetaTileEntity_LargeBoiler_Titanium.java | 153 +++++------ ...T_MetaTileEntity_LargeBoiler_TungstenSteel.java | 6 + .../multi/GT_MetaTileEntity_LargeTurbine.java | 2 +- .../GT_MetaTileEntity_LargeTurbine_HPSteam.java | 2 +- .../GT_MetaTileEntity_LargeTurbine_Plasma.java | 6 +- .../GT_MetaTileEntity_LargeTurbine_Steam.java | 10 +- .../multi/GT_MetaTileEntity_OilCracker.java | 241 +++++++++++++++++ .../machines/multi/GT_MetaTileEntity_OilDrill.java | 208 +++++++++++++++ .../multi/GT_MetaTileEntity_ProcessingArray.java | 12 +- .../multi/GT_MetaTileEntity_PyrolyseOven.java | 171 ++++++++++++ .../steam/GT_MetaTileEntity_Macerator_Bronze.java | 264 +++++++++--------- 30 files changed, 1921 insertions(+), 259 deletions(-) create mode 100644 src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Charger.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_SeismicProspector.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AdvMiner2.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_Charcoal_Pit.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilCracker.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_OilDrill.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PyrolyseOven.java (limited to 'src/main/java/gregtech/common/tileentities/machines') diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Boxinator.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Boxinator.java index 23b9d74fb7..fad3acec3f 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Boxinator.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Boxinator.java @@ -14,7 +14,6 @@ import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Recipe.GT_Recipe_Map; import gregtech.api.util.GT_Utility; import net.minecraft.item.ItemStack; -import net.minecraft.item.crafting.CraftingManager; public class GT_MetaTileEntity_Boxinator extends GT_MetaTileEntity_BasicMachine @@ -98,11 +97,11 @@ public class GT_MetaTileEntity_Boxinator if (super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) { if ((ItemList.Schematic_1by1.isStackEqual(getInputAt(1))) || (ItemList.Schematic_2by2.isStackEqual(getInputAt(1))) || (ItemList.Schematic_3by3.isStackEqual(getInputAt(1)))) { - if(GT_Recipe.GT_Recipe_Map.sBoxinatorRecipes.findRecipe(getBaseMetaTileEntity(), true, gregtech.api.enums.GT_Values.V[this.mTier], null, new ItemStack[] { GT_Utility.copyAmount(64L, new Object[] { aStack }), getInputAt(1) }) != null){return true;} - if(ItemList.Schematic_1by1.isStackEqual(getInputAt(1))&>_ModHandler.getRecipeOutput(new ItemStack[] { aStack })!=null)return true; - if(ItemList.Schematic_2by2.isStackEqual(getInputAt(1))&>_ModHandler.getRecipeOutput(new ItemStack[] { aStack, aStack, null, aStack, aStack })!=null){return true;} - if(ItemList.Schematic_3by3.isStackEqual(getInputAt(1))&&(GT_ModHandler.getRecipeOutput(new ItemStack[] { aStack,aStack,aStack,aStack,aStack,aStack,aStack,aStack,aStack })!=null)){return true;} - }else{return GT_Recipe.GT_Recipe_Map.sBoxinatorRecipes.containsInput(aStack);} + if(GT_Recipe.GT_Recipe_Map.sBoxinatorRecipes.findRecipe(getBaseMetaTileEntity(), true, gregtech.api.enums.GT_Values.V[this.mTier], null, new ItemStack[] { GT_Utility.copyAmount(64L, new Object[] { aStack }), getInputAt(1) }) != null){return true;} + if(ItemList.Schematic_1by1.isStackEqual(getInputAt(1))&>_ModHandler.getRecipeOutput(new ItemStack[] { aStack })!=null)return true; + if(ItemList.Schematic_2by2.isStackEqual(getInputAt(1))&>_ModHandler.getRecipeOutput(new ItemStack[] { aStack, aStack, null, aStack, aStack })!=null){return true;} + if(ItemList.Schematic_3by3.isStackEqual(getInputAt(1))&&(GT_ModHandler.getRecipeOutput(new ItemStack[] { aStack,aStack,aStack,aStack,aStack,aStack,aStack,aStack,aStack })!=null)){return true;} + }else{return GT_Recipe.GT_Recipe_Map.sBoxinatorRecipes.containsInput(aStack);} } return false; } diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Charger.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Charger.java new file mode 100644 index 0000000000..8504cf3197 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Charger.java @@ -0,0 +1,79 @@ +package gregtech.common.tileentities.machines.basic; + +import static gregtech.api.enums.GT_Values.V; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicBatteryBuffer; +import gregtech.api.util.GT_ModHandler; + +public class GT_MetaTileEntity_Charger extends GT_MetaTileEntity_BasicBatteryBuffer { + + public GT_MetaTileEntity_Charger(int aID, String aName, String aNameRegional, int aTier, String aDescription, int aSlotCount) { + super(aID, aName, aNameRegional, aTier, aDescription, aSlotCount); + } + + public GT_MetaTileEntity_Charger(String aName, int aTier, String aDescription, ITexture[][][] aTextures, int aSlotCount) { + super(aName, aTier, aDescription, aTextures, aSlotCount); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Charger(mName, mTier, mDescription, mTextures, mInventory.length); + } + + @Override + public long getMinimumStoredEU() { + return V[mTier] * 64 * mInventory.length; + } + + @Override + public long maxEUStore() { + return V[mTier] * 256 * mInventory.length; + } + + @Override + public long maxAmperesIn() { + return mChargeableCount * 8; + } + + @Override + public long maxAmperesOut() { + return mBatteryCount * 4; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + super.onPostTick(aBaseMetaTileEntity, aTick); + if (this.getBaseMetaTileEntity() instanceof BaseMetaTileEntity) { + BaseMetaTileEntity mBaseMetaTileEntity = (BaseMetaTileEntity) getBaseMetaTileEntity(); + if (mBaseMetaTileEntity.getMetaTileEntity() instanceof MetaTileEntity) { + MetaTileEntity mMetaTileEntity = (MetaTileEntity) mBaseMetaTileEntity.getMetaTileEntity(); + //for (int t = 0; t < 6; t++) { + if (mMetaTileEntity.dechargerSlotCount() > 0 && mBaseMetaTileEntity.getStoredEU() < mBaseMetaTileEntity.getEUCapacity()) { + for (int i = mMetaTileEntity.dechargerSlotStartIndex(), k = mMetaTileEntity.dechargerSlotCount() + i; i < k; i++) { + if (mMetaTileEntity.mInventory[i] != null && mBaseMetaTileEntity.getStoredEU() < mBaseMetaTileEntity.getEUCapacity()) { + mBaseMetaTileEntity.increaseStoredEnergyUnits(GT_ModHandler.dischargeElectricItem(mMetaTileEntity.mInventory[i], (int)Math.min(V[mTier]*15, mBaseMetaTileEntity.getEUCapacity() - mBaseMetaTileEntity.getStoredEU()), (int)Math.min(Integer.MAX_VALUE, mMetaTileEntity.getInputTier()), true, false, false), true); + if (mMetaTileEntity.mInventory[i].stackSize <= 0) + mMetaTileEntity.mInventory[i] = null; + } + } + } + if (mMetaTileEntity.rechargerSlotCount() > 0 && mBaseMetaTileEntity.getStoredEU() > 0) { + for (int i = mMetaTileEntity.rechargerSlotStartIndex(), k = mMetaTileEntity.rechargerSlotCount() + i; i < k; i++) { + if (mBaseMetaTileEntity.getStoredEU() > 0 && mMetaTileEntity.mInventory[i] != null) { + mBaseMetaTileEntity.decreaseStoredEU(GT_ModHandler.chargeElectricItem(mMetaTileEntity.mInventory[i], (int)Math.min(V[this.mTier]*15, mBaseMetaTileEntity.getStoredEU()), (int)Math.min(Integer.MAX_VALUE, mMetaTileEntity.getOutputTier()), true, false), true); + if (mMetaTileEntity.mInventory[i].stackSize <= 0) + mMetaTileEntity.mInventory[i] = null; + } + } + //} + } + } + } + } + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java index 07337cd305..f82517bedc 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java @@ -1,5 +1,6 @@ package gregtech.common.tileentities.machines.basic; +import static gregtech.api.enums.GT_Values.V; import gregtech.api.enums.ConfigCategories; import gregtech.api.enums.ItemList; import gregtech.api.enums.Materials; @@ -46,14 +47,17 @@ public class GT_MetaTileEntity_Massfabricator Materials.UUAmplifier.mChemicalFormula = ("Mass Fabricator Eff/Speed Bonus: x" + sUUASpeedBonus); } +@Override public long maxAmperesIn(){return 10;} +@Override public long maxEUStore() {return V[mTier]*512;} + public int checkRecipe() { FluidStack tFluid = getDrainableStack(); if ((tFluid == null) || (tFluid.amount < getCapacity())) { this.mOutputFluid = Materials.UUMatter.getFluid(1L); - this.mEUt = ((int)gregtech.api.enums.GT_Values.V[this.mTier]); - this.mMaxProgresstime = (sDurationMultiplier / (1 << this.mTier - 1)); + this.mEUt = ((int)gregtech.api.enums.GT_Values.V[this.mTier])*8; + this.mMaxProgresstime = (sDurationMultiplier / (1 << (this.mTier*2) - 2)); if (((tFluid = getFillableStack()) != null) && (tFluid.amount >= sUUAperUUM) && (tFluid.isFluidEqual(Materials.UUAmplifier.getFluid(1L)))) { tFluid.amount -= sUUAperUUM; diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java new file mode 100644 index 0000000000..11489dfa56 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_MicrowaveEnergyTransmitter.java @@ -0,0 +1,296 @@ + +package gregtech.common.tileentities.machines.basic; + +import static gregtech.api.enums.GT_Values.V; +import net.minecraft.client.particle.EntityFX; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityHanging; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.boss.EntityDragonPart; +import net.minecraft.entity.effect.EntityWeatherEffect; +import net.minecraft.entity.item.EntityBoat; +import net.minecraft.entity.item.EntityEnderCrystal; +import net.minecraft.entity.item.EntityEnderEye; +import net.minecraft.entity.item.EntityFireworkRocket; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.item.EntityMinecart; +import net.minecraft.entity.item.EntityTNTPrimed; +import net.minecraft.entity.item.EntityXPOrb; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.entity.projectile.EntityFireball; +import net.minecraft.entity.projectile.EntityFishHook; +import net.minecraft.entity.projectile.EntityThrowable; +import net.minecraft.init.Blocks; +import net.minecraft.inventory.IInventory; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.world.World; +import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.fluids.FluidStack; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.gui.GT_Container_MultiMachine; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IEnergyConnected; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_Utility; +import gregtech.common.gui.GT_Container_MicrowaveEnergyTransmitter; +import gregtech.common.gui.GT_Container_Teleporter; +import gregtech.common.gui.GT_GUIContainer_FusionReactor; +import gregtech.common.gui.GT_GUIContainer_MicrowaveEnergyTransmitter; +import gregtech.common.gui.GT_GUIContainer_Teleporter; + +public class GT_MetaTileEntity_MicrowaveEnergyTransmitter extends GT_MetaTileEntity_BasicTank{ + + public int mTargetX = 0; + public int mTargetY = 0; + public int mTargetZ = 0; + public int mTargetD = 0; + public boolean mDebug = false; + public boolean hasEgg = false; + public static boolean sInterDimensionalTeleportAllowed = true; + public int mMaxLoss = 50; + public int mMaxLossDistance = 10000; + public boolean mPassiveEnergyUse = true; + + public GT_MetaTileEntity_MicrowaveEnergyTransmitter(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 3, "Transmits Energy wireless"); + } + + public GT_MetaTileEntity_MicrowaveEnergyTransmitter(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 3, aDescription, aTextures); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + this.hasEgg = checkForEgg(); + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + + @Override + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_Container_MicrowaveEnergyTransmitter(aPlayerInventory, aBaseMetaTileEntity); + } + + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_GUIContainer_MicrowaveEnergyTransmitter(aPlayerInventory, aBaseMetaTileEntity); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_MicrowaveEnergyTransmitter(this.mName, this.mTier, this.mDescription, this.mTextures); + } + + public String[] getInfoData() + { + return new String[] { "Coordinates:", "X: " + this.mTargetX, "Y: " + this.mTargetY, "Z: " + this.mTargetZ, "Dimension: " + this.mTargetD }; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1], (aSide == 0) ? null : aActive ? new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TELEPORTER_ACTIVE) : new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TELEPORTER) }; + } + + + public void saveNBTData(NBTTagCompound aNBT) + { + if (mFluid != null) aNBT.setTag("mFluid", mFluid.writeToNBT(new NBTTagCompound())); + aNBT.setInteger("mTargetX", this.mTargetX); + aNBT.setInteger("mTargetY", this.mTargetY); + aNBT.setInteger("mTargetZ", this.mTargetZ); + aNBT.setInteger("mTargetD", this.mTargetD); + aNBT.setBoolean("mDebug", this.mDebug); + } + + public void loadNBTData(NBTTagCompound aNBT) + { + mFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluid")); + this.mTargetX = aNBT.getInteger("mTargetX"); + this.mTargetY = aNBT.getInteger("mTargetY"); + this.mTargetZ = aNBT.getInteger("mTargetZ"); + this.mTargetD = aNBT.getInteger("mTargetD"); + this.mDebug = aNBT.getBoolean("mDebug"); + } + + public void onConfigLoad(GT_Config aConfig) + { + sInterDimensionalTeleportAllowed = aConfig.get(ConfigCategories.machineconfig, "Teleporter.Interdimensional", true); + mMaxLoss = Math.max(aConfig.get(ConfigCategories.machineconfig, "MicrowaveTransmitter.MaxLoss",50),11); + mMaxLossDistance = aConfig.get(ConfigCategories.machineconfig, "MicrowaveTransmitter.MaxLossDistance",10000); + mPassiveEnergyUse = aConfig.get(ConfigCategories.machineconfig, "MicrowaveTransmitter.PassiveEnergy",true); + } + + public void onFirstTick() + { + if (getBaseMetaTileEntity().isServerSide()) + { + if ((this.mTargetX == 0) && (this.mTargetY == 0) && (this.mTargetZ == 0) && (this.mTargetD == 0)) + { + this.mTargetX = getBaseMetaTileEntity().getXCoord(); + this.mTargetY = getBaseMetaTileEntity().getYCoord(); + this.mTargetZ = getBaseMetaTileEntity().getZCoord(); + this.mTargetD = getBaseMetaTileEntity().getWorld().provider.dimensionId; + } + this.hasEgg = checkForEgg(); + } + } + + public boolean checkForEgg() + { + for (byte i = -5; i <= 5; i = (byte)(i + 1)) { + for (byte j = -5; j <= 5; j = (byte)(j + 1)) { + for (byte k = -5; k <= 5; k = (byte)(k + 1)) { + if (getBaseMetaTileEntity().getBlockOffset(i, j, k) == Blocks.dragon_egg) { + return true; + } + } + } + } + return false; + } + + public boolean hasDimensionalTeleportCapability() + { + return (this.mDebug) || (this.hasEgg) || (mFluid.isFluidEqual(Materials.Nitrogen.getPlasma(1))&&mFluid.amount>=1000); + } + + public boolean isDimensionalTeleportAvailable() + { + return (this.mDebug) || ((hasDimensionalTeleportCapability()) && (GT_Utility.isRealDimension(this.mTargetD)) && (GT_Utility.isRealDimension(getBaseMetaTileEntity().getWorld().provider.dimensionId))); + } + + public int tTargetX = 0; + public int tTargetY = 0; + public int tTargetZ = 0; + public int tTargetD = 0; + public TileEntity tTile = null; + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if(mFluid==null){ + mFluid=Materials.Nitrogen.getPlasma(0); + } + super.onPostTick(aBaseMetaTileEntity, aTick); + if (getBaseMetaTileEntity().isServerSide()) + { + if (getBaseMetaTileEntity().getTimer() % 100L == 50L) { + this.hasEgg = checkForEgg(); + } + if ((getBaseMetaTileEntity().isAllowedToWork()) && (getBaseMetaTileEntity().getRedstone())) + { + if(getBaseMetaTileEntity().getStoredEU()>(V[mTier]*16)){ + if(mPassiveEnergyUse){getBaseMetaTileEntity().decreaseStoredEnergyUnits((long) Math.pow(2, mTier), false);} + if(hasDimensionalTeleportCapability()&&this.mTargetD != getBaseMetaTileEntity().getWorld().provider.dimensionId&&mFluid.isFluidEqual(Materials.Nitrogen.getPlasma(1))){ + mFluid.amount--; + if(mFluid.amount<1){mFluid=null;} + } + if(tTargetD!=mTargetD||tTargetX!=mTargetX||tTargetY!=mTargetY||tTargetZ!=mTargetZ){ + tTargetD=mTargetD; + tTargetX=mTargetX; + tTargetY=mTargetY; + tTargetZ=mTargetZ; + if(this.mTargetD == getBaseMetaTileEntity().getWorld().provider.dimensionId){ + tTile = getBaseMetaTileEntity().getTileEntity(this.mTargetX, this.mTargetY, this.mTargetZ);}else{ + World tWorld = DimensionManager.getWorld(this.mTargetD); + if(tWorld!=null){ + tTile = tWorld.getTileEntity(this.mTargetX, this.mTargetY, this.mTargetZ); + } + } + } + int tDistance = distanceCalculation(); + long tEnergyTrans = Math.min(V[mTier], getBaseMetaTileEntity().getStoredEU()); + if(tTile!=null&&tTile instanceof IEnergyConnected){ + if(((IEnergyConnected)tTile).injectEnergyUnits((byte) 6, V[mTier], 1)>0){ + int tLoss=1; + if(mMaxLossDistance!=0){ + tLoss = 10 + tDistance*(mMaxLoss-10)/mMaxLossDistance;} + getBaseMetaTileEntity().decreaseStoredEnergyUnits(V[mTier]+((V[mTier]*tLoss)/100), false); + } + } + } + getBaseMetaTileEntity().setActive(true); + } + else + { + getBaseMetaTileEntity().setActive(false); + } + } + } + + private int distanceCalculation() + { + return Math.abs(((this.mTargetD != getBaseMetaTileEntity().getWorld().provider.dimensionId) && (isDimensionalTeleportAvailable()) ? 100 : 1) * (int)Math.sqrt(Math.pow(getBaseMetaTileEntity().getXCoord() - this.mTargetX, 2.0D) + Math.pow(getBaseMetaTileEntity().getYCoord() - this.mTargetY, 2.0D) + Math.pow(getBaseMetaTileEntity().getZCoord() - this.mTargetZ, 2.0D))); + } + + @Override public boolean isSimpleMachine() {return false;} + @Override public boolean isOverclockerUpgradable() {return false;} + @Override public boolean isTransformerUpgradable() {return false;} + @Override public boolean isElectric() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return true;} + @Override public boolean isEnetInput() {return true;} + @Override public boolean isInputFacing(byte aSide) {return true;} + @Override public boolean isOutputFacing(byte aSide) {return false;} + @Override public boolean isTeleporterCompatible() {return false;} + @Override public long getMinimumStoredEU() {return V[mTier]*16;} + @Override public long maxEUStore() {return V[mTier]*256;} + @Override public long maxEUInput() {return V[mTier];} + @Override public long maxSteamStore() {return maxEUStore();} + @Override public long maxAmperesIn() {return 3;} + @Override public int getStackDisplaySlot() {return 2;} + @Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;} + @Override public int getInputSlot() {return 0;} + @Override public int getOutputSlot() {return 0;} + + @Override + public int getCapacity() {return 64000;} + + @Override + public boolean doesFillContainers() { + return false; + } + + @Override + public boolean doesEmptyContainers() { + return false; + } + + @Override + public boolean canTankBeFilled() { + return true; + } + + @Override + public boolean canTankBeEmptied() { + return true; + } + + @Override + public boolean displaysItemStack() { + return false; + } + + @Override + public boolean displaysStackSize() { + return false; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + +} diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java index 40020ef435..92248da910 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Pump.java @@ -196,10 +196,9 @@ public class GT_MetaTileEntity_Pump extends GT_MetaTileEntity_Hatch { } } else if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord(), y, getBaseMetaTileEntity().getZCoord()) != GT_Utility .getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))&&this.mInventory[0] != null&&this.mInventory[0].stackSize>0&>_Utility.areStacksEqual(this.mInventory[0], GT_ModHandler.getIC2Item("miningPipe", 1L))) { - getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord(), y, getBaseMetaTileEntity().getZCoord(), - GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))); + getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord(), y, getBaseMetaTileEntity().getZCoord(), + GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))); getBaseMetaTileEntity().decrStackSize(0, 1); - } return y; } diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java index 3360369114..a08ec27c23 100644 --- a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java @@ -171,6 +171,20 @@ public class GT_MetaTileEntity_Scanner return 2; } } + if(getSpecialSlot()==null&&ItemList.Tool_DataStick.isStackEqual(aStack, false, true)){ + if(GT_Utility.ItemNBT.getBookTitle(aStack).equals("Raw Prospection Data")){ + GT_Utility.ItemNBT.setBookTitle(aStack,"Analyzed Prospection Data"); + GT_Utility.ItemNBT.convertProspectionData(aStack); + aStack.stackSize -= 1; + + this.mOutputItems[0] = GT_Utility.copyAmount(1L, new Object[] { aStack }); + this.mMaxProgresstime = (1000 / (1 << this.mTier - 1)); + this.mEUt = (32 * (1 << this.mTier - 1) * (1 << this.mTier - 1)); + return 2; + + } + } + } return 0; } diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_SeismicProspector.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_SeismicProspector.java new file mode 100644 index 0000000000..09b06b033e --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_SeismicProspector.java @@ -0,0 +1,109 @@ +package gregtech.common.tileentities.machines.basic; + +import ic2.core.Ic2Items; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.fluids.FluidStack; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.blocks.GT_Block_Ores; +import gregtech.common.blocks.GT_TileEntity_Ores; + +public class GT_MetaTileEntity_SeismicProspector extends GT_MetaTileEntity_BasicMachine{ + + boolean ready = false; + + public GT_MetaTileEntity_SeismicProspector(int aID, String aName, String aNameRegional, int aTier) + { + super(aID, aName, aNameRegional, aTier, 1, "Place, activate with explosives, use Data Stick", 1, 1, "Default.png", "", new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_ROCK_BREAKER_ACTIVE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_ROCK_BREAKER), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_ROCK_BREAKER_ACTIVE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_ROCK_BREAKER), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER_ACTIVE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_ROCK_BREAKER_ACTIVE), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_ROCK_BREAKER) }); + } + + public GT_MetaTileEntity_SeismicProspector(String aName, int aTier, String aDescription, ITexture[][][] aTextures, String aGUIName, String aNEIName) + { + super(aName, aTier, 1, aDescription, aTextures, 1, 1, aGUIName, aNEIName); + } + + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_SeismicProspector(this.mName, this.mTier, this.mDescription, this.mTextures, this.mGUIName, this.mNEIName); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isServerSide()) { + ItemStack aStack = aPlayer.getCurrentEquippedItem(); + if ((aStack != null) && (aStack.getItem() == Item.getItemFromBlock(Blocks.tnt)||aStack.getItem() == Ic2Items.industrialTnt.getItem()) && aStack.stackSize > 7&&!ready) { + if ((!aPlayer.capabilities.isCreativeMode) && (aStack.stackSize != 111)) { + aStack.stackSize -= 8; + } + this.ready = true; + this.mMaxProgresstime = 200; + } else if (ready&&mMaxProgresstime==0&&aStack!=null&&aStack.stackSize==1&&aStack.getItem()==ItemList.Tool_DataStick.getItem()) { + this.ready=false; + GT_Utility.ItemNBT.setBookTitle(aPlayer.getCurrentEquippedItem(),"Raw Prospection Data"); + List tStringList = new ArrayList(); + for(int i = this.getBaseMetaTileEntity().getYCoord();i>0;i--){ + for(int f = -1; f<2;f++){ + for(int g = -1; g<2;g++){ + Block tBlock = this.getBaseMetaTileEntity().getBlockOffset(f, -i, g); + if ((tBlock instanceof GT_Block_Ores)) + { + TileEntity tTileEntity = getBaseMetaTileEntity().getWorld().getTileEntity(getBaseMetaTileEntity().getXCoord()+f, getBaseMetaTileEntity().getYCoord()+(-i), getBaseMetaTileEntity().getZCoord()+g); + if ((tTileEntity instanceof GT_TileEntity_Ores)) + { + Materials tMaterial = GregTech_API.sGeneratedMaterials[(((GT_TileEntity_Ores)tTileEntity).mMetaData % 1000)]; + if ((tMaterial != null) && (tMaterial != Materials._NULL)) + { + if(!tStringList.contains(tMaterial.mDefaultLocalName)){ + tStringList.add(tMaterial.mDefaultLocalName); + } + } + } + } + else + { + int tMetaID = getBaseMetaTileEntity().getWorld().getBlockMetadata(getBaseMetaTileEntity().getXCoord()+f, getBaseMetaTileEntity().getYCoord()+(-i), getBaseMetaTileEntity().getZCoord()+g); + ItemData tAssotiation = GT_OreDictUnificator.getAssociation(new ItemStack(tBlock, 1, tMetaID)); + if ((tAssotiation != null) && (tAssotiation.mPrefix.toString().startsWith("ore"))) + { + if(!tStringList.contains( tAssotiation.mMaterial.mMaterial.mDefaultLocalName)){ + tStringList.add( tAssotiation.mMaterial.mMaterial.mDefaultLocalName); + } + } + } + } + } + } + FluidStack tFluid = GT_Utility.getUndergroundOil(getBaseMetaTileEntity().getWorld(), getBaseMetaTileEntity().getXCoord(), getBaseMetaTileEntity().getZCoord()); + String[] tStringArray = new String[tStringList.size()];{ + for(int i = 0;i=1000); } public boolean isDimensionalTeleportAvailable() @@ -157,6 +164,9 @@ public class GT_MetaTileEntity_Teleporter extends GT_MetaTileEntity_BasicTank{ @Override public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if(mFluid==null){ + mFluid=Materials.Nitrogen.getPlasma(0); + } super.onPostTick(aBaseMetaTileEntity, aTick); if (getBaseMetaTileEntity().isServerSide()) { @@ -165,14 +175,40 @@ public class GT_MetaTileEntity_Teleporter extends GT_MetaTileEntity_BasicTank{ } if ((getBaseMetaTileEntity().isAllowedToWork()) && (getBaseMetaTileEntity().getRedstone())) { - if(getBaseMetaTileEntity().decreaseStoredEnergyUnits(8192, false)){ + if(getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048, false)){ + if(hasDimensionalTeleportCapability()&&this.mTargetD != getBaseMetaTileEntity().getWorld().provider.dimensionId&&mFluid.isFluidEqual(Materials.Nitrogen.getPlasma(1))){ + mFluid.amount--; + if(mFluid.amount<1){mFluid=null;} + } int tDistance = distanceCalculation(); + if(mInventory[0]!=null){ + TileEntity tTile = null; + if(this.mTargetD == getBaseMetaTileEntity().getWorld().provider.dimensionId){ + tTile = getBaseMetaTileEntity().getTileEntity(this.mTargetX, this.mTargetY, this.mTargetZ);}else{ + World tWorld = DimensionManager.getWorld(this.mTargetD); + if(tWorld!=null){ + tTile = tWorld.getTileEntity(this.mTargetX, this.mTargetY, this.mTargetZ); + } + } + if(tTile!=null&&tTile instanceof IInventory){ + int tStacksize = mInventory[0].stackSize; + GT_Utility.moveOneItemStack(this, tTile, (byte)0 ,(byte)0, null, false, (byte)64, (byte)1, (byte)64, (byte)1); + if(mInventory[0]==null||mInventory[0].stackSize mMineList = new ArrayList(); + private boolean completedCycle = false; + + @Override + public boolean checkRecipe(ItemStack aStack) { + if(mInventory[1]==null||(mInventory[1].isItemEqual(GT_ModHandler.getIC2Item("miningPipe", 1L)) && mInventory[1].stackSize tItems = getStoredInputs(); + for(ItemStack tStack : tItems){ + if(tStack.isItemEqual(GT_ModHandler.getIC2Item("miningPipe", 1L))){ + if(tStack.stackSize<2){ + tStack = null; + }else{tStack.stackSize--;} + + } + if(mInventory[1]==null){ + mInventory[1] = GT_ModHandler.getIC2Item("miningPipe", 1L); + }else{ + mInventory[1].stackSize++;} + } + } + if(mInputHatches==null||mInputHatches.get(0).mFluid==null||mInputHatches.get(0).mFluid.getFluid().getID()!=ItemList.sDrillingFluid.getID()){ + return false;} + FluidStack tFluid = mInputHatches.get(0).mFluid.copy(); + if(tFluid==null){ + return false; + } + if(tFluid.amount<20){ + return false; + } + tFluid.amount=100; + depleteInput(tFluid); + long tVoltage = getMaxInputVoltage(); + if(getBaseMetaTileEntity().getRandomNumber(20)==0){ + if(mMineList.isEmpty()){ + int yLevel = getYOfPumpHead(); + for(int i=-48;i<49;i++){ + for(int f=-48;f<49;f++){ + Block tBlock = getBaseMetaTileEntity().getBlockOffset(i, yLevel-getBaseMetaTileEntity().getYCoord(), f); + if(tBlock==GregTech_API.sBlockOres1){ + TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityOffset(i, yLevel-getBaseMetaTileEntity().getYCoord(), f); + if ((tTileEntity instanceof GT_TileEntity_Ores)&&((GT_TileEntity_Ores)tTileEntity).mNatural == true&&!mMineList.contains(new ChunkPosition(i, yLevel-getBaseMetaTileEntity().getYCoord(), f))){ + mMineList.add(new ChunkPosition(i, yLevel-getBaseMetaTileEntity().getYCoord(), f)); + } + } + } + } + } + if(mMineList.isEmpty()&&getBaseMetaTileEntity().getBlockOffset(ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX, getYOfPumpHead()-1-getBaseMetaTileEntity().getYCoord(), ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ)!=Blocks.bedrock){ + if(mEnergyHatches.size()>0&&mEnergyHatches.get(0).getEUVar()>(512+getMaxInputVoltage()*4)){moveOneDown();} + } + ArrayList tDrops = new ArrayList(); + if(!mMineList.isEmpty()){ + Block tMineBlock = getBaseMetaTileEntity().getBlockOffset(mMineList.get(0).chunkPosX,mMineList.get(0).chunkPosY,mMineList.get(0).chunkPosZ); + tDrops = tMineBlock.getDrops(getBaseMetaTileEntity().getWorld(), mMineList.get(0).chunkPosX,mMineList.get(0).chunkPosY,mMineList.get(0).chunkPosZ, getBaseMetaTileEntity().getMetaIDOffset(mMineList.get(0).chunkPosX,mMineList.get(0).chunkPosY,mMineList.get(0).chunkPosZ), 1); + if(!tDrops.isEmpty()){ + if(GT_OreDictUnificator.getItemData(tDrops.get(0)).mPrefix != OrePrefixes.crushed){ + GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.findRecipe(getBaseMetaTileEntity(), false, tVoltage, null , tDrops.get(0)); + if(tRecipe!=null){ + this.mOutputItems=new ItemStack[tRecipe.mOutputs.length]; + for(int g=0;g 0) { + this.mEUt = (-this.mEUt); + } + this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); + return true; + } + + private boolean moveOneDown() { + if ((this.mInventory[1] == null) || (this.mInventory[1].stackSize < 1) + || (!GT_Utility.areStacksEqual(this.mInventory[1], GT_ModHandler.getIC2Item("miningPipe", 1L)))) { + return false; + } + int xDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX;int zDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ; + int yHead = getYOfPumpHead(); + if (yHead <= 0) { + return false; + } + if(getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord()+xDir, yHead-1, getBaseMetaTileEntity().getZCoord()+zDir) == Blocks.bedrock){ + return false; + } + if (!(getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord()+xDir, yHead - 1, getBaseMetaTileEntity().getZCoord()+zDir,GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))))) { + return false; + } + if (yHead != getBaseMetaTileEntity().getYCoord()) { + getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord()+xDir, yHead, getBaseMetaTileEntity().getZCoord()+zDir,GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipe", 1L))); + } + getBaseMetaTileEntity().decrStackSize(1, 1); + return true; + } + + private int getYOfPumpHead() { + int xDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetX;int zDir = ForgeDirection.getOrientation(getBaseMetaTileEntity().getBackFacing()).offsetZ; + int y = getBaseMetaTileEntity().getYCoord() - 1; + while (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord()+xDir, y, getBaseMetaTileEntity().getZCoord()+zDir) == GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipe", 1L))) { + y--; + } + if (y == getBaseMetaTileEntity().getYCoord() - 1) { + if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord()+xDir, y, getBaseMetaTileEntity().getZCoord()+zDir) != GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))) { + return y + 1; + } + } else if (getBaseMetaTileEntity().getBlock(getBaseMetaTileEntity().getXCoord()+xDir, y, getBaseMetaTileEntity().getZCoord()+zDir) != GT_Utility + .getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))&&this.mInventory[1] != null&&this.mInventory[1].stackSize>0&>_Utility.areStacksEqual(this.mInventory[1], GT_ModHandler.getIC2Item("miningPipe", 1L))) { + getBaseMetaTileEntity().getWorld().setBlock(getBaseMetaTileEntity().getXCoord()+xDir, y, getBaseMetaTileEntity().getZCoord()+zDir, + GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("miningPipeTip", 1L))); + getBaseMetaTileEntity().decrStackSize(0, 1); + } + return y; + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX;int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ; + for (int i = -1; i < 2; i++) { + for (int j = -1; j < 2; j++) { + if ((xDir + i != 0) || (zDir + j != 0)) + { + IGregTechTileEntity tTileEntity = aBaseMetaTileEntity.getIGregTechTileEntityOffset(xDir + i, 0, zDir + j); + if ((!addMaintenanceToMachineList(tTileEntity, 16)) && (!addInputToMachineList(tTileEntity, 16)) && (!addOutputToMachineList(tTileEntity, 16)) && (!addEnergyInputToMachineList(tTileEntity, 16))) + { + if (aBaseMetaTileEntity.getBlockOffset(xDir + i, 0, zDir + j) != GregTech_API.sBlockCasings2) { + return false; + } + if (aBaseMetaTileEntity.getMetaIDOffset(xDir + i, 0, zDir + j) != 0) { + return false; + } + } + } + } + } + for(int y=1;y<4;y++){ + if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir) != GregTech_API.sBlockCasings2) { + return false; + } + if (aBaseMetaTileEntity.getBlockOffset(xDir+1, y, zDir) != GregTech_API.sBlockMachines) { + return false; + } + if (aBaseMetaTileEntity.getBlockOffset(xDir-1, y, zDir) != GregTech_API.sBlockMachines) { + return false; + } + if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir+1) != GregTech_API.sBlockMachines) { + return false; + } + if (aBaseMetaTileEntity.getBlockOffset(xDir, y, zDir-1) != GregTech_API.sBlockMachines) { + return false; + } + if (aBaseMetaTileEntity.getBlockOffset(xDir, y+3, zDir) != GregTech_API.sBlockMachines) { + return false; + } + } + return true; + } + + @Override public boolean isCorrectMachinePart(ItemStack aStack) {return true; } + @Override public int getMaxEfficiency(ItemStack aStack) {return 10000;} + @Override public int getPollutionPerTick(ItemStack aStack) {return 0; } + @Override public int getDamageToComponent(ItemStack aStack) {return 0;} + @Override public int getAmountOfOutputs() {return 0;} + @Override public boolean explodesOnComponentBreak(ItemStack aStack) {return false;} + + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_AdvMiner2(this.mName); + } + +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_Charcoal_Pit.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_Charcoal_Pit.java new file mode 100644 index 0000000000..fcfdbfc104 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_Charcoal_Pit.java @@ -0,0 +1,214 @@ +package gregtech.common.tileentities.machines.multi; + +import java.util.ArrayList; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.ChunkPosition; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +import gregtech.api.gui.GT_GUIContainer_MultiMachine; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.blocks.GT_Block_Reinforced; + +public class GT_MetaTileEntity_Charcoal_Pit extends GT_MetaTileEntity_MultiBlockBase{ + + private boolean running = false; + public GT_MetaTileEntity_Charcoal_Pit(int aID, String aName, String aNameRegional) + { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_Charcoal_Pit(String aName) + { + super(aName); + } + + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_Charcoal_Pit(this.mName); + } + + public String[] getDescription() + { + return new String[] { "Charcoal pit controller", + "Place on top of a pile of wood logs", + "Maximum size of logs below 11x5x11", + "Each log only can have other logs,", + "dirt or grass on its sides or above", + "or only logs or bricks below", + "Turns logs into Brittle Charcoal blocks"}; + } + + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) + { + if (aSide == 1) { + return new ITexture[] { Textures.BlockIcons.CASING_BLOCKS[10], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ROCK_BREAKER) }; + } + return new ITexture[] { Textures.BlockIcons.CASING_BLOCKS[10] }; + } + + public GT_Recipe.GT_Recipe_Map getRecipeMap() + { + return null; + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + + return true; + } + + public boolean isCorrectMachinePart(ItemStack aStack) + { + return true; + } + + public boolean isFacingValid(byte aFacing) + { + return aFacing > 1; + } + + public boolean checkRecipe(ItemStack aStack) + { + if(!checkRecursiveBlocks()){ + return false; + } + + if(mEfficiency==0){ + this.mEfficiency = 10000; + this.mEfficiencyIncrease = 10000; + this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); + return true; + }else{ + this.mEfficiency=0; + this.mEfficiencyIncrease = 0; + this.mMaxProgresstime = 0; + } + return false; + } + + private boolean checkRecursiveBlocks(){ + ArrayList tList1 = new ArrayList(); + ArrayList tList2 = new ArrayList(); + + Block tBlock = this.getBaseMetaTileEntity().getBlockOffset(0, -1, 0); + if(tBlock!=Blocks.log&&tBlock!=Blocks.log2){ + return false; + }else{ + tList2.add(new ChunkPosition(0,-1,0));//this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord()-1, this.getBaseMetaTileEntity().getZCoord())); + } + while(!tList2.isEmpty()){ + ChunkPosition tPos= (ChunkPosition) tList2.get(0); + tList2.remove(0); + if(!checkAllBlockSides(tPos.chunkPosX, tPos.chunkPosY, tPos.chunkPosZ, tList1, tList2)){ + return false; + } + } + if(running){ + for(ChunkPosition tPos : tList1){ + if(this.getBaseMetaTileEntity().getBlockOffset(tPos.chunkPosX, tPos.chunkPosY, tPos.chunkPosZ)==Blocks.log) + this.getBaseMetaTileEntity().getWorld().setBlock(this.getBaseMetaTileEntity().getXCoord()+tPos.chunkPosX, this.getBaseMetaTileEntity().getYCoord()+tPos.chunkPosY, this.getBaseMetaTileEntity().getZCoord()+tPos.chunkPosZ, GregTech_API.sBlockReinforced, 4, 3); + } + running = false; + return false; + }else{ + this.mMaxProgresstime = (int) Math.sqrt(tList1.size()* 240000); + } + running = true; + return true; + } + private boolean p1,p2,p3,p4,p5,p6; + private boolean checkAllBlockSides(int aX, int aY, int aZ, ArrayList aList1, ArrayList aList2){ + p1=false;p2=false;p3=false;p4=false;p5=false;p6=false; + Block tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX +1, aY, aZ); + if(aX+1<6&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX +1, aY, aZ))&&(!aList2.contains(new ChunkPosition(aX +1, aY, aZ))))p1=true; + }else if(!(tBlock==Blocks.dirt||tBlock==Blocks.grass)){return false;} + + tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX -1, aY, aZ); + if(aX-1>-6&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX -1, aY, aZ))&&(!aList2.contains(new ChunkPosition(aX -1, aY, aZ))))p2=true; + }else if(!(tBlock==Blocks.dirt||tBlock==Blocks.grass)){return false;} + + tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX , aY+1, aZ); + if(aY+1<1&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX, aY+1, aZ))&&(!aList2.contains(new ChunkPosition(aX, aY+1, aZ))))p3=true; + }else if(!(tBlock==Blocks.dirt||tBlock==Blocks.grass||(aX==0&&aY==-1&&aZ==0&&tBlock==GregTech_API.sBlockMachines))){return false;} + + tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX, aY-1, aZ); + if(aY-1>-6&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX, aY-1, aZ))&&(!aList2.contains(new ChunkPosition(aX, aY-1, aZ))))p4=true; + }else if(tBlock!=Blocks.brick_block){return false;} + + tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX, aY, aZ+1); + if(aZ+1<6&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX, aY, aZ+1))&&(!aList2.contains(new ChunkPosition(aX, aY, aZ+1))))p5=true; + }else if(!(tBlock==Blocks.dirt||tBlock==Blocks.grass)){return false;} + + tBlock = this.getBaseMetaTileEntity().getBlockOffset(aX, aY, aZ-1); + if(aZ-1>-6&&(tBlock==Blocks.log||tBlock==Blocks.log2)){ + if(!aList1.contains(new ChunkPosition(aX, aY, aZ-1))&&(!aList2.contains(new ChunkPosition(aX, aY, aZ-1))))p6=true; + }else if(!(tBlock==Blocks.dirt||tBlock==Blocks.grass)){return false;} + aList1.add(new ChunkPosition(aX,aY,aZ)); + if(p1)aList2.add(new ChunkPosition(aX+1,aY,aZ)); + if(p2)aList2.add(new ChunkPosition(aX-1,aY,aZ)); + if(p3)aList2.add(new ChunkPosition(aX,aY+1,aZ)); + if(p4)aList2.add(new ChunkPosition(aX,aY-1,aZ)); + if(p5)aList2.add(new ChunkPosition(aX,aY,aZ+1)); + if(p6)aList2.add(new ChunkPosition(aX,aY,aZ-1)); + return true; + } + + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) + { + mWrench = true; + mScrewdriver = true; + mSoftHammer = true; + mHardHammer = true; + mSolderingTool = true; + mCrowbar = true; + return true; + } + + public int getMaxEfficiency(ItemStack aStack) + { + return 10000; + } + + public int getPollutionPerTick(ItemStack aStack) + { + return 0; + } + + public int getDamageToComponent(ItemStack aStack) + { + return 0; + } + + public int getAmountOfOutputs() + { + return 1; + } + + public boolean explodesOnComponentBreak(ItemStack aStack) + { + return false; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java index 632cdcbd6f..7386e74ed8 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java @@ -16,7 +16,6 @@ import gregtech.api.util.GT_Utility; import java.util.ArrayList; -import scala.actors.threadpool.Arrays; import net.minecraft.block.Block; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.item.ItemStack; @@ -43,7 +42,14 @@ public class GT_MetaTileEntity_DistillationTower public String[] getDescription() { - return new String[] { "Controller Block for the Distillation Tower", "Size: 3x6x3 (Hollow)", "Controller (front bottom)", "1x Input Hatch (bottom)", "5x Output Hatch (one each height level besides botton)","1x Output Bus (Botton)", "1x Energy Hatch (anywhere)", "1x Maintenance Hatch (anywhere)", "Clean Stainless Steel Casings for the rest (26 at least!)" }; + return new String[] { + "Controller Block for the Distillation Tower", + "Size: 3x6x3 (Hollow)", "Controller (front bottom)", + "1x Input Hatch (bottom)", + "5x Output Hatch (one each height level besides botton)", + "1x Output Bus (Botton)", "1x Energy Hatch (anywhere)", + "1x Maintenance Hatch (anywhere)", + "Clean Stainless Steel Casings for the rest (26 at least!)" }; } public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java index 9a835e625f..e25cfc08f2 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java @@ -60,11 +60,11 @@ public abstract class GT_MetaTileEntity_FusionComputer extends GT_MetaTileEntity @Override public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { - return new GT_GUIContainer_FusionReactor(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "FusionComputer.png"); + return new GT_GUIContainer_FusionReactor(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "FusionComputer.png", GT_Recipe.GT_Recipe_Map.sFusionRecipes.mNEIName); } public abstract MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity); - + public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) { return aSide != getBaseMetaTileEntity().getFrontFacing(); @@ -283,7 +283,6 @@ public abstr