866 lines
25 KiB
Java
866 lines
25 KiB
Java
package com.myuki69.enderquarry;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.BlockLiquid;
|
|
import net.minecraft.block.IGrowable;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.enchantment.Enchantment;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.init.Enchantments;
|
|
import net.minecraft.init.Items;
|
|
import net.minecraft.inventory.EntityEquipmentSlot;
|
|
import net.minecraft.item.Item;
|
|
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.minecraft.util.math.ChunkPos;
|
|
import net.minecraft.util.text.TextComponentString;
|
|
import net.minecraft.world.WorldServer;
|
|
import net.minecraftforge.common.ForgeChunkManager;
|
|
import net.minecraftforge.common.IPlantable;
|
|
import net.minecraftforge.common.capabilities.Capability;
|
|
import net.minecraftforge.common.util.FakePlayer;
|
|
import net.minecraftforge.common.util.FakePlayerFactory;
|
|
import net.minecraftforge.energy.CapabilityEnergy;
|
|
import net.minecraftforge.energy.EnergyStorage;
|
|
import net.minecraftforge.event.ForgeEventFactory;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTank;
|
|
import net.minecraftforge.fluids.IFluidBlock;
|
|
import net.minecraftforge.fluids.capability.CapabilityFluidHandler;
|
|
import net.minecraftforge.fluids.capability.IFluidHandler;
|
|
import net.minecraftforge.fluids.capability.wrappers.BlockLiquidWrapper;
|
|
import net.minecraftforge.fluids.capability.wrappers.FluidBlockWrapper;
|
|
import net.minecraftforge.items.CapabilityItemHandler;
|
|
import net.minecraftforge.items.IItemHandler;
|
|
import net.minecraftforge.items.ItemHandlerHelper;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Random;
|
|
|
|
public class TileEnderQuarry
|
|
extends TileEntity
|
|
implements ITickable, IItemHandler
|
|
{
|
|
private static final Random rand = new Random();
|
|
public static int baseDrain = 1800;
|
|
public static float hardnessDrain = 200.0F;
|
|
|
|
public ArrayList<ItemStack> items = new ArrayList<ItemStack>();
|
|
public FluidTank tank = new FluidTank(32000);
|
|
public EnergyStorage energy = new EnergyStorage(10000000);
|
|
public int neededEnergy = -1;
|
|
public int config = -1;
|
|
|
|
public long progress = 0L;
|
|
public boolean started = false;
|
|
public boolean finished = false;
|
|
|
|
|
|
public int dx = 1;
|
|
public int dy = 0;
|
|
public int dz = 0;
|
|
|
|
int chunk_x = 0;
|
|
int chunk_z = 0;
|
|
int chunk_y = 0;
|
|
|
|
int xCoord;
|
|
int yCoord;
|
|
int zCoord;
|
|
|
|
int min_x;
|
|
int max_x;
|
|
int min_z;
|
|
int max_z;
|
|
|
|
private ForgeChunkManager.Ticket chunkTicket;
|
|
private EntityPlayer owner;
|
|
|
|
public static double[] powerMultipliers = { 1.0D, 1.0D, 1.5D, 5.0D, 20.0D, 80.0D, 1.0D, 1.5D, 2.0D, 1.0D, 0.0D, 0.0D, 0.0D, 0.0D, 0.0D, 0.0D };
|
|
public boolean[] upgrades = new boolean[16];
|
|
public static final int UPGRADE_BLANK = 0;
|
|
public static final int UPGRADE_VOID = 1;
|
|
public static final int UPGRADE_SILK = 2;
|
|
public static final int UPGRADE_FORTUNE1 = 3;
|
|
public static final int UPGRADE_FORTUNE2 = 4;
|
|
public static final int UPGRADE_FORTUNE3 = 5;
|
|
public static final int UPGRADE_SPEED1 = 6;
|
|
public static final int UPGRADE_SPEED2 = 7;
|
|
public static final int UPGRADE_SPEED3 = 8;
|
|
public static final int UPGRADE_FLUID = 9;
|
|
|
|
public TileEnderQuarry()
|
|
{
|
|
|
|
tank.setCanFill(false);
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound tags)
|
|
{
|
|
this.energy.receiveEnergy(tags.getInteger("energy"), false);
|
|
int n = tags.getInteger("item_no");
|
|
this.items.clear();
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
NBTTagCompound t = tags.getCompoundTag("item_" + i);
|
|
this.items.add(new ItemStack(t));
|
|
}
|
|
if (tags.hasKey("fluid"))
|
|
tank.fillInternal(FluidStack.loadFluidStackFromNBT(tags.getCompoundTag("fluid")), true);
|
|
|
|
this.finished = tags.getBoolean("finished");
|
|
if (this.finished)
|
|
return;
|
|
|
|
this.started = tags.getBoolean("started");
|
|
if (!this.started)
|
|
return;
|
|
|
|
min_x = tags.getInteger("min_x");
|
|
min_z = tags.getInteger("min_z");
|
|
max_x = tags.getInteger("max_x");
|
|
max_z = tags.getInteger("max_z");
|
|
chunk_x = tags.getInteger("chunk_x");
|
|
chunk_y = tags.getInteger("chunk_y");
|
|
chunk_z = tags.getInteger("chunk_z");
|
|
dx = tags.getInteger("dx");
|
|
dy = tags.getInteger("dy");
|
|
dz = tags.getInteger("dz");
|
|
progress = tags.getLong("progress");
|
|
super.readFromNBT(tags);
|
|
}
|
|
|
|
@Override
|
|
public NBTTagCompound writeToNBT(NBTTagCompound tags)
|
|
{
|
|
tags.setInteger("energy", energy.getEnergyStored());
|
|
for (int i = 0; i < items.size(); i++)
|
|
{
|
|
while (i < items.size() && items.get(i) == null)
|
|
items.remove(i);
|
|
|
|
if (i < items.size())
|
|
{
|
|
NBTTagCompound t = new NBTTagCompound();
|
|
((ItemStack)items.get(i)).writeToNBT(t);
|
|
tags.setTag("item_" + i, t);
|
|
}
|
|
}
|
|
tags.setInteger("item_no", items.size());
|
|
if (tank.getFluid() != null)
|
|
{
|
|
NBTTagCompound t = new NBTTagCompound();
|
|
tank.getFluid().writeToNBT(t);
|
|
tags.setTag("fluid", t);
|
|
}
|
|
if (finished)
|
|
{
|
|
tags.setBoolean("finished", true);
|
|
}
|
|
else if (started)
|
|
{
|
|
tags.setBoolean("started", true);
|
|
tags.setInteger("min_x", min_x);
|
|
tags.setInteger("max_x", max_x);
|
|
tags.setInteger("min_z", min_z);
|
|
tags.setInteger("max_z", max_z);
|
|
tags.setInteger("chunk_x", chunk_x);
|
|
tags.setInteger("chunk_y", chunk_y);
|
|
tags.setInteger("chunk_z", chunk_z);
|
|
tags.setInteger("dx", dx);
|
|
tags.setInteger("dy", dy);
|
|
tags.setInteger("dz", dz);
|
|
tags.setLong("progress", progress);
|
|
}
|
|
return super.writeToNBT(tags);
|
|
}
|
|
|
|
public boolean checkForMarkers(EntityPlayer player)
|
|
{
|
|
BlockPos thisBlockPos = this.getPos();
|
|
System.out.println("Quarry checking at: " + thisBlockPos.getX() + " " + thisBlockPos.getY() + " " + thisBlockPos.getZ());
|
|
for (EnumFacing face : EnumFacing.HORIZONTALS)
|
|
{
|
|
BlockPos vecin = thisBlockPos.offset(face);
|
|
int offsetX = vecin.getX() - thisBlockPos.getX();
|
|
int offsetZ = vecin.getZ() - thisBlockPos.getZ();
|
|
|
|
int[] test = { this.world.provider.getDimension(), vecin.getX(), vecin.getY(), vecin.getZ() };
|
|
int[] test_forward = null;
|
|
int[] test_side = null;
|
|
|
|
boolean foundAttached = false;
|
|
for (int[] a : TileEnderMarker.markers)
|
|
{
|
|
if (isIntEqual(a, test))
|
|
{
|
|
foundAttached = true;
|
|
break;
|
|
}
|
|
}
|
|
if (foundAttached)
|
|
{
|
|
player.sendMessage(new TextComponentString("Found attached ender-marker"));
|
|
for (int[] a : TileEnderMarker.markers)
|
|
{
|
|
if ((a[0] == test[0]) && (a[2] == test[2]) && ((a[1] != test[1]) || (a[3] != test[3])))
|
|
{
|
|
if ((sign(a[1] - test[1]) == offsetX) && (sign(a[3] - test[3]) == offsetZ))
|
|
{
|
|
if (test_forward == null)
|
|
test_forward = a;
|
|
else if (!isIntEqual(a, test_forward))
|
|
player.sendMessage(new TextComponentString("Quarry marker square is ambiguous - multiple markers found at (" + a[1] + "," + a[3] + ") and (" + test_forward[1] + "," + test_forward[3] + ")"));
|
|
}
|
|
if (((offsetX == 0) && (a[3] == test[3])) || ((offsetZ == 0) && (a[1] == test[1])))
|
|
{
|
|
if (test_side == null)
|
|
test_side = a;
|
|
else if (!isIntEqual(a, test_side))
|
|
player.sendMessage(new TextComponentString("Quarry marker square is ambiguous - multiple markers found at (" + a[1] + "," + a[3] + ") and (" + test_side[1] + "," + test_side[3] + ")"));
|
|
}
|
|
}
|
|
}
|
|
if (test_forward == null)
|
|
{
|
|
player.sendMessage(new TextComponentString("Quarry marker square is incomplete"));
|
|
return false;
|
|
}
|
|
if (test_side == null)
|
|
{
|
|
player.sendMessage(new TextComponentString("Quarry marker square is incomplete"));
|
|
return false;
|
|
}
|
|
int amin_x = Math.min(Math.min(test[1], test_forward[1]), test_side[1]);
|
|
int amax_x = Math.max(Math.max(test[1], test_forward[1]), test_side[1]);
|
|
int amin_z = Math.min(Math.min(test[3], test_forward[3]), test_side[3]);
|
|
int amax_z = Math.max(Math.max(test[3], test_forward[3]), test_side[3]);
|
|
if ((amax_x - amin_x <= 2) || (amax_z - amin_z <= 2))
|
|
{
|
|
player.sendMessage(new TextComponentString("Region created by ender markers is too small"));
|
|
return false;
|
|
}
|
|
player.sendMessage(new TextComponentString("Sucessfully established boundary"));
|
|
|
|
chunk_y = this.getPos().getY();
|
|
min_x = amin_x;
|
|
max_x = amax_x;
|
|
min_z = amin_z;
|
|
max_z = amax_z;
|
|
|
|
startDig();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static boolean isIntEqual(int[] a, int[] b)
|
|
{
|
|
if (a == b)
|
|
return true;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (a[i] != b[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static int sign(int d)
|
|
{
|
|
if (d == 0)
|
|
return 0;
|
|
if (d > 0)
|
|
return 1;
|
|
return -1;
|
|
}
|
|
|
|
public void startDig()
|
|
{
|
|
System.out.println("Ender quarry started digging at (" + min_x + ", " + min_z + "), (" + max_x + ", " + max_z + ")");
|
|
|
|
this.started = true;
|
|
//this.chunk_y = yCoord;
|
|
this.chunk_x = (this.min_x + 1 >> 4);
|
|
this.chunk_z = (this.min_z + 1 >> 4);
|
|
this.dx = Math.max(0, this.min_x + 1 - (this.chunk_x << 4));
|
|
this.dy = this.chunk_y;
|
|
this.dz = Math.max(0, this.min_z + 1 - (this.chunk_z << 4));
|
|
if (!stopHere())
|
|
nextBlock();
|
|
|
|
}
|
|
|
|
@Override
|
|
public void update()
|
|
{
|
|
xCoord = this.getPos().getX();
|
|
yCoord = this.getPos().getY();
|
|
zCoord = this.getPos().getZ();
|
|
|
|
if(this.world.isRemote)
|
|
return;
|
|
if(config == -1)
|
|
checkSurroundings();
|
|
|
|
if (!started || finished)
|
|
return;
|
|
|
|
if (chunkTicket == null)
|
|
{
|
|
chunkTicket = ForgeChunkManager.requestTicket(EnderQuarryMod.instance, this.world, ForgeChunkManager.Type.NORMAL);
|
|
if (chunkTicket == null)
|
|
{
|
|
if (owner != null)
|
|
owner.sendMessage(new TextComponentString("Problem registering chunk-preserving method"));
|
|
this.finished = true;
|
|
return;
|
|
}
|
|
chunkTicket.getModData().setString("id", "quarry");
|
|
chunkTicket.getModData().setInteger("x", xCoord);
|
|
chunkTicket.getModData().setInteger("y", yCoord);
|
|
chunkTicket.getModData().setInteger("z", zCoord);
|
|
|
|
ForgeChunkManager.forceChunk(chunkTicket, new ChunkPos(xCoord, zCoord));
|
|
|
|
loadChunk();
|
|
}
|
|
|
|
int nr = getSpeedStack(); //operations per tick
|
|
for (int k = 0; k < nr; k++)
|
|
{
|
|
if (hasRedstoneSignal() || (!items.isEmpty()) || (tank.getFluid() != null && tank.getFluidAmount() > 31000))
|
|
{
|
|
}
|
|
|
|
else if (energy.getEnergyStored() >= neededEnergy && energy.extractEnergy(baseDrain, true) == baseDrain)
|
|
{
|
|
int x = (chunk_x << 4) + dx;
|
|
int z = (chunk_z << 4) + dz;
|
|
int y = dy;
|
|
if (y >= 0)
|
|
{
|
|
if (mineBlock(x, y, z, upgrades[1] == false))
|
|
{
|
|
this.neededEnergy = -1;
|
|
nextBlock();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nextBlock();
|
|
}
|
|
}
|
|
|
|
if (!items.isEmpty() && config > 0)
|
|
{
|
|
BlockPos thisBlockPos = this.getPos();
|
|
for (EnumFacing face : EnumFacing.values())
|
|
{
|
|
BlockPos vecin = thisBlockPos.offset(face);
|
|
TileEntity tile = this.world.getTileEntity(vecin);
|
|
if(tile != null && tile.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, face.getOpposite())) //am gasit un cufar sau cv
|
|
{
|
|
//System.out.println("Trying to put item at: " + vecin.getX() + ", " + vecin.getY() + ", " + vecin.getZ());
|
|
IItemHandler itemhandler = tile.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, face.getOpposite());
|
|
for(int i = 0; i < items.size(); ++i)
|
|
{
|
|
ItemStack remainder = ItemHandlerHelper.insertItemStacked(itemhandler, (ItemStack)items.get(i), false);
|
|
if(remainder.isEmpty())
|
|
{
|
|
items.remove(i);
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (tank.getFluid() != null && tank.getFluidAmount() > 0 && config > 0)
|
|
{
|
|
BlockPos thisBlockPos = this.getPos();
|
|
for (EnumFacing face : EnumFacing.values())
|
|
{
|
|
BlockPos vecin = thisBlockPos.offset(face);
|
|
TileEntity tile = this.world.getTileEntity(vecin);
|
|
if(tile != null && tile.hasCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, face.getOpposite()))
|
|
{
|
|
IFluidHandler handler = tile.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY, face.getOpposite());
|
|
tank.drain(handler.fill(tank.getFluid(), true), true);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean mineBlock(int x, int y, int z, boolean replaceWithDirt)
|
|
{
|
|
BlockPos miningPos = new BlockPos (x, y, z);
|
|
IFluidHandler handler = null;
|
|
|
|
IBlockState toBeMinedState = this.world.getBlockState(miningPos);
|
|
Block toBeMined = toBeMinedState.getBlock();
|
|
|
|
if (this.world.isAirBlock(miningPos))
|
|
return true;
|
|
|
|
if (toBeMined instanceof BlockLiquid)
|
|
handler = new BlockLiquidWrapper((BlockLiquid) toBeMined, this.world, miningPos);
|
|
else if (toBeMined instanceof IFluidBlock) {
|
|
handler = new FluidBlockWrapper((IFluidBlock) toBeMined, this.world, miningPos);
|
|
}
|
|
|
|
if (handler != null) //fluid block
|
|
{
|
|
if(upgrades[9])
|
|
{
|
|
FluidStack drained = handler.drain(16000, false);
|
|
|
|
if (drained != null && tank.fillInternal(drained, false) == drained.amount)
|
|
{
|
|
tank.fillInternal(handler.drain(16000, true), true);
|
|
world.setBlockState(miningPos, Blocks.AIR.getDefaultState());
|
|
//System.out.println("Draining " + drained.amount + " from " + x + ", " + y + ", " + z);
|
|
return true;
|
|
}
|
|
//if(drained != null)
|
|
//System.out.println("DEBUG: draining failed: " + toBeMined.getLocalizedName() + " " + drained.getLocalizedName() + " " + drained.amount);
|
|
//else
|
|
if(drained == null)
|
|
{
|
|
System.out.println("WARNING: Draining block at " + x + ", " + y + ", " + z + " - " + toBeMined.getLocalizedName() + " returned null! Skipping!");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
|
|
if(toBeMined == Blocks.BEDROCK)
|
|
return true;
|
|
|
|
if (replaceWithDirt && (toBeMined.isLeaves(toBeMinedState, this.world, miningPos) || toBeMined.isFoliage(this.world, miningPos) || toBeMined.isWood(this.world, miningPos) || (toBeMined instanceof IPlantable) || (toBeMined instanceof IGrowable)))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
int meta = toBeMined.getMetaFromState(toBeMinedState);
|
|
float hardness = toBeMinedState.getBlockHardness(this.world, miningPos);
|
|
|
|
|
|
if (hardness < 0.0F)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
int amount = (int)Math.ceil(baseDrain + hardness * hardnessDrain * getPowerMultiplier()); //cat RF o sa consume pentru acest block
|
|
if (amount > this.energy.getMaxEnergyStored())
|
|
{
|
|
amount = this.energy.getMaxEnergyStored();
|
|
}
|
|
|
|
if (this.energy.extractEnergy(amount, true) < amount)
|
|
{
|
|
this.neededEnergy = amount;
|
|
return false;
|
|
}
|
|
this.energy.extractEnergy(amount, false);
|
|
|
|
if(toBeMined == Blocks.GRASS && this.world.canSeeSky(miningPos))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return harvestBlock(toBeMinedState, miningPos, meta, replaceWithDirt, getDigType());
|
|
}
|
|
|
|
public boolean harvestBlock(IBlockState toBeMinedState, BlockPos miningPos, int meta, boolean replaceWithDirt, DigType digType)
|
|
{
|
|
Block toBeMined = toBeMinedState.getBlock();
|
|
boolean isOpaque = toBeMinedState.isOpaqueCube();
|
|
FakePlayer fakePlayer = FakePlayerFactory.getMinecraft((WorldServer) this.world);
|
|
fakePlayer.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, digType.newStack(Items.DIAMOND_PICKAXE));
|
|
try
|
|
{
|
|
boolean flag;
|
|
|
|
//check if item has inventory storage capability
|
|
//if so, extract items
|
|
TileEntity tile = this.world.getTileEntity(miningPos);
|
|
System.out.println("Tile at " + miningPos + ": " + tile);
|
|
if(tile != null && tile.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, EnumFacing.UP))
|
|
{
|
|
System.out.println("Found inventory containing tile at " + miningPos);
|
|
}
|
|
|
|
Object i = new ArrayList();
|
|
if ((digType.isSilkTouch()) && (toBeMined.canSilkHarvest(this.world, miningPos, toBeMinedState, fakePlayer)))
|
|
{
|
|
int j = 0;
|
|
Item item = Item.getItemFromBlock(toBeMined);
|
|
if (item != null)
|
|
{
|
|
if (item.getHasSubtypes())
|
|
j = meta;
|
|
ItemStack itemstack = new ItemStack(item, 1, j);
|
|
((ArrayList)i).add(itemstack);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
((ArrayList)i).addAll(toBeMined.getDrops(this.world, miningPos, toBeMinedState, digType.getFortuneModifier()));
|
|
|
|
}
|
|
float p = ForgeEventFactory.fireBlockHarvesting((ArrayList)i, this.world, miningPos, toBeMinedState, digType.getFortuneModifier(), 1.0F, digType.isSilkTouch(), fakePlayer);
|
|
if ((p > 0.0F) && (!((ArrayList)i).isEmpty()) && ((p == 1.0F) || (rand.nextFloat() < p)))
|
|
this.items.addAll((Collection)i);
|
|
|
|
if(replaceWithDirt)
|
|
{
|
|
if(toBeMined != Blocks.DIRT)
|
|
flag = this.world.setBlockState(miningPos, Blocks.DIRT.getDefaultState());
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
flag = this.world.setBlockState(miningPos, Blocks.AIR.getDefaultState());
|
|
|
|
if (!flag)
|
|
{
|
|
System.out.println("Error in setting block at mining pos!");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
finally
|
|
{
|
|
fakePlayer.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, new ItemStack(Blocks.DIRT));
|
|
}
|
|
|
|
}
|
|
|
|
private DigType getDigType()
|
|
{
|
|
if (this.upgrades[2] == true)
|
|
return DigType.SILK;
|
|
|
|
if (this.upgrades[3] == true)
|
|
return DigType.FORTUNE;
|
|
|
|
if (this.upgrades[4] == true)
|
|
return DigType.FORTUNE2;
|
|
|
|
if (this.upgrades[5] == true)
|
|
return DigType.FORTUNE3;
|
|
|
|
return DigType.NORMAL;
|
|
}
|
|
|
|
public void nextBlock()
|
|
{
|
|
nextSubBlock();
|
|
while (!stopHere())
|
|
nextSubBlock();
|
|
}
|
|
|
|
public void nextSubBlock()
|
|
{
|
|
this.progress += 1L;
|
|
this.dy -= 1;
|
|
if (this.dy <= 0)
|
|
{
|
|
this.dx += 1;
|
|
if ((this.dx >= 16) || ((this.chunk_x << 4) + this.dx >= this.max_x))
|
|
{
|
|
this.dx = Math.max(0, this.min_x + 1 - (this.chunk_x << 4));
|
|
this.dz += 1;
|
|
if ((this.dz >= 16) || ((this.chunk_z << 4) + this.dz >= this.max_z))
|
|
{
|
|
nextChunk();
|
|
this.dx = Math.max(0, this.min_x + 1 - (this.chunk_x << 4));
|
|
this.dz = Math.max(0, this.min_z + 1 - (this.chunk_z << 4));
|
|
}
|
|
}
|
|
this.dy = this.chunk_y;
|
|
}
|
|
}
|
|
|
|
public void nextChunk()
|
|
{
|
|
unloadChunk();
|
|
this.chunk_x += 1;
|
|
if (this.chunk_x << 4 >= this.max_x)
|
|
{
|
|
this.chunk_x = (this.min_x + 1 >> 4);
|
|
this.chunk_z += 1;
|
|
if (this.chunk_z << 4 >= this.max_z)
|
|
{
|
|
this.finished = true;
|
|
//this.world.setBlockMetadataWithNotify(this.xCoord, this.yCoord, this.zCoord, 2, 2);
|
|
ForgeChunkManager.releaseTicket(this.chunkTicket);
|
|
return;
|
|
}
|
|
}
|
|
this.dy = this.chunk_y;
|
|
loadChunk();
|
|
}
|
|
|
|
public boolean stopHere()
|
|
{
|
|
return (this.finished) || (isValid((this.chunk_x << 4) + this.dx, (this.chunk_z << 4) + this.dz));
|
|
}
|
|
|
|
private boolean isValid(int x, int z)
|
|
{
|
|
return (this.min_x < x) && (x < this.max_x) && (this.min_z < z) && (z < this.max_z);
|
|
}
|
|
|
|
private double getPowerMultiplier()
|
|
{
|
|
double multiplier = 1.0D;
|
|
for (int i = 0; i < 16; i++)
|
|
{
|
|
if (upgrades[i])
|
|
multiplier *= powerMultipliers[i];
|
|
}
|
|
return multiplier;
|
|
}
|
|
|
|
private int getSpeedStack()
|
|
{
|
|
if (upgrades[6])
|
|
return 1;
|
|
|
|
if (upgrades[7])
|
|
return 3;
|
|
|
|
if (upgrades[8])
|
|
return 9;
|
|
|
|
return 1;
|
|
}
|
|
|
|
private void loadChunk()
|
|
{
|
|
|
|
ChunkPos base = new ChunkPos(xCoord, zCoord);
|
|
if(base.x != chunk_x || base.z != chunk_z)
|
|
ForgeChunkManager.forceChunk(chunkTicket, new ChunkPos(chunk_x, chunk_z));
|
|
|
|
}
|
|
|
|
private void unloadChunk()
|
|
{
|
|
ChunkPos base = new ChunkPos(xCoord, zCoord);
|
|
if(base.x != chunk_x || base.z != chunk_z)
|
|
ForgeChunkManager.unforceChunk(chunkTicket, new ChunkPos(chunk_x, chunk_z)); //ne asiguram ca nu stergem din ram chunkul in care e ender quarry
|
|
}
|
|
|
|
public void checkSurroundings()
|
|
{
|
|
config = 1;
|
|
for(int i = 0; i <= 10; ++i)
|
|
upgrades[i] = false;
|
|
|
|
BlockPos thisBlockPos = this.getPos();
|
|
for (EnumFacing face : EnumFacing.values())
|
|
{
|
|
BlockPos vecin = thisBlockPos.offset(face);
|
|
if (world.getBlockState(vecin).getBlock() instanceof UpgradeBlock)
|
|
{
|
|
upgrades[((UpgradeBlock)world.getBlockState(vecin).getBlock()).upgradeType] = true;
|
|
//System.out.println("Found an upgrade of type " + ((UpgradeBlock)world.getBlockState(vecin).getBlock()).upgradeType);
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean hasRedstoneSignal()
|
|
{
|
|
for (EnumFacing enumfacing : EnumFacing.values())
|
|
{
|
|
if (world.isSidePowered(pos.offset(enumfacing), enumfacing))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (world.isSidePowered(pos, EnumFacing.DOWN))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
BlockPos blockpos = pos.up();
|
|
|
|
for (EnumFacing enumfacing1 : EnumFacing.values())
|
|
{
|
|
if (enumfacing1 != EnumFacing.DOWN && world.isSidePowered(blockpos.offset(enumfacing1), enumfacing1))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public int invInsert(IItemHandler itemhandler, ItemStack toBeInserted)
|
|
{
|
|
for(int i = 0; i < itemhandler.getSlots(); ++i)
|
|
{
|
|
ItemStack cur = itemhandler.getStackInSlot(i);
|
|
if(cur.isEmpty())
|
|
{
|
|
itemhandler.insertItem(i, toBeInserted, false);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if(ItemStack.areItemsEqual(toBeInserted, cur))
|
|
{
|
|
if(cur.getCount() == cur.getMaxStackSize())
|
|
continue;
|
|
if(cur.getCount() + toBeInserted.getCount() <= cur.getMaxStackSize())
|
|
{
|
|
itemhandler.insertItem(i, toBeInserted, false);
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
int ammount = cur.getMaxStackSize() - cur.getCount();
|
|
ItemStack remainder = toBeInserted;
|
|
remainder.shrink(ammount);
|
|
toBeInserted.setCount(ammount);
|
|
items.add(remainder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static enum DigType
|
|
{
|
|
NORMAL(null, 0), SILK(Enchantments.SILK_TOUCH, 1), FORTUNE(Enchantments.FORTUNE, 1), FORTUNE2(Enchantments.FORTUNE, 2), FORTUNE3(Enchantments.FORTUNE, 3), SPEED(Enchantments.EFFICIENCY, 1), SPEED2(Enchantments.EFFICIENCY, 3), SPEED3(Enchantments.EFFICIENCY, 5);
|
|
|
|
public Enchantment ench;
|
|
public int level;
|
|
|
|
private DigType(Enchantment ench, int level)
|
|
{
|
|
this.ench = ench;
|
|
this.level = level;
|
|
}
|
|
|
|
public int getFortuneModifier()
|
|
{
|
|
if (this.ench == Enchantments.FORTUNE)
|
|
return this.level;
|
|
return 0;
|
|
}
|
|
|
|
public ItemStack newStack(Item pick)
|
|
{
|
|
ItemStack stack = new ItemStack(pick);
|
|
if (ench != null)
|
|
stack.addEnchantment(this.ench, this.level);
|
|
return stack;
|
|
}
|
|
|
|
public boolean isSilkTouch()
|
|
{
|
|
return this.ench == Enchantments.SILK_TOUCH;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCapability(Capability<?> capability, EnumFacing facing)
|
|
{
|
|
if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
|
|
return true;
|
|
if(capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
|
|
return true;
|
|
if(capability == CapabilityEnergy.ENERGY)
|
|
return true;
|
|
return super.hasCapability(capability, facing);
|
|
}
|
|
|
|
@Override
|
|
public <T> T getCapability(Capability<T> capability, EnumFacing facing)
|
|
{
|
|
if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
|
|
return (T) this;
|
|
if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY)
|
|
return (T) tank;
|
|
if (capability == CapabilityEnergy.ENERGY)
|
|
return (T) energy;
|
|
|
|
return super.getCapability(capability, facing);
|
|
}
|
|
|
|
//useless stuff so pipes connect to quarry
|
|
@Override
|
|
public int getSlots()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int slot)
|
|
{
|
|
if(slot != 0)
|
|
return ItemStack.EMPTY;
|
|
|
|
for(int i = 0; i < items.size(); ++i)
|
|
return (ItemStack)items.get(i);
|
|
|
|
return ItemStack.EMPTY;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack insertItem(int slot, ItemStack stack, boolean simulate) {
|
|
return stack;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack extractItem(int slot, int amount, boolean simulate)
|
|
{
|
|
ItemStack eject;
|
|
for(int i = 0; i < items.size(); ++i)
|
|
{
|
|
eject = (ItemStack)items.get(i);
|
|
if(simulate == false)
|
|
{
|
|
items.remove(i);
|
|
--i;
|
|
}
|
|
return eject;
|
|
}
|
|
return ItemStack.EMPTY;
|
|
}
|
|
|
|
@Override
|
|
public int getSlotLimit(int slot)
|
|
{
|
|
ItemStack firstStack;
|
|
for(int i = 0; i < items.size(); ++i)
|
|
{
|
|
firstStack = (ItemStack)items.get(i);
|
|
return firstStack.getMaxStackSize();
|
|
}
|
|
return 64;
|
|
}
|
|
|
|
}
|