@Override
public Object getServerGuiElement(int id, EntityPlayer player, World world, int x, int y, int z) {
if (!world.blockExists(x, y, z)) {
return null;
}
TileEntity tile = world.getTileEntity(x, y, z);
switch (id) {
case 0:
if (!(tile instanceof TileAssemblyTable)) {
return null;
} else {
return new ContainerAssemblyTable(player.inventory, (TileAssemblyTable) tile);
}
case 1:
if (!(tile instanceof TileAdvancedCraftingTable)) {
return null;
} else {
return new ContainerAdvancedCraftingTable(
player.inventory, (TileAdvancedCraftingTable) tile);
}
case 2:
if (!(tile instanceof TileIntegrationTable)) {
return null;
} else {
return new ContainerIntegrationTable(player.inventory, (TileIntegrationTable) tile);
}
default:
return null;
}
}
public void handlePacket(Packet250CustomPayload packet) throws IOException {
DataInputStream dis = new DataInputStream(new ByteArrayInputStream(packet.data));
byte type = dis.readByte();
World world = net.minecraft.client.Minecraft.getMinecraft().theWorld;
ISyncHandler handler = null;
if (type == TYPE_TILE) {
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
if (world != null) {
if (world.blockExists(x, y, z)) {
TileEntity tile = world.getBlockTileEntity(x, y, z);
if (tile instanceof ISyncHandler) {
handler = (ISyncHandler) tile;
}
}
}
} else if (type == TYPE_ENTITY) {
int entityId = dis.readInt();
Entity entity = world.getEntityByID(entityId);
if (entity != null && entity instanceof ISyncHandler) {
handler = (ISyncHandler) entity;
}
}
if (handler != null) {
List<ISyncableObject> changes = handler.getSyncMap().readFromStream(dis);
handler.onSynced(changes);
}
dis.close();
}
public boolean generate(World world, Random random, int x, int y, int z) {
if (!world.blockExists(x, y, z)) {
return false;
}
int i = y;
while (world.getBlock(x, i, z) != Blocks.stone) {
if (i > 96) return false; // Don't generate marble over y96
i++;
addBlock(x, i, z, 6);
}
while ((this.marbleVein.size() > 0) && (this.numberOfBlocks > 0)) {
List blocksToGenerate = (List) this.marbleVein.removeFirst();
Integer[] blockToSet = (Integer[]) blocksToGenerate.toArray();
if (world.getBlock(blockToSet[0], blockToSet[1], blockToSet[2]) == Blocks.stone) {
world.setBlock(blockToSet[0], blockToSet[1], blockToSet[2], this.block);
if (blockToSet[3] > 0) {
searchBlock(world, blockToSet[0], blockToSet[1], blockToSet[2], blockToSet[3] - 1);
}
this.numberOfBlocks -= 1;
}
}
return true;
}
public static void unpath(World world, int i, int j, int k) {
List<ChunkCoordinates> blocks = Lists.newLinkedList();
List<ChunkCoordinates> notify = Lists.newLinkedList();
blocks.add(new ChunkCoordinates(i, j, k));
while (blocks.size() > 0) {
ChunkCoordinates coords = blocks.remove(0);
depolarize(world, coords.posX + 1, coords.posY, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY + 1, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY, coords.posZ + 1, blocks);
depolarize(world, coords.posX - 1, coords.posY, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY - 1, coords.posZ, blocks);
depolarize(world, coords.posX, coords.posY, coords.posZ - 1, blocks);
notify.add(coords);
}
for (ChunkCoordinates coords : notify) {
if (world.blockExists(coords.posX, coords.posY, coords.posZ)) {
world.markBlockForUpdate(coords.posX, coords.posY, coords.posZ);
world.notifyBlocksOfNeighborChange(
coords.posX,
coords.posY,
coords.posZ,
world.getBlock(coords.posX, coords.posY, coords.posZ));
}
}
}
/* Safe Tile Entity Retrieval */
public static TileEntity getAdjacentTileEntity(
World world, int x, int y, int z, ForgeDirection dir) {
x += dir.offsetX;
y += dir.offsetY;
z += dir.offsetZ;
return world == null || !world.blockExists(x, y, z) ? null : world.getTileEntity(x, y, z);
}
@Override
public void onBlockDestroyedByPlayer(World world, int x, int y, int z, int metaData) {
if (!world.isRemote) {
if (world.blockExists(x, y - 1, z)) {
world.setBlock(x, y - 1, z, Blocks.air);
}
}
}
public void activate(Vector3f pos) {
if (_world.blockExists((int) pos.getX(), (int) pos.getY(), (int) pos.getZ())) {
Block blk =
Block.blocksList[_world.getBlockId((int) pos.getX(), (int) pos.getY(), (int) pos.getZ())];
blk.onBlockActivated(
_world, (int) pos.getX(), (int) pos.getY(), (int) pos.getZ(), _player, 0, 0, 0, 0);
}
}
private void setBlocks(World par1World, int x, int y, int z, boolean item, int blockid) {
if (par1World.blockExists(x, y, z)) {
if (par1World.getBlockId(x, y, z) != blockid) {
par1World.destroyBlock(x, y, z, item);
}
par1World.setBlock(x, y, z, blockid);
}
}
@Override
public void processCommand(ICommandSender icommandsender, String[] astring) {
ArrayList<ChunkCoordinates> ccListsb = new ArrayList<ChunkCoordinates>();
ArrayList<ChunkCoordinates> ccListdb = new ArrayList<ChunkCoordinates>();
boolean sameBiome;
int offset = 1;
ChunkCoordinates cc = icommandsender.getPlayerCoordinates();
EntityPlayerMP player = getCommandSenderAsPlayer(icommandsender);
World w = player.worldObj;
BiomeGenBase bg = w.getBiomeGenForCoords(cc.posX, cc.posZ);
sameBiome = true;
int olddb, newdb;
newdb = 0;
while (sameBiome == true) {
olddb = newdb;
for (int i = -offset; i <= offset; i++) {
for (int j = -offset; j <= offset; j++) {
if (w.getBiomeGenForCoords(cc.posX + i, cc.posZ + j) == bg) {
ccListsb.add(new ChunkCoordinates(cc.posX + i, 0, cc.posZ + j));
} else {
ccListdb.add(new ChunkCoordinates(cc.posX + i, 0, cc.posZ + j));
}
}
}
newdb = ccListdb.size();
if ((newdb - olddb >= offset * 8 || offset == 512)) {
System.out.println("" + ccListsb.size());
sameBiome = false;
} else {
ccListdb.clear();
ccListsb.clear();
}
offset++;
}
for (int j = 0; j < ccListsb.size(); j++) {
for (int i = 0; i < 256; i++) {
if (w.blockExists(ccListsb.get(j).posX, i, ccListsb.get(j).posZ))
w.destroyBlock(ccListsb.get(j).posX, i, ccListsb.get(j).posZ, false);
}
}
System.out.println("Done");
}
private static void pathto(World world, int i, int j, int k) {
List<ChunkCoordinates> blocks = Lists.newLinkedList();
List<ChunkCoordinates> portals = Lists.newLinkedList();
List<ChunkCoordinates> repath = Lists.newLinkedList();
List<ChunkCoordinates> redraw = Lists.newLinkedList();
blocks.add(new ChunkCoordinates(i, j, k));
while ((portals.size() > 0) || (blocks.size() > 0)) {
while (blocks.size() > 0) {
ChunkCoordinates coords = blocks.remove(0);
directPortal(world, coords.posX + 1, coords.posY, coords.posZ, 5, blocks, portals);
directPortal(world, coords.posX, coords.posY + 1, coords.posZ, 1, blocks, portals);
directPortal(world, coords.posX, coords.posY, coords.posZ + 1, 3, blocks, portals);
directPortal(world, coords.posX - 1, coords.posY, coords.posZ, 6, blocks, portals);
directPortal(world, coords.posX, coords.posY - 1, coords.posZ, 2, blocks, portals);
directPortal(world, coords.posX, coords.posY, coords.posZ - 1, 4, blocks, portals);
redraw.add(coords);
}
if (portals.size() > 0) {
ChunkCoordinates coords = portals.remove(0);
directPortal(world, coords.posX + 1, coords.posY, coords.posZ, 5, blocks, portals);
directPortal(world, coords.posX, coords.posY + 1, coords.posZ, 1, blocks, portals);
directPortal(world, coords.posX, coords.posY, coords.posZ + 1, 3, blocks, portals);
directPortal(world, coords.posX - 1, coords.posY, coords.posZ, 6, blocks, portals);
directPortal(world, coords.posX, coords.posY - 1, coords.posZ, 2, blocks, portals);
directPortal(world, coords.posX, coords.posY, coords.posZ - 1, 4, blocks, portals);
if (world.getBlock(coords.posX, coords.posY, coords.posZ) == NailedBlocks.portal) {
repath.add(coords);
}
}
}
while (repath.size() > 0) {
ChunkCoordinates coords = repath.remove(0);
if (world.getBlock(coords.posX, coords.posY, coords.posZ) == NailedBlocks.portal) {
if (!BlockPortal.isValidPortal(world, coords.posX, coords.posY, coords.posZ)) {
repathNeighbors(world, coords.posX, coords.posY, coords.posZ);
world.setBlock(coords.posX, coords.posY, coords.posZ, Blocks.air, 0, 0);
addSurrounding(repath, coords.posX, coords.posY, coords.posZ);
} else {
redraw.add(coords);
}
}
}
for (ChunkCoordinates coords : redraw) {
if (world.blockExists(coords.posX, coords.posY, coords.posZ)) {
world.markBlockForUpdate(coords.posX, coords.posY, coords.posZ);
world.notifyBlocksOfNeighborChange(
coords.posX,
coords.posY,
coords.posZ,
world.getBlock(coords.posX, coords.posY, coords.posZ));
}
}
}
private void breakBlocks(World par1World, int x, int y, int z, boolean item) {
if (par1World.blockExists(x, y, z)) {
if (par1World.getBlockId(x, y, z) == SpacecraftBlocks.caravanModulePart.blockID
|| par1World.getBlockId(x, y, z) == GCCoreBlocks.glowstoneTorch.blockID
|| par1World.getBlockId(x, y, z) == Block.furnaceBurning.blockID
|| par1World.getBlockId(x, y, z) == Block.furnaceIdle.blockID
|| par1World.getBlockId(x, y, z) == Block.chest.blockID
|| par1World.getBlockId(x, y, z) == Block.workbench.blockID) {
par1World.destroyBlock(x, y, z, item);
}
}
}
@Override
public Object getClientGuiElement(int id, EntityPlayer player, World world, int x, int y, int z) {
switch (id) {
case 0:
case 1:
break;
case 2:
return new GuiContainerBasic(new ContainerItemShield(player), prefix + "shield");
case 3:
return new GuiItemTeleporter(player);
case 4:
return new GuiItemFloater(player);
case 5:
return new GuiContainerBasic(new ContainerItemFilter(player), prefix + "filterItem");
case 6:
return new GuiItemFilterInstaller(player);
case 7:
return new GuiContainerBasic(new ContainerItemCollector(player), prefix + "collector");
}
if (!world.blockExists(x, y, z)) return null;
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (tileEntity instanceof TileEntitySmeltingMachine)
return new GuiSmeltingMachine(player, (TileEntitySmeltingMachine) tileEntity);
if (tileEntity instanceof TileEntityRepairingMachine)
return new GuiRepairingMachine(player, (TileEntityRepairingMachine) tileEntity);
if (tileEntity instanceof TileEntityConvertingMachine)
return new GuiConvertingMachine(player, (TileEntityConvertingMachine) tileEntity);
if (tileEntity instanceof TileEntityFusingMachine)
return new GuiFusingMachine(player, (TileEntityFusingMachine) tileEntity);
if (tileEntity instanceof TileEntityTeleportingMarker)
return new GuiTeleportingMarker(player, (TileEntityTeleportingMarker) tileEntity);
if (tileEntity instanceof TileEntityPresentBox)
return new GuiPresentBox(player, (TileEntityPresentBox) tileEntity);
if (id == 1) {
if (tileEntity instanceof TileEntityPlacer)
return new GuiWorldEditorBase.GuiPlacer(player, (TileEntityPlacer) tileEntity);
if (tileEntity instanceof TileEntityCollector)
return new GuiWorldEditorBase.GuiCollector(player, (TileEntityCollector) tileEntity);
if (tileEntity instanceof TileEntityWorldEditorBase)
return new GuiWorldEditorBase(player, (TileEntityWorldEditorBase) tileEntity);
} else if (id == 0) {
if (tileEntity instanceof TileEntityWorldEditorBase)
return new GuiSettingWorldEditorBase((TileEntityWorldEditorBase) tileEntity);
}
return null;
}
public void processPacket211(Packet211TileDesc var1, NetHandler var2) {
if (var2 instanceof NetClientHandler) {
NetClientHandler var3 = (NetClientHandler) var2;
World var4 = var3.getPlayer().worldObj;
if (var4.blockExists(var1.xCoord, var1.yCoord, var1.zCoord)) {
TileEntity var5 = var4.getBlockTileEntity(var1.xCoord, var1.yCoord, var1.zCoord);
if (var5 instanceof IHandlePackets) {
((IHandlePackets) var5).handlePacket(var1);
return;
}
}
} else {
super.processPacket211(var1, var2);
}
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
if (!world.blockExists(x, y, z)) return null;
TileEntity tile = world.getBlockTileEntity(x, y, z);
switch (ID) {
case 0:
if (!(tile instanceof TileAssemblyTable)) return null;
return new GuiAssemblyTable(player.inventory, (TileAssemblyTable) tile);
case 1:
if (!(tile instanceof TileAdvancedCraftingTable)) return null;
return new GuiAdvancedCraftingTable(player.inventory, (TileAdvancedCraftingTable) tile);
default:
return null;
}
}
public static IImmersiveConnectable toIIC(Object object, World world) {
if (object instanceof IImmersiveConnectable) return (IImmersiveConnectable) object;
else if (object instanceof ChunkCoordinates
&& world != null
&& world.blockExists(
((ChunkCoordinates) object).posX,
((ChunkCoordinates) object).posY,
((ChunkCoordinates) object).posZ)
&& world.getTileEntity(
((ChunkCoordinates) object).posX,
((ChunkCoordinates) object).posY,
((ChunkCoordinates) object).posZ)
instanceof IImmersiveConnectable) {
return (IImmersiveConnectable)
world.getTileEntity(
((ChunkCoordinates) object).posX,
((ChunkCoordinates) object).posY,
((ChunkCoordinates) object).posZ);
}
return null;
}
/** Refresh validity of each conductor in the network */
public void refreshWithChecks() {
int tierfound = 2;
Iterator<IConductor> it = this.conductors.iterator();
while (it.hasNext()) {
IConductor conductor = it.next();
if (conductor == null) {
it.remove();
continue;
}
TileEntity tile = (TileEntity) conductor;
World world = tile.getWorldObj();
// Remove any conductors in unloaded chunks
if (tile.isInvalid()
|| world == null
|| !world.blockExists(tile.xCoord, tile.yCoord, tile.zCoord)) {
it.remove();
continue;
}
if (conductor != world.getTileEntity(tile.xCoord, tile.yCoord, tile.zCoord)) {
it.remove();
continue;
}
if (conductor.getTierGC() < 2) {
tierfound = 1;
}
if (conductor.getNetwork() != this) {
conductor.setNetwork(this);
conductor.onNetworkChanged();
}
}
// This will set the network tier to 2 if all the conductors are tier 2
this.networkTierGC = tierfound;
}
public boolean remove() {
if (!world.blockExists(x, y, z)) return false;
if (spawnProtection) {
if (!world.canMineBlock(player, x, y, z)) return false;
}
if (eventCheck) {
final Block block = world.getBlock(x, y, z);
final int meta = world.getBlockMetadata(x, y, z);
BlockEvent.BreakEvent event = new BlockEvent.BreakEvent(x, y, z, world, block, meta, player);
event.setExpToDrop(0);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled()) return false;
}
if (silentTeRemove) world.removeTileEntity(x, y, z);
return world.setBlockToAir(x, y, z);
}
public boolean place(Block block, int meta) {
if (!world.blockExists(x, y, z)) return false;
if (spawnProtection) {
if (!world.canMineBlock(player, x, y, z)) return false;
}
final BlockSnapshot snapshot =
net.minecraftforge.common.util.BlockSnapshot.getBlockSnapshot(world, x, y, z);
if (!world.setBlock(x, y, z, block, meta, blockPlaceFlags)) return false;
if (ForgeEventFactory.onPlayerBlockPlace(
player, snapshot, net.minecraftforge.common.util.ForgeDirection.UNKNOWN)
.isCanceled()) {
world.restoringBlockSnapshots = true;
snapshot.restore(true, false);
world.restoringBlockSnapshots = false;
return false;
}
return true;
}
private void breakBlocksOther(World par1World, int x, int y, int z, boolean item) {
if (par1World.blockExists(x, y, z)) {
par1World.destroyBlock(x, y, z, item);
}
}
public void processCommand(ICommandSender par1ICommandSender, String[] par2ArrayOfStr) {
if (par2ArrayOfStr.length >= 1) {
String var3 = par2ArrayOfStr[0];
double var4 = (double) par1ICommandSender.getCommandSenderPosition().posX + 0.5D;
double var6 = (double) par1ICommandSender.getCommandSenderPosition().posY;
double var8 = (double) par1ICommandSender.getCommandSenderPosition().posZ + 0.5D;
if (par2ArrayOfStr.length >= 4) {
var4 = func_110666_a(par1ICommandSender, var4, par2ArrayOfStr[1]);
var6 = func_110666_a(par1ICommandSender, var6, par2ArrayOfStr[2]);
var8 = func_110666_a(par1ICommandSender, var8, par2ArrayOfStr[3]);
}
World var10 = par1ICommandSender.getEntityWorld();
if (!var10.blockExists((int) var4, (int) var6, (int) var8)) {
notifyAdmins(par1ICommandSender, "commands.summon.outOfWorld", new Object[0]);
} else {
NBTTagCompound var11 = new NBTTagCompound();
boolean var12 = false;
if (par2ArrayOfStr.length >= 5) {
IChatComponent var13 = func_147178_a(par1ICommandSender, par2ArrayOfStr, 4);
try {
NBTBase var14 = JsonToNBT.func_150315_a(var13.getUnformattedText());
if (!(var14 instanceof NBTTagCompound)) {
notifyAdmins(
par1ICommandSender, "commands.summon.tagError", new Object[] {"Not a valid tag"});
return;
}
var11 = (NBTTagCompound) var14;
var12 = true;
} catch (NBTException var17) {
notifyAdmins(
par1ICommandSender, "commands.summon.tagError", new Object[] {var17.getMessage()});
return;
}
}
var11.setString("id", var3);
Entity var18 = EntityList.createEntityFromNBT(var11, var10);
if (var18 != null) {
var18.setLocationAndAngles(var4, var6, var8, var18.rotationYaw, var18.rotationPitch);
if (!var12 && var18 instanceof EntityLiving) {
((EntityLiving) var18).onSpawnWithEgg((IEntityLivingData) null);
}
var10.spawnEntityInWorld(var18);
Entity var19 = var18;
for (NBTTagCompound var15 = var11;
var15.func_150297_b("Riding", 10);
var15 = var15.getCompoundTag("Riding")) {
Entity var16 = EntityList.createEntityFromNBT(var15.getCompoundTag("Riding"), var10);
if (var16 != null) {
var16.setLocationAndAngles(var4, var6, var8, var16.rotationYaw, var16.rotationPitch);
var10.spawnEntityInWorld(var16);
var19.mountEntity(var16);
}
var19 = var16;
}
notifyAdmins(par1ICommandSender, "commands.summon.success", new Object[0]);
} else {
notifyAdmins(par1ICommandSender, "commands.summon.failed", new Object[0]);
}
}
} else {
throw new WrongUsageException("commands.summon.usage", new Object[0]);
}
}