Files
Gadomancy/src/main/java/makeo/gadomancy/common/blocks/tiles/TileAuraPylon.java
T
HellFirePvP 28dee0fff0 - AuraPylon finish
- AuraResearchPage finish
2015-11-30 14:51:06 +01:00

589 lines
20 KiB
Java

package makeo.gadomancy.common.blocks.tiles;
import makeo.gadomancy.common.entities.EntityPermNoClipItem;
import makeo.gadomancy.common.aura.AuraEffectHandler;
import makeo.gadomancy.common.utils.NBTHelper;
import net.minecraft.block.Block;
import net.minecraft.command.IEntitySelector;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.MathHelper;
import net.minecraftforge.common.util.ForgeDirection;
import thaumcraft.api.ThaumcraftApiHelper;
import thaumcraft.api.aspects.Aspect;
import thaumcraft.api.aspects.AspectList;
import thaumcraft.api.aspects.IAspectContainer;
import thaumcraft.api.aspects.IEssentiaTransport;
import thaumcraft.client.fx.ParticleEngine;
import thaumcraft.client.fx.particles.FXEssentiaTrail;
import thaumcraft.common.entities.EntityPermanentItem;
import thaumcraft.common.entities.EntitySpecialItem;
import thaumcraft.common.items.ItemCrystalEssence;
import java.util.ArrayList;
import java.util.List;
/**
* This class is part of the Gadomancy Mod
* Gadomancy is Open Source and distributed under the
* GNU LESSER GENERAL PUBLIC LICENSE
* for more read the LICENSE file
* <p/>
* Created by HellFirePvP @ 11.11.2015 14:30
*/
public class TileAuraPylon extends SynchronizedTileEntity implements IAspectContainer, IEssentiaTransport {
//This TileEntity is designed to be used stacked with others of its kind - without limits.
//The aspects the tiles contain are all provided in the top tile of the structure
//The actual work is done in the top tile of the structure
//The inner aspect type is defined by a piece of crystallized Essentia being checked by the master-tile
//The master tile informs all the other tiles what aspect currently is in use.
//All tiles check each 8 ticks if the structure is still complete/contains an IO- and a master-tile
//Master tile updates its state and the state of all tiles every 4 ticks so Aspect information and item information are still valid.
//Master tile updates effects all 8 ticks if there is an internal aspect present.
//Input tile handles Essentia IO all 8 ticks and thus provides needed amount information.
private ItemStack crystalEssentiaStack = null;
private boolean isPartOfMultiblock = false;
public int timeSinceLastItemInfo = 0; //0-5, update interval = 2
private int ticksExisted = 0;
private Aspect holdingAspect;
private int amount = 0;
private int maxAmount = 16;
private boolean isMasterTile;
private boolean isInputTile;
//Individual.
@Override
public void updateEntity() {
ticksExisted++;
timeSinceLastItemInfo++;
if (!worldObj.isRemote) {
if ((ticksExisted & 7) == 0) {
if (checkComponents()) return;
}
if (isInputTile()) {
handleIO();
}
if (isMasterTile()) {
TileAuraPylon io = getInputTile();
if(io != null && io.amount > 0) {
if ((ticksExisted & 31) == 0) {
drainEssentia(io);
}
doAuraEffects(holdingAspect);
}
if(holdingAspect != null && timeSinceLastItemInfo > 8) {
informItemPickup();
}
}
} else {
if( isInputTile() && holdingAspect != null) {
doEssentiaTrail();
}
}
if (isMasterTile()) {
if (crystalEssentiaStack == null) {
tryVortexPossibleItems();
}
}
}
private void doAuraEffects(Aspect aspect) {
if(aspect == null) return;
if(!isMasterTile()) return;
if(worldObj.isRemote) return;
AuraEffectHandler.distributeEffects(aspect, worldObj, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, 8, ticksExisted);
}
private void drainEssentia(TileAuraPylon io) {
if(!isMasterTile()) return;
io.amount--;
worldObj.markBlockForUpdate(io.xCoord, io.yCoord, io.zCoord);
io.markDirty();
}
//Client-Side input tile only!
private void doEssentiaTrail() {
if((ticksExisted & 1) == 0) return;
TileAuraPylon tile = getMasterTile();
if(tile == null) return;
TileAuraPylon inputTile = getInputTile();
if(inputTile == null) return;
Aspect a = inputTile.getAspectType();
if(a == null) return;
if(inputTile.amount <= 0) return;
int count = 5;
FXEssentiaTrail essentiaTrail = new FXEssentiaTrail(tile.getWorldObj(), inputTile.xCoord + 0.5, inputTile.yCoord + 0.2, inputTile.zCoord + 0.5, tile.xCoord + 0.5, tile.yCoord + 1.7, tile.zCoord + 0.5, count, a.getColor(), 1);
essentiaTrail.noClip = true;
essentiaTrail.motionY = (0.1F + MathHelper.sin(count / 3.0F) * 0.01F);
essentiaTrail.motionX = (MathHelper.sin(count / 10.0F) * 0.001F + worldObj.rand.nextGaussian() * 0.002000000094994903D);
essentiaTrail.motionZ = (MathHelper.sin(count / 10.0F) * 0.001F + worldObj.rand.nextGaussian() * 0.002000000094994903D);
ParticleEngine.instance.addEffect(tile.getWorldObj(), essentiaTrail);
}
//Special to masterTile only!
private void distributeAspectInformation() {
if(!isMasterTile()) return;
int count = 1;
TileEntity iter = worldObj.getTileEntity(xCoord, yCoord - count, zCoord);
while(iter != null && iter instanceof TileAuraPylon) {
((TileAuraPylon) iter).holdingAspect = holdingAspect;
worldObj.markBlockForUpdate(xCoord, yCoord - count, zCoord);
iter.markDirty();
count++;
iter = worldObj.getTileEntity(xCoord, yCoord - count, zCoord);
}
}
//Special to masterTile only!
private void tryVortexPossibleItems() {
TileAuraPylon io = getInputTile();
if (io == null) return;
int masterY = yCoord + 1;
float dst = ((float) (masterY - io.yCoord)) / 2F;
float yC = masterY - dst;
List entityItems = worldObj.selectEntitiesWithinAABB(EntityItem.class,
AxisAlignedBB.getBoundingBox(xCoord - 0.5, yC - 0.5, zCoord - 0.5, xCoord + 0.5, yC + 0.5, zCoord + 0.5).expand(8, 8, 8), new IEntitySelector() {
@Override
public boolean isEntityApplicable(Entity e) {
return !(e instanceof EntityPermanentItem) && !(e instanceof EntitySpecialItem) &&
e instanceof EntityItem && ((EntityItem) e).getEntityItem() != null &&
((EntityItem) e).getEntityItem().getItem() instanceof ItemCrystalEssence;
}
});
Entity dummy = new EntityItem(worldObj);
dummy.posX = xCoord + 0.5;
dummy.posY = yC + 0.5;
dummy.posZ = zCoord + 0.5;
//MC code.
EntityItem entity = null;
double d0 = Double.MAX_VALUE;
for (Object entityItem : entityItems) {
EntityItem entityIt = (EntityItem) entityItem;
if (entityIt != dummy) {
double d1 = dummy.getDistanceSqToEntity(entityIt);
if (d1 <= d0) {
entity = entityIt;
d0 = d1;
}
}
}
if(entity == null) return;
if(dummy.getDistanceToEntity(entity) < 1 && !worldObj.isRemote) {
this.crystalEssentiaStack = entity.getEntityItem();
EntityPermNoClipItem item = new EntityPermNoClipItem(entity.worldObj, xCoord + 0.5F, yC + 0.3F, zCoord + 0.5F, crystalEssentiaStack, xCoord, yCoord, zCoord);
entity.worldObj.spawnEntityInWorld(item);
item.setVelocity(0, 0, 0);
item.hoverStart = entity.hoverStart;
item.age = entity.age;
item.noClip = true;
timeSinceLastItemInfo = 0;
holdingAspect = ((ItemCrystalEssence) crystalEssentiaStack.getItem()).getAspects(crystalEssentiaStack).getAspects()[0];
distributeAspectInformation();
entity.setDead();
item.delayBeforeCanPickup = 60;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
markDirty();
} else {
entity.noClip = true;
applyMovementVectors(entity);
}
}
//Special to masterTile only!
private void applyMovementVectors(EntityItem entity) {
double var3 = (this.xCoord + 0.5D - entity.posX) / 15.0D;
double var5 = (this.yCoord + 0.5D - entity.posY) / 15.0D;
double var7 = (this.zCoord + 0.5D - entity.posZ) / 15.0D;
double var9 = Math.sqrt(var3 * var3 + var5 * var5 + var7 * var7);
double var11 = 1.0D - var9;
if (var11 > 0.0D) {
var11 *= var11;
entity.motionX += var3 / var9 * var11 * 0.15D;
entity.motionY += var5 / var9 * var11 * 0.25D;
entity.motionZ += var7 / var9 * var11 * 0.15D;
}
}
//Special to inputTile only!
private void handleIO() {
if ((!worldObj.isRemote) && ((ticksExisted & 15) == 0) && (getEssentiaAmount() < getMaxAmount())) {
TileEntity te = ThaumcraftApiHelper.getConnectableTile(this.worldObj, this.xCoord, this.yCoord, this.zCoord, ForgeDirection.DOWN);
if (te != null) {
IEssentiaTransport ic = (IEssentiaTransport) te;
if (!ic.canOutputTo(ForgeDirection.UP)) {
return;
}
if ((holdingAspect != null) && (ic.getSuctionAmount(ForgeDirection.UP) < getSuctionAmount(ForgeDirection.DOWN))) {
addToContainer(holdingAspect, ic.takeEssentia(holdingAspect, 1, ForgeDirection.UP));
}
}
}
}
public void informItemPickup() {
if(!isMasterTile()) return;
this.crystalEssentiaStack = null;
this.holdingAspect = null;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
markDirty();
distributeAspectInformation();
TileAuraPylon io = getInputTile();
if(io == null) return;
io.amount = 0;
worldObj.markBlockForUpdate(io.xCoord, io.yCoord, io.zCoord);
io.markDirty();
}
//Individual.
//Returns true, if state has changed, false if still complete state.
private boolean checkComponents() {
TileAuraPylon te = getMasterTile();
if (te == null) {
breakTile();
return true;
}
te = getInputTile();
if (te == null) {
breakTile();
return true;
}
if(!hasTopTile()) {
breakTile();
return true;
}
return false;
}
private boolean hasTopTile() {
TileAuraPylon master = getMasterTile();
if(master == null) return false;
TileEntity te = worldObj.getTileEntity(master.xCoord, master.yCoord + 1, master.zCoord);
return !(te == null || !(te instanceof TileAuraPylonTop));
}
//Individual.
private void breakTile() {
if(!isPartOfMultiblock || worldObj.isRemote) return;
int meta = worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
Block pylon = worldObj.getBlock(xCoord, yCoord, zCoord);
if(pylon != null) {
ArrayList<ItemStack> stacks = pylon.getDrops(worldObj, xCoord, yCoord, zCoord, meta, 0);
for(ItemStack i : stacks) {
EntityItem item = new EntityItem(worldObj, xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, i);
//ItemUtils.applyRandomDropOffset(item, worldObj.rand);
worldObj.spawnEntityInWorld(item);
}
}
worldObj.removeTileEntity(xCoord, yCoord, zCoord);
worldObj.setBlockToAir(xCoord, yCoord, zCoord);
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
//Individual
public boolean isPartOfMultiblock() {
return isPartOfMultiblock;
}
//Individual.
public void setPartOfMultiblock(boolean isPartOfMultiblock) {
this.isPartOfMultiblock = isPartOfMultiblock;
}
//Individual.
@Override
public boolean canUpdate() {
return true;
}
//Individual.
public void setTileInformation(boolean isMaster, boolean isInput) {
this.isMasterTile = isMaster;
this.isInputTile = isInput;
}
//Individual.
public boolean isInputTile() {
return isInputTile;
}
//Individual.
public TileAuraPylon getInputTile() {
if (isInputTile()) return this;
if(worldObj == null) return null;
TileEntity superTile = worldObj.getTileEntity(xCoord, yCoord - 1, zCoord);
if (superTile == null || !(superTile instanceof TileAuraPylon)) return null;
return ((TileAuraPylon) superTile).getInputTile();
}
//Individual.
public boolean isMasterTile() {
return isMasterTile;
}
//Individual.
public TileAuraPylon getMasterTile() {
if (isMasterTile()) return this;
if(worldObj == null) return null;
TileEntity superTile = worldObj.getTileEntity(xCoord, yCoord + 1, zCoord);
if (superTile == null || !(superTile instanceof TileAuraPylon)) return null;
return ((TileAuraPylon) superTile).getMasterTile();
}
//Dynamic.
public int getEssentiaAmount() {
TileAuraPylon io = getInputTile();
if (io == null) return 0;
return io.amount;
}
//Dynamic.
public Aspect getAspectType() {
TileAuraPylon io = getInputTile();
if (io == null) return null;
return io.holdingAspect;
}
//Dynamic.
public int getMaxAmount() {
TileAuraPylon io = getInputTile();
if (io == null) return 0;
int max = io.maxAmount;
int counter = 1;
TileEntity superTile = worldObj.getTileEntity(xCoord, yCoord + counter, zCoord);
while (superTile != null && superTile instanceof TileAuraPylon) {
max += ((TileAuraPylon) superTile).maxAmount;
counter++;
superTile = worldObj.getTileEntity(xCoord, yCoord + counter, zCoord);
}
return max;
}
@Override
public void readCustomNBT(NBTTagCompound compound) {
this.isInputTile = compound.getBoolean("input");
this.isMasterTile = compound.getBoolean("master");
String tag = compound.getString("aspect");
if (tag != null && !tag.equals("")) {
this.holdingAspect = Aspect.getAspect(tag);
} else {
this.holdingAspect = null;
}
this.amount = compound.getInteger("amount");
this.maxAmount = compound.getInteger("maxAmount");
this.isPartOfMultiblock = compound.getBoolean("partOfMultiblock");
this.crystalEssentiaStack = NBTHelper.getStack(compound, "crystalStack");
}
@Override
public void writeCustomNBT(NBTTagCompound compound) {
compound.setBoolean("input", isInputTile);
compound.setBoolean("master", isMasterTile);
if (holdingAspect != null) {
compound.setString("aspect", holdingAspect.getTag());
}
compound.setInteger("amount", amount);
compound.setInteger("maxAmount", maxAmount);
compound.setBoolean("partOfMultiblock", isPartOfMultiblock);
if(crystalEssentiaStack != null)
NBTHelper.setStack(compound, "crystalStack", crystalEssentiaStack);
}
///////////////////////////////////////////////////////////////////////////////////////////////
// IAspectContainer
///////////////////////////////////////////////////////////////////////////////////////////////
//Dynamic.
@Override
public AspectList getAspects() {
TileAuraPylon io = getInputTile();
AspectList al = new AspectList();
if (io != null && io.holdingAspect != null && io.amount > 0) {
al.add(io.holdingAspect, io.amount);
}
return al;
}
//NO-OP
@Override
public void setAspects(AspectList aspectList) {
}
//Individual.
@Override
public boolean doesContainerAccept(Aspect aspect) {
return isInputTile() && holdingAspect != null && holdingAspect.equals(aspect);
}
//Individual.
@Override
public int addToContainer(Aspect aspect, int amount) {
if (amount == 0) {
return amount;
}
if (!isInputTile()) return 0;
if (aspect == null) return 0;
if (holdingAspect != null && this.amount < getMaxAmount() && aspect == holdingAspect) {
int added = Math.min(amount, getMaxAmount() - this.amount);
this.amount += added;
amount -= added;
this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
markDirty();
}
return amount;
}
//Individual.
@Override
public boolean takeFromContainer(Aspect aspect, int i) {
if (!isInputTile()) return false;
if (aspect == null || holdingAspect == null) return false;
if (this.amount >= i && holdingAspect.equals(aspect)) {
this.amount -= i;
if (this.amount <= 0) {
this.holdingAspect = null;
this.amount = 0;
}
this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
markDirty();
return true;
}
return false;
}
//Individual.
//You may only extract 1 at a time.
@Override
public boolean takeFromContainer(AspectList aspectList) {
return false;
}
//Individual.
@Override
public boolean doesContainerContainAmount(Aspect aspect, int i) {
return isInputTile() && holdingAspect != null && this.amount >= i && aspect == holdingAspect;
}
//Individual.
@Override
public boolean doesContainerContain(AspectList list) {
if (!isInputTile()) return false;
if (holdingAspect == null) return false;
for (Aspect a : list.getAspects()) if ((this.amount > 0) && (a == holdingAspect)) return true;
return false;
}
//Individual.
@Override
public int containerContains(Aspect aspect) {
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// IEssentiaTransport
///////////////////////////////////////////////////////////////////////////////////////////////
//Individual.
@Override
public boolean isConnectable(ForgeDirection face) {
return isInputTile() && face == ForgeDirection.DOWN;
}
//Individual.
@Override
public boolean canInputFrom(ForgeDirection face) {
return isInputTile() && face == ForgeDirection.DOWN;
}
//Individual.
@Override
public boolean canOutputTo(ForgeDirection face) {
return false;
}
//NO-OP
@Override
public void setSuction(Aspect aspect, int i) {
}
//Individual.
@Override
public Aspect getSuctionType(ForgeDirection forgeDirection) {
return isInputTile() ? holdingAspect : null;
}
@Override
public int getSuctionAmount(ForgeDirection forgeDirection) {
if (!isInputTile()) return 0;
if (holdingAspect == null) return 0;
return getMinimumSuction();
}
@Override
public int takeEssentia(Aspect aspect, int amt, ForgeDirection direction) {
return 0;
}
@Override
public int addEssentia(Aspect aspect, int amt, ForgeDirection direction) {
if (!isInputTile()) return 0;
return canInputFrom(direction) ? amount - addToContainer(aspect, amount) : 0;
}
//Individual.
@Override
public Aspect getEssentiaType(ForgeDirection forgeDirection) {
return isInputTile() ? holdingAspect : null;
}
//Individual.
@Override
public int getEssentiaAmount(ForgeDirection forgeDirection) {
return isInputTile() ? amount : 0;
}
@Override
public int getMinimumSuction() {
return 128;
}
//Individual.
@Override
public boolean renderExtendedTube() {
return false;
}
public boolean isLowestTile() {
if(worldObj == null) return false;
TileEntity te = worldObj.getTileEntity(xCoord, yCoord - 1, zCoord);
return te == null || !(te instanceof TileAuraPylon);
}
}