diff options
| author | Foghrye4 <foghrye4@gmail.com> | 2016-04-11 19:44:54 +0300 |
|---|---|---|
| committer | Foghrye4 <foghrye4@gmail.com> | 2016-04-11 19:44:54 +0300 |
| commit | 05c78126859231a68e199dc34613689bd0978e2f (patch) | |
| tree | 050bea104a18c72905095d29f31bec2935a27a24 /ihl/tunneling_shield/DriverTileEntity.java | |
Initial commit
Diffstat (limited to 'ihl/tunneling_shield/DriverTileEntity.java')
| -rw-r--r-- | ihl/tunneling_shield/DriverTileEntity.java | 1138 |
1 files changed, 1138 insertions, 0 deletions
diff --git a/ihl/tunneling_shield/DriverTileEntity.java b/ihl/tunneling_shield/DriverTileEntity.java new file mode 100644 index 0000000..2c3f2d8 --- /dev/null +++ b/ihl/tunneling_shield/DriverTileEntity.java @@ -0,0 +1,1138 @@ +package ihl.tunneling_shield;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import ic2.api.energy.event.EnergyTileLoadEvent;
+import ic2.api.energy.event.EnergyTileUnloadEvent;
+import ic2.api.energy.tile.IEnergySink;
+import ic2.api.item.IC2Items;
+import ic2.api.network.INetworkClientTileEntityEventListener;
+import ic2.api.recipe.RecipeOutput;
+import ic2.api.recipe.Recipes;
+import ic2.core.ContainerBase;
+import ic2.core.IC2;
+import ic2.core.IHasGui;
+import ic2.core.Ic2Items;
+import ic2.core.audio.AudioSource;
+import ic2.core.audio.PositionSpec;
+import ic2.core.block.TileEntityInventory;
+import ic2.core.block.invslot.InvSlotConsumableId;
+import ic2.core.block.invslot.InvSlot;
+import ic2.core.block.invslot.InvSlotUpgrade;
+import ic2.core.block.invslot.InvSlot.Access;
+import ic2.core.network.NetworkManager;
+import ic2.core.upgrade.IUpgradableBlock;
+import ic2.core.upgrade.UpgradableProperty;
+import ic2.core.util.StackUtil;
+import ihl.IHLMod;
+import ihl.utils.IHLInvSlotDischarge;
+import ihl.utils.IHLUtils;
+import net.minecraft.block.Block;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.DamageSource;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class DriverTileEntity extends TileEntityInventory implements IEnergySink, IHasGui, INetworkClientTileEntityEventListener, IUpgradableBlock, IMultiBlock {
+
+ private AudioSource audioSource;
+ private AudioSource startAS;
+ private AudioSource loopAS;
+ private AudioSource stopAS;
+ private int startUpCounter=0;
+ public final InvSlotConsumableId miningPipesSlot;
+ public final InvSlotUpgrade upgradeSlot;
+ public final IHLInvSlotDischarge dischargeSlot;
+ public int tier;
+ private int defaultTier;
+ public int maxStorage;
+ private int defaultMaxStorage;
+ public boolean hasShield=false;
+ private boolean prevHasShield=false;
+ public int shaftDestroyedAtA=0;
+ private int prevShaftDestroyedAtA=0;
+ public int shaftDestroyedAtB=0;
+ private int prevShaftDestroyedAtB=0;
+ public int modelShift=0;
+ public int modelShiftSpeed;
+ private int defaultModelShiftSpeed;
+ public int blockShift=1;
+ private int lastBlockShift=1;
+ private double energy = 0;
+ private double energyConsume;
+ private double defaultEnergyConsume;
+ private boolean addedToEnergyNet=false;
+ public int xShaftMin, xShaftMax, yShaft, zShaftMin, zShaftMax, xShieldMin, xShieldMax, yShieldMin, yShieldMax, zShieldMin, zShieldMax;
+ private int updateChecksum=0;
+ private boolean renderHelperExist=false;
+ public DriverEntity renderHelper;
+ public boolean reverseModeOn=false;
+ public boolean autoReverseModeOn=true;
+ private float lastModelShiftAmount=1F;
+ private List<Block> blockBlackList = new ArrayList();
+ private List<Block> blockWhiteList = new ArrayList();
+ public boolean advancedShield=false;
+
+ public DriverTileEntity()
+ {
+ super();
+ this.miningPipesSlot = new InvSlotConsumableId(this, "miningPipesSlot", 1, 12, new Item[] {Ic2Items.miningPipe.getItem()});
+ this.upgradeSlot = new InvSlotUpgrade(this, "upgrade", 2, 4);
+ this.dischargeSlot = new IHLInvSlotDischarge(this, 1, Access.IO, this.tier, InvSlot.InvSide.BOTTOM);
+ this.defaultTier=IHLMod.config.ts02DefaultTier;
+ this.defaultMaxStorage=IHLMod.config.ts02DefaultMaxEnergyStorage;
+ this.defaultModelShiftSpeed=IHLMod.config.ts02DefaultSpeed;
+ this.defaultEnergyConsume=IHLMod.config.ts02DefaultOperationEUCost;
+ this.tier=this.defaultTier;
+ this.maxStorage=this.defaultMaxStorage;
+ this.modelShiftSpeed=this.defaultModelShiftSpeed;
+ this.energyConsume=this.defaultEnergyConsume;
+ for(int i6=0;i6<IHLMod.config.ts02BlockBlackListString.length;i6++)
+ {
+ String blockName = IHLMod.config.ts02BlockBlackListString[i6];
+ Block block = Block.getBlockFromName(blockName);
+ if(block==null)
+ {
+ ItemStack stack = IC2Items.getItem(blockName);
+ if(stack!=null)
+ {
+ block = StackUtil.getBlock(stack);
+ }
+ }
+ if(block!=null)
+ {
+ blockBlackList.add(block);
+ }
+ }
+ for(int i7=0;i7<IHLMod.config.ts02BlockWhiteListString.length;i7++)
+ {
+ String blockName = IHLMod.config.ts02BlockWhiteListString[i7];
+ Block block = Block.getBlockFromName(blockName);
+ if(block==null)
+ {
+ ItemStack stack = IC2Items.getItem(blockName);
+ if(stack!=null)
+ {
+ block = StackUtil.getBlock(stack);
+ }
+ }
+ if(block!=null)
+ {
+ blockWhiteList.add(block);
+ }
+
+ }
+ blockWhiteList.add(IHLMod.multiBlockSpacerBlock);
+ blockWhiteList.add(IHLMod.horizontalMiningPipeX);
+ blockWhiteList.add(IHLMod.horizontalMiningPipeZ);
+ blockWhiteList.add(Blocks.air);
+ }
+
+ @Override
+ public List<String> getNetworkedFields()
+ {
+ List<String> fields = super.getNetworkedFields();
+ fields.add("hasShield");
+ fields.add("modelShift");
+ fields.add("shaftDestroyedAtA");
+ fields.add("shaftDestroyedAtB");
+ fields.add("tier");
+ fields.add("modelShiftSpeed");
+ fields.add("maxStorage");
+ fields.add("reverseModeOn");
+ fields.add("autoReverseModeOn");
+ fields.add("advancedShield");
+ return fields;
+ }
+
+ public String getShieldSoundFile()
+ {
+ return "Machines/MinerOp.ogg";
+ }
+
+ public String getStartSoundFile()
+ {
+ return "Machines/IHL Tunneling Shield/TS02Start.ogg";
+ }
+
+ public String getLoopSoundFile()
+ {
+ return "Machines/IHL Tunneling Shield/TS02Loop.ogg";
+ }
+
+ public String getStopSoundFile()
+ {
+ return "Machines/IHL Tunneling Shield/TS02Stop.ogg";
+ }
+
+ @Override
+ public void onLoaded()
+ {
+ super.onLoaded();
+ if (IC2.platform.isSimulating()&&!this.addedToEnergyNet)
+ {
+ MinecraftForge.EVENT_BUS.post(new EnergyTileLoadEvent(this));
+ this.addedToEnergyNet = true;
+ }
+ if (IC2.platform.isRendering() && (this.startAS==null||this.loopAS==null||this.stopAS==null))
+ {
+ this.startAS = IC2.audioManager.createSource(this, PositionSpec.Center, this.getStartSoundFile(),false,false, 0.5F);
+ this.loopAS = IC2.audioManager.createSource(this, PositionSpec.Center, this.getLoopSoundFile(),true,false, 0.5F);
+ this.stopAS = IC2.audioManager.createSource(this, PositionSpec.Center, this.getStopSoundFile(),false,false, 0.5F);
+ }
+ }
+
+ @Override
+ public void onUnloaded()
+ {
+ super.onUnloaded();
+
+ if (IC2.platform.isRendering() && this.audioSource != null)
+ {
+ this.audioSource.stop();
+ this.audioSource = null;
+ this.startAS.stop();
+ this.loopAS.stop();
+ this.stopAS.stop();
+ this.startAS = null;
+ this.loopAS = null;
+ this.stopAS = null;
+ IC2.audioManager.removeSources(this);
+ }
+
+ if (IC2.platform.isSimulating()&&this.addedToEnergyNet)
+ {
+ MinecraftForge.EVENT_BUS.post(new EnergyTileUnloadEvent(this));
+ this.addedToEnergyNet = false;
+ }
+ }
+
+
+ @Override
+ public void updateEntityClient()
+ {
+ super.updateEntityClient();
+ updateEntityServer();
+ if(!this.renderHelperExist)
+ {
+ List<DriverEntity> deList = this.worldObj.getEntitiesWithinAABB(DriverEntity.class, this.getOperationZone());
+ if(deList.size()>0)
+ {
+ Iterator<DriverEntity> dei = deList.iterator();
+ while(dei.hasNext())
+ {
+ DriverEntity rh=dei.next();
+ if(!rh.isDead)
+ {
+ this.renderHelper=rh;
+ rh.parent=this;
+ this.renderHelperExist=true;
+ break;
+ }
+ }
+ if(!this.renderHelperExist)
+ {
+ this.renderHelper=new DriverEntity(this.worldObj, this, this.xCoord+this.blockShift*this.mX(), this.yCoord, this.zCoord+this.blockShift*this.mZ());
+ this.renderHelperExist=true;
+ }
+ }
+ else
+ {
+ this.renderHelper=new DriverEntity(this.worldObj, this, this.xCoord+this.blockShift*this.mX(), this.yCoord, this.zCoord+this.blockShift*this.mZ());
+ this.renderHelper.parent=this;
+ this.renderHelperExist=true;
+ }
+ }
+
+ if(this.renderHelper!=null && !this.renderHelper.isDead && !this.worldObj.loadedEntityList.contains(this.renderHelper))
+ {
+ this.worldObj.spawnEntityInWorld(this.renderHelper);
+ }
+ if(this.audioSource==null && this.renderHelper!=null)this.audioSource = IC2.audioManager.createSource(this.renderHelper, PositionSpec.Center, this.getShieldSoundFile(),true,false, 1.0F);
+ if(this.audioSource!=null)
+ {
+ this.audioSource.updatePosition();
+ }
+ if(this.audioSource!=null)
+ {
+ if(this.getActive())
+ {
+ if(this.startUpCounter>62)
+ {
+ this.startUpCounter=0;
+ }
+ if(this.startUpCounter==0)
+ {
+ this.stopAS.stop();
+ this.startAS.play();
+ }
+ if(this.startUpCounter<60)
+ {
+ this.startUpCounter++;
+ }
+ else if(this.startUpCounter==60)
+ {
+ this.startAS.stop();
+ this.loopAS.play();
+ this.audioSource.play();
+ this.startUpCounter++;
+ }
+ }
+ else if(this.startUpCounter>0)
+ {
+ this.startAS.stop();
+ this.loopAS.stop();
+ this.audioSource.stop();
+ this.stopAS.play();
+ if(this.startUpCounter<100)
+ {
+ this.startUpCounter++;
+ }
+ else
+ {
+ this.startUpCounter=0;
+ this.stopAS.stop();
+ }
+ }
+ }
+ else if(!this.getActive() && this.audioSource!=null)
+ {
+ this.audioSource.stop();
+ }
+ }
+
+ @Override
+ public void updateEntityServer()
+ {
+ if (IC2.platform.isSimulating())
+ {
+ this.setOverclockRates();
+ }
+ if(this.dischargeSlot.tier!=this.tier)
+ {
+ this.dischargeSlot.tier=this.tier;
+ }
+ int xyz[]={0,0,1,0,-1,-1,1,1,-1,2,0,2,1,2,-1,-2,0,-2,1,-2,-1,0};
+ boolean freeToDigForward = true;
+ boolean freeToMoveBack = true;
+ if(this.blockShift>=127)
+ {
+ freeToDigForward = false;
+ if(this.autoReverseModeOn && !this.reverseModeOn && this.worldObj.isRemote)
+ {
+ this.reverseModeOn=true;
+ IC2.network.get().initiateClientTileEntityEvent(this, 0);
+ }
+ }
+ else
+ {
+ for(int i = 0;i<21;i++)
+ {
+ Block block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift+1)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift+1)*this.mZ());
+ if(this.blockBlackList.contains(block))
+ {
+ freeToDigForward = false;
+ }
+ }
+ }
+
+ if(this.blockShift<=3)
+ {
+ freeToMoveBack = false;
+ }
+ else
+ {
+ for(int i = 0;i<21;i++)
+ {
+ Block block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-3)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-3)*this.mZ());
+ if(block.getCollisionBoundingBoxFromPool(worldObj, this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-3)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-3)*this.mZ())!=null && !block.getMaterial().isLiquid() && !this.blockWhiteList.contains(block))
+ {
+ freeToMoveBack = false;
+ }
+ block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ());
+ if(block.getCollisionBoundingBoxFromPool(worldObj, this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ())!=null && !block.getMaterial().isLiquid() && !this.blockWhiteList.contains(block))
+ {
+ freeToMoveBack = false;
+ }
+ }
+ }
+
+ if(IC2.platform.isSimulating())
+ {
+ if(this.hasShield && this.shaftDestroyedAtA==0 && this.energy>=this.energyConsume)
+ {
+ if(this.reverseModeOn && freeToMoveBack)
+ {
+ this.energy-=this.energyConsume;
+ this.setActive(true);
+ }
+ else if((!this.reverseModeOn) && freeToDigForward && this.miningPipesSlot.get()!=null && this.miningPipesSlot.get().stackSize>=1)
+ {
+ this.energy-=this.energyConsume;
+ this.setActive(true);
+ }
+ else
+ {
+ this.setActive(false);
+ }
+ }
+ else
+ {
+ this.setActive(false);
+ }
+ }
+ if(this.getActive())
+ {
+ double velocity;
+ if(this.reverseModeOn && this.modelShift>0)
+ {
+ this.modelShift--;
+ List<Entity> entityList = this.worldObj.getEntitiesWithinAABB(Entity.class, this.getShieldBladesZone(0D));
+ velocity = -0.5D;
+ if(entityList.size()>0)
+ {
+ for(int i0=0;i0<entityList.size();i0++)
+ {
+ entityList.get(i0).addVelocity(velocity*mX(), 0.25D, velocity*mZ());
+ }
+ }
+ }
+ else
+ {
+ this.modelShift++;
+ List<EntityLivingBase> entityLivingList = this.worldObj.getEntitiesWithinAABB(EntityLivingBase.class, this.getShieldBladesZone(2.5D));
+ float damage = 800F/(this.modelShiftSpeed);
+ velocity = 0.1D*damage;
+ if(entityLivingList.size()>0)
+ {
+ for(int i1=0;i1<entityLivingList.size();i1++)
+ {
+ entityLivingList.get(i1).attackEntityFrom(DamageSource.fallingBlock, damage);
+ entityLivingList.get(i1).addVelocity(velocity*mX(), 0.25D*velocity, velocity*mZ());
+ }
+ }
+ List<EntityLiving> entityLivingList2 = this.worldObj.getEntitiesWithinAABB(EntityLiving.class, this.getShieldBladesZone(2.5D));
+ velocity*=0.1D;
+ if(entityLivingList2.size()>0)
+ {
+ for(int i2=0;i2<entityLivingList2.size();i2++)
+ {
+ entityLivingList2.get(i2).attackEntityFrom(DamageSource.fallingBlock, damage);
+ entityLivingList2.get(i2).addVelocity(velocity*mX(), 0.25D*velocity, velocity*mZ());
+ }
+ }
+ }
+ }
+ this.blockShift=Math.round(this.getModelShiftAmount()+1.0F+(this.reverseModeOn?2.0F:0));
+ if (IC2.platform.isSimulating())
+ {
+ if (this.prevHasShield!= this.hasShield)
+ {
+ IC2.network.get().updateTileEntityField(this, "hasShield");
+ this.prevHasShield = this.hasShield;
+ }
+ if (this.prevShaftDestroyedAtA!= this.shaftDestroyedAtA)
+ {
+ IC2.network.get().updateTileEntityField(this, "shaftDestroyedAtA");
+ this.prevShaftDestroyedAtA=this.shaftDestroyedAtA;
+ }
+ if (this.prevShaftDestroyedAtB!= this.shaftDestroyedAtB)
+ {
+ IC2.network.get().updateTileEntityField(this, "shaftDestroyedAtB");
+ this.prevShaftDestroyedAtB=this.shaftDestroyedAtB;
+ }
+ if(this.getDemandedEnergy() > 1.0D)
+ {
+ double amount = this.dischargeSlot.discharge(this.getDemandedEnergy(), false);
+ this.energy += amount;
+ }
+ if(this.energy>this.maxStorage)
+ {
+ this.energy=this.maxStorage;
+ }
+ }
+
+ if(this.blockShift!=this.lastBlockShift)
+ {
+ if(this.getActive() && this.reverseModeOn && IC2.platform.isSimulating() && this.lastModelShiftAmount-this.getModelShiftAmount()<1F)
+ {
+ if(this.miningPipesSlot.get()==null)
+ {
+ this.miningPipesSlot.put(Ic2Items.miningPipe.copy());
+ }
+ else if(this.miningPipesSlot.get().stackSize<64)
+ {
+ this.miningPipesSlot.get().stackSize++;
+ }
+ else
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj,this.xCoord,this.yCoord+1,this.zCoord,this.miningPipesSlot.get()));
+ this.miningPipesSlot.put(Ic2Items.miningPipe.copy());
+ }
+ this.lastModelShiftAmount-=1F;
+ }
+ else if(this.getActive() && IC2.platform.isSimulating() && this.getModelShiftAmount()-this.lastModelShiftAmount>1F)
+ {
+ this.miningPipesSlot.consume(1);
+ this.lastModelShiftAmount+=1F;
+ IC2.network.get().updateTileEntityField(this, "modelShift");
+ }
+ this.defineTechBlockVariables();
+ if(this.getActive() && IC2.platform.isSimulating())
+ {
+ if(this.reverseModeOn)
+ {
+ for(int i = 0;i<21;i++)
+ {
+ if(this.blockShift>=2)
+ {
+ this.worldObj.setBlockToAir(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift)*this.mZ());
+ }
+ if(this.blockShift>=3)
+ {
+ Block block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ());
+ if(block!=IHLMod.multiBlockSpacerBlock && block!=IHLMod.horizontalMiningPipeX && block!=IHLMod.horizontalMiningPipeZ)
+ {
+ this.harvestDrops(block, this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ(), this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-3)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-3)*this.mZ(), IHLMod.multiBlockSpacerBlock);
+ }
+ else
+ {
+ this.worldObj.setBlock(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ(), IHLMod.multiBlockSpacerBlock);
+ }
+ }
+ }
+ }
+ else
+ {
+ for(int i = 0;i<21;i++)
+ {
+ Block block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+this.blockShift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+this.blockShift*this.mZ());
+ this.harvestMiningDrops(block, this.xCoord+xyz[i+1]*this.mZ()+this.blockShift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+this.blockShift*this.mZ(), this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ(), IHLMod.multiBlockSpacerBlock);
+ if(this.blockShift>=3)
+ {
+ if(i!=0)
+ {
+ this.worldObj.setBlockToAir(this.xCoord+xyz[i+1]*this.mZ()+(this.blockShift-2)*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+(this.blockShift-2)*this.mZ());
+ }
+ else
+ {
+ this.worldObj.setBlock(this.xCoord+(this.blockShift-2)*this.mX(), this.yCoord, this.zCoord+(this.blockShift-2)*this.mZ(), this.mX()!=0?IHLMod.horizontalMiningPipeZ:IHLMod.horizontalMiningPipeX);
+ }
+ }
+
+ }
+ }
+ }
+ this.lastBlockShift=this.blockShift;
+ }
+ }
+
+ private void harvestMiningDrops(Block block, int x, int y, int z, int x1, int y1, int z1, Block setToBlock)
+ {
+ if(block!=null && block!=Blocks.air && block!=Blocks.bedrock)
+ {
+ int meta = worldObj.getBlockMetadata(x, y, z);
+ ArrayList<ItemStack> drops = block.getDrops(this.worldObj, x, y, z, meta, 0);
+ if(drops.size()>0)
+ {
+ if(!this.advancedShield || !this.handleDropsByHydrotransport(drops))
+ {
+ for(int i1=0;i1<drops.size();i1++)
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, x1, y1, z1, drops.get(i1)));
+ }
+ }
+ }
+ }
+ this.worldObj.setBlock(x, y, z, setToBlock);
+ }
+
+ public void setOverclockRates()
+ {
+ int speedUp=0;
+ int tierUp=0;
+ int capacityUp=0;
+ int checksum=0;
+ for(int i=0;i<this.upgradeSlot.size();i++)
+ {
+ if(this.upgradeSlot.get(i)!=null)
+ {
+ if(this.upgradeSlot.get(i).getItemDamage()==IC2Items.getItem("overclockerUpgrade").getItemDamage())
+ {
+ speedUp+=this.upgradeSlot.get(i).stackSize;
+ }
+ if(this.upgradeSlot.get(i).getItemDamage()==IC2Items.getItem("transformerUpgrade").getItemDamage())
+ {
+ tierUp+=this.upgradeSlot.get(i).stackSize;
+ }
+ if(this.upgradeSlot.get(i).getItemDamage()==IC2Items.getItem("energyStorageUpgrade").getItemDamage())
+ {
+ capacityUp+=this.upgradeSlot.get(i).stackSize;
+ }
+ }
+ }
+ checksum=speedUp*4096+tierUp*64+capacityUp;
+ if(this.updateChecksum!=checksum)
+ {
+ double correction = this.reverseModeOn?0.1D:1D;
+ float newModelShiftSpeed=(float)Math.max(correction*this.defaultModelShiftSpeed*Math.pow(0.7D, speedUp),10D);
+ this.modelShift=Math.round(this.modelShift*newModelShiftSpeed/this.modelShiftSpeed);
+ this.modelShiftSpeed=Math.round(newModelShiftSpeed);
+ this.tier=this.defaultTier+tierUp;
+ IC2.network.get().updateTileEntityField(this, "tier");
+ this.maxStorage=this.defaultMaxStorage + capacityUp*10000;
+ IC2.network.get().updateTileEntityField(this, "maxStorage");
+ this.energyConsume=Math.min(correction*this.defaultEnergyConsume*Math.pow(1.6D, speedUp),this.maxStorage);
+ IC2.network.get().updateTileEntityField(this, "modelShift");
+ IC2.network.get().updateTileEntityField(this, "modelShiftSpeed");
+ this.updateChecksum=checksum;
+ };
+ }
+
+ @Override
+ public void writeToNBT(NBTTagCompound var1) {
+ super.writeToNBT(var1);
+ var1.setDouble("energy", this.energy);
+ var1.setBoolean("hasShield", this.hasShield);
+ var1.setBoolean("autoReverseModeOn", this.autoReverseModeOn);
+ var1.setBoolean("reverseModeOn", this.reverseModeOn);
+ var1.setBoolean("advancedShield", this.advancedShield);
+ var1.setInteger("modelShift", this.modelShift);
+ var1.setInteger("shaftDestroyedAtA", this.shaftDestroyedAtA);
+ var1.setInteger("shaftDestroyedAtB", this.shaftDestroyedAtB);
+ var1.setInteger("modelShiftSpeed", this.modelShiftSpeed);
+ }
+
+ @Override
+ public void readFromNBT(NBTTagCompound var1) {
+ super.readFromNBT(var1);
+ this.hasShield=var1.getBoolean("hasShield");
+ this.autoReverseModeOn=var1.getBoolean("autoReverseModeOn");
+ this.reverseModeOn=var1.getBoolean("reverseModeOn");
+ this.advancedShield=var1.getBoolean("advancedShield");
+ this.modelShift=var1.getInteger("modelShift");
+ this.modelShiftSpeed=var1.getInteger("modelShiftSpeed");
+ this.energy=var1.getDouble("energy");
+ this.shaftDestroyedAtA=var1.getInteger("shaftDestroyedAtA");
+ this.shaftDestroyedAtB=var1.getInteger("shaftDestroyedAtB");
+ if(this.hasShield)
+ {
+ if(!MultiBlockSpacerBlock.teList.contains(this))
+ {
+ MultiBlockSpacerBlock.teList.add(this);
+ }
+ if(this.mX()==0)
+ {
+ if(!HorizontalMiningPipe.teList.contains(this))
+ {
+ HorizontalMiningPipe.teList.add(this);
+ }
+ }
+ else
+ {
+ if(!HorizontalMiningPipe.teList.contains(this))
+ {
+ HorizontalMiningPipe.teList.add(this);
+ }
+ }
+ }
+ float shift=(float)this.modelShift/(float)this.modelShiftSpeed+1.0F;
+ this.lastBlockShift=this.blockShift=Math.round(shift);
+ this.defineTechBlockVariables();
+ this.lastModelShiftAmount=this.getModelShiftAmount();
+ }
+
+ @Override
+ public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) {
+ return !this.hasShield && this.getFacing()!=(short)side;
+ }
+
+ @Override
+ public short getFacing() {
+ return super.getFacing();
+ }
+
+ @Override
+ public void setFacing(short facing) {
+ short newFacing = (short) Math.max(2, facing);
+ super.setFacing(newFacing);
+ }
+
+ @Override
+ public boolean wrenchCanRemove(EntityPlayer entityPlayer) {
+ return true;
+ }
+
+ @Override
+ public float getWrenchDropRate() {
+ return 1.0F;
+ }
+
+ @Override
+ public ItemStack getWrenchDrop(EntityPlayer entityPlayer) {
+ this.cleanUp();
+ if(this.hasShield)
+ {
+ if(this.advancedShield)
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord+(this.blockShift-2)*this.mX(), this.yCoord, this.zCoord+(this.blockShift-2)*this.mZ(), IHLUtils.getThisModItemStack("advancedShieldAssemblyUnitBlock")));
+ }
+ else
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord+(this.blockShift-2)*this.mX(), this.yCoord, this.zCoord+(this.blockShift-2)*this.mZ(), IHLUtils.getThisModItemStack("IHLShieldAssemblyUnitBlock")));
+ }
+ }
+ if(this.miningPipesSlot.get()!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.miningPipesSlot.get()));
+ if(this.dischargeSlot.get()!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.dischargeSlot.get()));
+ if(this.upgradeSlot.get(0)!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.upgradeSlot.get(0)));
+ if(this.upgradeSlot.get(1)!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.upgradeSlot.get(1)));
+ if(this.upgradeSlot.get(2)!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.upgradeSlot.get(2)));
+ if(this.upgradeSlot.get(3)!=null)this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord+1, this.zCoord, this.upgradeSlot.get(3)));
+ return new ItemStack(IHLMod.driverBlock,1);
+ }
+
+ @Override
+ public String getInventoryName() {
+ return "IHL TS-002";
+ }
+
+ @Override
+ @SideOnly(Side.CLIENT)
+ public GuiScreen getGui(EntityPlayer arg0, boolean arg1) {
+ return new DriverGui(new DriverContainer(arg0, this));
+ }
+
+ @Override
+ public ContainerBase getGuiContainer(EntityPlayer arg0) {
+ return new DriverContainer(arg0, this);
+ }
+
+ @Override
+ public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction)
+ {
+ return true;
+ }
+
+ public boolean getGui(EntityPlayer player)
+ {
+ return this instanceof IHasGui ? (IC2.platform.isSimulating() ? IC2.platform.launchGui(player, this) : true) : false;
+ }
+
+ public boolean canPlaceShield()
+ {
+ if(this.hasShield)
+ {
+ return false;
+ }
+ Block block;
+ int xyz[]={0,0,1,0,-1,-1,1,1,-1,2,0,2,1,2,-1,-2,0,-2,1,-2,-1,0};
+ for(int i = 0;i<21;i++)
+ {
+ block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+this.mZ());
+ if(!block.isAir(this.worldObj, this.xCoord+xyz[i+1]*this.mZ()+this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+this.mZ()))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public int mX()
+ {
+ switch(this.getFacing())
+ {
+ case 4:
+ return -1;
+ case 5:
+ return 1;
+ default:
+ return 0;
+ }
+ }
+
+ public int mZ()
+ {
+ switch(this.getFacing())
+ {
+ case 3:
+ return 1;
+ case 2:
+ return -1;
+ case 4:
+ return 0;
+ case 5:
+ return 0;
+ default:
+ return -1;
+ }
+ }
+
+ public float getModelShiftAmount() {
+ return (float)this.modelShift/(float)this.modelShiftSpeed;
+ }
+
+ private AxisAlignedBB getOperationZone()
+ {
+ int x=this.xCoord;
+ int y=this.yCoord;
+ int z=this.zCoord;
+ double extension=this.getModelShiftAmount()+1.0D;
+ return AxisAlignedBB.getBoundingBox(x + extension*Math.min(this.mX(),0)-2.0D, y-2.0D, z + extension*Math.min(this.mZ(),0)-2.0D, x + 3.0D + extension*Math.max(this.mX(),0), y + 3.0D, z + 3.0D + extension*Math.max(this.mZ(),0));
+ }
+
+ private AxisAlignedBB getShieldBladesZone(double offset)
+ {
+ int x=this.xCoord;
+ int y=this.yCoord;
+ int z=this.zCoord;
+ double extension=this.getModelShiftAmount()+offset;
+ double xShieldMinD=this.xCoord+extension*this.mX()-1D*Math.max(this.mX(), 0)-2D*Math.abs(this.mZ());
+ double xShieldMaxD=this.xCoord+extension*this.mX()-1D*Math.min(this.mX(), 0)+3D*Math.abs(this.mZ());
+ double yShieldMinD=this.yCoord-2D;
+ double yShieldMaxD=this.yCoord+3D;
+ double zShieldMinD=this.zCoord+extension*this.mZ()-1D*Math.max(this.mZ(), 0)-2D*Math.abs(this.mX());
+ double zShieldMaxD=this.zCoord+extension*this.mZ()-1D*Math.min(this.mZ(), 0)+3D*Math.abs(this.mX());
+ return AxisAlignedBB.getBoundingBox(xShieldMinD, yShieldMinD, zShieldMinD, xShieldMaxD, yShieldMaxD, zShieldMaxD);
+ }
+
+ public int getStored() {
+ return Math.round((float)this.energy);
+ }
+
+ public void setStored(int value) {
+ this.energy=value;
+ }
+
+ @Override
+ public void onGuiClosed(EntityPlayer arg0) {}
+
+ public void installShield() {
+ if(IC2.platform.isSimulating())
+ {
+ this.hasShield=true;
+ int x=this.xCoord;
+ int y=this.yCoord;
+ int z=this.zCoord;
+ MultiBlockSpacerBlock.teList.add(this);
+ this.defineTechBlockVariables();
+ if(this.mX()==0)
+ {
+ HorizontalMiningPipe.teList.add(this);
+ }
+ else
+ {
+ HorizontalMiningPipe.teList.add(this);
+ }
+
+ int xyz[]={0,0,1,0,-1,-1,1,1,-1,2,0,2,1,2,-1,-2,0,-2,1,-2,-1,0};
+ for(int i1 = 0;i1<21;i1++)
+ {
+ this.worldObj.setBlock(x+xyz[i1+1]*this.mZ()+this.mX(), y+xyz[i1], z+xyz[i1+1]*this.mX()+this.mZ(), IHLMod.multiBlockSpacerBlock, 0, 3);
+ }
+ }
+ }
+
+ public boolean isShaftCoord(int x, int y, int z)
+ {
+ if(IC2.platform.isSimulating() && y==this.yShaft && x>=this.xShaftMin && x<=this.xShaftMax && z>=this.zShaftMin && z<=this.zShaftMax)
+ {
+ int sda = (x-this.xCoord)*this.mX()+(z-this.zCoord)*this.mZ();
+ if(this.shaftDestroyedAtA==0 && this.shaftDestroyedAtB==0)
+ {
+ this.shaftDestroyedAtA=this.shaftDestroyedAtB=sda;
+ }
+ else if(sda>this.shaftDestroyedAtB)
+ {
+ for(int i4=this.shaftDestroyedAtB;i4<sda;i4++)
+ {
+ int x1=this.xCoord+i4*mX();
+ int y1=this.yCoord;
+ int z1=this.zCoord+i4*mZ();
+ Block block=this.worldObj.getBlock(x1, y1, z1);
+ if(block instanceof HorizontalMiningPipe)
+ {
+ this.harvestDrops(block, x1, y1, z1, x1, y1, z1, Blocks.air);
+ }
+ }
+ this.shaftDestroyedAtB=sda;
+ }
+ else if(sda<this.shaftDestroyedAtA)
+ {
+ for(int i4=sda;i4<this.shaftDestroyedAtA;i4++)
+ {
+ int x1=this.xCoord+i4*mX();
+ int y1=this.yCoord;
+ int z1=this.zCoord+i4*mZ();
+ Block block=this.worldObj.getBlock(x1, y1, z1);
+ if(block instanceof HorizontalMiningPipe)
+ {
+ this.harvestDrops(block, x1, y1, z1, x1, y1, z1, Blocks.air);
+ }
+ }
+ this.shaftDestroyedAtA=sda;
+ }
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean isAPartOfStructure(int x, int y, int z, boolean onBlockBeak)
+ {
+ if(IC2.platform.isSimulating() && y>=this.yShieldMin && y<=this.yShieldMax && x>=this.xShieldMin && x<=this.xShieldMax && z>=this.zShieldMin && z<=this.zShieldMax)
+ {
+ if(onBlockBeak)
+ {
+ this.hasShield=false;
+ this.advancedShield=false;
+ this.modelShift=0;
+ this.lastBlockShift=this.blockShift=1;
+ this.shaftDestroyedAtA=0;
+ IC2.network.get().updateTileEntityField(this, "modelShift");
+ IC2.network.get().updateTileEntityField(this, "advancedShield");
+ this.cleanUp();
+ }
+ return true;
+ }
+ return false;
+ }
+
+ public boolean isShaftCoordNN(int x, int y, int z)
+ {
+ if(y==this.yShaft && x>=this.xShaftMin && x<=this.xShaftMax && z>=this.zShaftMin && z<=this.zShaftMax)
+ {
+ return true;
+ }
+ return false;
+ }
+
+ public void cleanUp()
+ {
+ int xyz[]={0,0,1,0,-1,-1,1,1,-1,2,0,2,1,2,-1,-2,0,-2,1,-2,-1,0};
+ for(int shift = 0;shift<=this.blockShift+1;shift++)
+ {
+ for(int i = 0;i<21;i++)
+ {
+ Block block = this.worldObj.getBlock(this.xCoord+xyz[i+1]*this.mZ()+shift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+shift*this.mZ());
+ if(block instanceof HorizontalMiningPipe)
+ {
+ ArrayList<ItemStack> drops = block.getDrops(this.worldObj, this.xCoord+xyz[i+1]*this.mZ()+shift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+shift*this.mZ(), 0, 3);
+ if(drops.size()>0)
+ {
+ for(int i1=0;i1<drops.size();i1++)
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord+xyz[i+1]*this.mZ()+shift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+shift*this.mZ(), drops.get(i1)));
+ }
+ }
+ this.worldObj.setBlockToAir(this.xCoord+xyz[i+1]*this.mZ()+shift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+shift*this.mZ());
+ }
+ else if(block instanceof MultiBlockSpacerBlock)
+ {
+ this.worldObj.setBlockToAir(this.xCoord+xyz[i+1]*this.mZ()+shift*this.mX(), this.yCoord+xyz[i], this.zCoord+xyz[i+1]*this.mX()+shift*this.mZ());
+ }
+ }
+ }
+ }
+
+ private boolean handleDropsByHydrotransport(ArrayList<ItemStack> drops)
+ {
+ ForgeDirection direction = ForgeDirection.getOrientation(this.getFacing()).getOpposite();
+ TileEntity te = worldObj.getTileEntity(xCoord+direction.offsetX, yCoord+direction.offsetY, zCoord+direction.offsetZ);
+ if(te instanceof HydrotransportPulpRegeneratorTileEntity)
+ {
+ HydrotransportPulpRegeneratorTileEntity hprte = (HydrotransportPulpRegeneratorTileEntity) te;
+ if(hprte.getActive())
+ {
+ ArrayList<ItemStack> drops1 = new ArrayList();
+ Iterator<ItemStack> dropsIterator = drops.iterator();
+ while(dropsIterator.hasNext())
+ {
+ ItemStack stack = dropsIterator.next();
+ RecipeOutput maceratorOut = Recipes.macerator.getOutputFor(stack, false);
+ if(maceratorOut!=null && !maceratorOut.items.isEmpty())
+ {
+ Iterator<ItemStack> maceratorOutIterator = maceratorOut.items.iterator();
+ while(maceratorOutIterator.hasNext())
+ {
+ drops1.add(maceratorOutIterator.next().copy());
+ }
+ }
+ else
+ {
+ drops1.add(stack);
+ }
+ }
+ if(hprte.outputSlot.canAdd(drops1))
+ {
+ hprte.outputSlot.add(drops1);
+ }
+ else
+ {
+ for(int i1=0;i1<drops1.size();i1++)
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, xCoord+direction.offsetX, yCoord+direction.offsetY, zCoord+direction.offsetZ, drops1.get(i1)));
+ }
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ @Override
+ public void onNetworkEvent(EntityPlayer player, int event)
+ {
+ switch(event)
+ {
+ case 0:
+ this.reverseModeOn=!this.reverseModeOn;
+ IC2.network.get().updateTileEntityField(this, "reverseModeOn");
+ this.updateChecksum=-1;
+ this.setOverclockRates();
+ break;
+ case 1:
+ this.autoReverseModeOn=!this.autoReverseModeOn;
+ IC2.network.get().updateTileEntityField(this, "autoReverseModeOn");
+ break;
+ default:
+ break;
+ }
+ }
+
+ public void defineTechBlockVariables()
+ {
+ this.xShaftMin=this.xCoord+this.blockShift*Math.min(this.mX(), 0);
+ this.xShaftMax=this.xCoord+this.blockShift*Math.max(this.mX(), 0);
+ this.yShaft=this.yCoord;
+ this.zShaftMin=this.zCoord+this.blockShift*Math.min(this.mZ(), 0);
+ this.zShaftMax=this.zCoord+this.blockShift*Math.max(this.mZ(), 0);
+ this.xShieldMin=this.xCoord+this.blockShift*this.mX()-3*Math.max(this.mX(), 0)-2*Math.abs(this.mZ());
+ this.xShieldMax=this.xCoord+this.blockShift*this.mX()-3*Math.min(this.mX(), 0)+2*Math.abs(this.mZ());
+ this.yShieldMin=this.yCoord-2;
+ this.yShieldMax=this.yCoord+2;
+ this.zShieldMin=this.zCoord+this.blockShift*this.mZ()-3*Math.max(this.mZ(), 0)-2*Math.abs(this.mX());
+ this.zShieldMax=this.zCoord+this.blockShift*this.mZ()-3*Math.min(this.mZ(), 0)+2*Math.abs(this.mX());
+ }
+
+ public void harvestDrops(Block block, int x, int y, int z, int x1, int y1, int z1, Block setToBlock)
+ {
+ if(block!=null && block!=Blocks.air && block!=Blocks.bedrock)
+ {
+ int meta = worldObj.getBlockMetadata(x, y, z);
+ ArrayList<ItemStack> drops = block.getDrops(this.worldObj, x, y, z, meta, 0);
+ if(drops.size()>0)
+ {
+ for(int i1=0;i1<drops.size();i1++)
+ {
+ this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, x1, y1, z1, drops.get(i1)));
+ }
+ }
+ }
+ this.worldObj.setBlock(x, y, z, setToBlock);
+ }
+
+ //1.7.10 API
+ @Override
+ public double getDemandedEnergy()
+ {
+ return this.maxStorage - this.energy;
+ }
+
+ @Override
+ public int getSinkTier()
+ {
+ return this.tier;
+ }
+
+ @Override
+ public double injectEnergy(ForgeDirection directionFrom, double amount, double voltage)
+ {
+ if (this.energy >= this.maxStorage)
+ {
+ return amount;
+ }
+ else
+ {
+ this.energy += amount;
+ return 0.0D;
+ }
+ }
+
+ @Override
+ public double getEnergy() {
+ return this.energy;
+ }
+
+ @Override
+ public boolean useEnergy(double amount)
+ {
+ if (this.energy >= amount)
+ {
+ this.energy -= amount;
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ @Override
+ public boolean shouldRenderInPass(int pass)
+ {
+ return pass==0;
+ }
+
+ @Override
+ public boolean getIsInvalid()
+ {
+ return this.isInvalid();
+ }
+
+ public void installAdvancedShield()
+ {
+ this.installShield();
+ this.advancedShield=true;
+ IC2.network.get().updateTileEntityField(this, "advancedShield");
+ }
+
+ public ItemStack getOutput(int arg0)
+ {
+ return null;
+ }
+
+ public int getOutputSize() {
+ return 0;
+ }
+
+ public void setOutput(int arg0, ItemStack arg1)
+ {
+ }
+
+ @Override
+ public Set<UpgradableProperty> getUpgradableProperties()
+ {
+ Set<UpgradableProperty> properties = new HashSet<UpgradableProperty>();
+ properties.add(UpgradableProperty.EnergyStorage);
+ properties.add(UpgradableProperty.Processing);
+ properties.add(UpgradableProperty.Transformer);
+ return properties;
+ }
+}
|