mirror of
https://github.com/Ellpeck/NaturesAura.git
synced 2024-06-03 03:43:36 +02:00
290 lines
12 KiB
Java
290 lines
12 KiB
Java
package de.ellpeck.naturesaura.blocks.tiles;
|
|
|
|
import de.ellpeck.naturesaura.Helper;
|
|
import de.ellpeck.naturesaura.NaturesAura;
|
|
import de.ellpeck.naturesaura.aura.BasicAuraContainer;
|
|
import de.ellpeck.naturesaura.aura.Capabilities;
|
|
import de.ellpeck.naturesaura.aura.IAuraContainer;
|
|
import de.ellpeck.naturesaura.packet.PacketHandler;
|
|
import de.ellpeck.naturesaura.packet.PacketParticleStream;
|
|
import de.ellpeck.naturesaura.packet.PacketParticles;
|
|
import de.ellpeck.naturesaura.recipes.AltarRecipe;
|
|
import net.minecraft.block.BlockStoneBrick;
|
|
import net.minecraft.block.BlockStoneBrick.EnumType;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.ITickable;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraftforge.items.IItemHandlerModifiable;
|
|
import net.minecraftforge.items.ItemStackHandler;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Random;
|
|
|
|
public class TileEntityNatureAltar extends TileEntityImpl implements ITickable {
|
|
|
|
private static final BlockPos[] BRICK_POSITIONS = new BlockPos[]{
|
|
new BlockPos(-2, -1, 0),
|
|
new BlockPos(-3, -1, 0),
|
|
new BlockPos(-4, 0, 0),
|
|
new BlockPos(-4, 1, 0),
|
|
|
|
new BlockPos(2, -1, 0),
|
|
new BlockPos(3, -1, 0),
|
|
new BlockPos(4, 0, 0),
|
|
new BlockPos(4, 1, 0),
|
|
|
|
new BlockPos(0, -1, -2),
|
|
new BlockPos(0, -1, -3),
|
|
new BlockPos(0, 0, -4),
|
|
new BlockPos(0, 1, -4),
|
|
|
|
new BlockPos(0, -1, 2),
|
|
new BlockPos(0, -1, 3),
|
|
new BlockPos(0, 0, 4),
|
|
new BlockPos(0, 1, 4)
|
|
};
|
|
private static final BlockPos[] MOSSY_POSITIONS = new BlockPos[]{
|
|
new BlockPos(-4, 2, 0),
|
|
new BlockPos(4, 2, 0),
|
|
new BlockPos(0, 2, -4),
|
|
new BlockPos(0, 2, 4),
|
|
|
|
new BlockPos(-2, 0, -2),
|
|
new BlockPos(2, 0, -2),
|
|
new BlockPos(2, 0, 2),
|
|
new BlockPos(-2, 0, 2)
|
|
};
|
|
private static final BlockPos[] CHISELED_POSITIONS = new BlockPos[]{
|
|
new BlockPos(1, -1, 1),
|
|
new BlockPos(-1, -1, 1),
|
|
new BlockPos(-1, -1, -1),
|
|
new BlockPos(1, -1, -1)
|
|
};
|
|
private static final BlockPos[] WOOD_POSITIONS = new BlockPos[]{
|
|
new BlockPos(-1, -1, 0),
|
|
new BlockPos(1, -1, 0),
|
|
new BlockPos(0, -1, -1),
|
|
new BlockPos(0, -1, 1),
|
|
|
|
new BlockPos(-2, -1, -1),
|
|
new BlockPos(-3, -1, -1),
|
|
new BlockPos(-2, -1, 1),
|
|
new BlockPos(-3, -1, 1),
|
|
|
|
new BlockPos(2, -1, -1),
|
|
new BlockPos(3, -1, -1),
|
|
new BlockPos(2, -1, 1),
|
|
new BlockPos(3, -1, 1),
|
|
|
|
new BlockPos(-1, -1, -2),
|
|
new BlockPos(-1, -1, -3),
|
|
new BlockPos(1, -1, -2),
|
|
new BlockPos(1, -1, -3),
|
|
|
|
new BlockPos(-1, -1, 2),
|
|
new BlockPos(-1, -1, 3),
|
|
new BlockPos(1, -1, 2),
|
|
new BlockPos(1, -1, 3),
|
|
};
|
|
|
|
public final ItemStackHandler items = new ItemStackHandlerNA(1, this, true) {
|
|
@Override
|
|
public int getSlotLimit(int slot) {
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
protected boolean canInsert(ItemStack stack, int slot) {
|
|
return AltarRecipe.forInput(stack) != null || stack.hasCapability(Capabilities.auraContainer, null);
|
|
}
|
|
|
|
@Override
|
|
protected boolean canExtract(ItemStack stack, int slot, int amount) {
|
|
return AltarRecipe.forInput(stack) == null;
|
|
}
|
|
};
|
|
|
|
private final List<TileEntity> cachedProviders = new ArrayList<>();
|
|
private final BasicAuraContainer container = new BasicAuraContainer(5000, true);
|
|
public boolean structureFine;
|
|
|
|
private AltarRecipe currentRecipe;
|
|
private int timer;
|
|
|
|
private int lastAura;
|
|
|
|
@Override
|
|
public void update() {
|
|
Random rand = this.world.rand;
|
|
|
|
if (!this.world.isRemote) {
|
|
if (this.world.getTotalWorldTime() % 40 == 0) {
|
|
boolean fine = this.check(BRICK_POSITIONS, Blocks.STONEBRICK.getDefaultState(), false)
|
|
&& this.check(MOSSY_POSITIONS, Blocks.STONEBRICK.getDefaultState().withProperty(BlockStoneBrick.VARIANT, EnumType.MOSSY), false)
|
|
&& this.check(CHISELED_POSITIONS, Blocks.STONEBRICK.getDefaultState().withProperty(BlockStoneBrick.VARIANT, EnumType.CHISELED), false)
|
|
&& this.check(WOOD_POSITIONS, Blocks.PLANKS.getDefaultState(), true);
|
|
if (fine != this.structureFine) {
|
|
this.structureFine = fine;
|
|
this.sendToClients();
|
|
}
|
|
}
|
|
|
|
if (this.structureFine) {
|
|
if (this.world.getTotalWorldTime() % 100 == 0) {
|
|
this.cachedProviders.clear();
|
|
for (TileEntity tile : Helper.getTileEntitiesInArea(this.world, this.pos, 15)) {
|
|
if (tile.hasCapability(Capabilities.auraContainer, null) && tile != this) {
|
|
this.cachedProviders.add(tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!this.cachedProviders.isEmpty()) {
|
|
int index = rand.nextInt(this.cachedProviders.size());
|
|
TileEntity provider = this.cachedProviders.get(index);
|
|
if (!provider.isInvalid() && provider.hasCapability(Capabilities.auraContainer, null)) {
|
|
IAuraContainer container = provider.getCapability(Capabilities.auraContainer, null);
|
|
int stored = this.container.storeAura(container.drainAura(5, true), false);
|
|
if (stored > 0) {
|
|
container.drainAura(stored, false);
|
|
|
|
BlockPos pos = provider.getPos();
|
|
PacketHandler.sendToAllAround(this.world, this.pos, 32, new PacketParticleStream(
|
|
pos.getX() + 0.5F, pos.getY() + 0.5F, pos.getZ() + 0.5F,
|
|
this.pos.getX() + 0.5F, this.pos.getY() + 0.5F, this.pos.getZ() + 0.5F,
|
|
rand.nextFloat() * 0.05F + 0.05F, container.getAuraColor(), rand.nextFloat() * 1F + 1F
|
|
));
|
|
}
|
|
} else {
|
|
this.cachedProviders.remove(index);
|
|
}
|
|
}
|
|
|
|
ItemStack stack = this.items.getStackInSlot(0);
|
|
if (!stack.isEmpty() && stack.hasCapability(Capabilities.auraContainer, null)) {
|
|
IAuraContainer container = stack.getCapability(Capabilities.auraContainer, null);
|
|
int theoreticalDrain = this.container.drainAura(10, true);
|
|
if (theoreticalDrain > 0) {
|
|
int stored = container.storeAura(theoreticalDrain, false);
|
|
if (stored > 0) {
|
|
this.container.drainAura(stored, false);
|
|
|
|
if (this.world.getTotalWorldTime() % 4 == 0) {
|
|
PacketHandler.sendToAllAround(this.world, this.pos, 32, new PacketParticles(this.pos.getX(), this.pos.getY(), this.pos.getZ(), 4));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (this.currentRecipe == null) {
|
|
if (!stack.isEmpty()) {
|
|
this.currentRecipe = AltarRecipe.forInput(stack);
|
|
}
|
|
} else {
|
|
if (stack.isEmpty() || !stack.isItemEqual(this.currentRecipe.input)) {
|
|
this.currentRecipe = null;
|
|
} else {
|
|
int req = this.currentRecipe.aura / this.currentRecipe.time;
|
|
if (this.container.getStoredAura() >= req) {
|
|
this.container.drainAura(req, false);
|
|
|
|
if (this.timer % 4 == 0) {
|
|
PacketHandler.sendToAllAround(this.world, this.pos, 32, new PacketParticles(this.pos.getX(), this.pos.getY(), this.pos.getZ(), 4));
|
|
}
|
|
|
|
this.timer++;
|
|
if (this.timer >= this.currentRecipe.time) {
|
|
this.items.setStackInSlot(0, this.currentRecipe.output.copy());
|
|
this.currentRecipe = null;
|
|
this.timer = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.world.getTotalWorldTime() % 10 == 0 && this.lastAura != this.container.getStoredAura()) {
|
|
this.lastAura = this.container.getStoredAura();
|
|
this.sendToClients();
|
|
}
|
|
} else {
|
|
if (this.structureFine) {
|
|
if (rand.nextFloat() >= 0.7F) {
|
|
int fourths = this.container.getMaxAura() / 4;
|
|
if (this.container.getStoredAura() > 0) {
|
|
NaturesAura.proxy.spawnMagicParticle(this.world,
|
|
this.pos.getX() - 4F + rand.nextFloat(), this.pos.getY() + 3F, this.pos.getZ() + rand.nextFloat(),
|
|
0F, 0F, 0F, this.container.getAuraColor(), rand.nextFloat() * 3F + 1F, rand.nextInt(200) + 100, -0.025F, true, true);
|
|
}
|
|
if (this.container.getStoredAura() >= fourths) {
|
|
NaturesAura.proxy.spawnMagicParticle(this.world,
|
|
this.pos.getX() + 4F + rand.nextFloat(), this.pos.getY() + 3F, this.pos.getZ() + rand.nextFloat(),
|
|
0F, 0F, 0F, this.container.getAuraColor(), rand.nextFloat() * 3F + 1F, rand.nextInt(200) + 100, -0.025F, true, true);
|
|
}
|
|
if (this.container.getStoredAura() >= fourths * 2) {
|
|
NaturesAura.proxy.spawnMagicParticle(this.world,
|
|
this.pos.getX() + rand.nextFloat(), this.pos.getY() + 3F, this.pos.getZ() - 4F + rand.nextFloat(),
|
|
0F, 0F, 0F, this.container.getAuraColor(), rand.nextFloat() * 3F + 1F, rand.nextInt(200) + 100, -0.025F, true, true);
|
|
}
|
|
if (this.container.getStoredAura() >= fourths * 3) {
|
|
NaturesAura.proxy.spawnMagicParticle(this.world,
|
|
this.pos.getX() + rand.nextFloat(), this.pos.getY() + 3F, this.pos.getZ() + 4F + rand.nextFloat(),
|
|
0F, 0F, 0F, this.container.getAuraColor(), rand.nextFloat() * 3F + 1F, rand.nextInt(200) + 100, -0.025F, true, true);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean check(BlockPos[] positions, IBlockState state, boolean blockOnly) {
|
|
return Helper.checkMultiblock(this.world, this.pos, positions, state, blockOnly);
|
|
}
|
|
|
|
@Override
|
|
public void writeNBT(NBTTagCompound compound, boolean syncing) {
|
|
super.writeNBT(compound, syncing);
|
|
compound.setTag("items", this.items.serializeNBT());
|
|
compound.setBoolean("fine", this.structureFine);
|
|
this.container.writeNBT(compound);
|
|
|
|
if (!syncing) {
|
|
if (this.currentRecipe != null) {
|
|
compound.setTag("recipe_input", this.currentRecipe.input.serializeNBT());
|
|
compound.setInteger("timer", this.timer);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readNBT(NBTTagCompound compound, boolean syncing) {
|
|
super.readNBT(compound, syncing);
|
|
this.items.deserializeNBT(compound.getCompoundTag("items"));
|
|
this.structureFine = compound.getBoolean("fine");
|
|
this.container.readNBT(compound);
|
|
|
|
if (!syncing) {
|
|
if (compound.hasKey("recipe_input")) {
|
|
this.currentRecipe = AltarRecipe.forInput(new ItemStack(compound.getCompoundTag("recipe_input")));
|
|
this.timer = compound.getInteger("timer");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public IAuraContainer getAuraContainer(EnumFacing facing) {
|
|
return this.container;
|
|
}
|
|
|
|
@Override
|
|
public IItemHandlerModifiable getItemHandler(EnumFacing facing) {
|
|
return this.items;
|
|
}
|
|
}
|