mirror of
https://github.com/GTNewHorizons/TinkersConstruct.git
synced 2026-11-18 03:25:10 +00:00
Initial test of Gradle (not working yet)
This commit is contained in:
1 parent
e8b7378831
commit
cb87c836c8
519 files changed
+351
No files matched your search
@@ -0,0 +1,570 @@
|
||||
package tconstruct.library.component;
|
||||
|
||||
import java.util.*;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.nbt.*;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import tconstruct.TConstruct;
|
||||
import tconstruct.library.util.*;
|
||||
|
||||
public class TankLayerScan extends LogicComponent
|
||||
{
|
||||
protected TileEntity master;
|
||||
protected IMasterLogic imaster;
|
||||
protected Block[] scanBlocks;
|
||||
protected CoordTuple masterCoord;
|
||||
|
||||
protected boolean completeStructure;
|
||||
|
||||
protected int bricks = 0;
|
||||
protected int airBlocks = 0;
|
||||
protected int structureTop = 0;
|
||||
protected HashSet<CoordTuple> layerBlockCoords = new HashSet<CoordTuple>();
|
||||
protected HashSet<CoordTuple> layerAirCoords = new HashSet<CoordTuple>();
|
||||
|
||||
public ArrayList<CoordTuple> blockCoords = new ArrayList<CoordTuple>();
|
||||
public ArrayList<CoordTuple> airCoords = new ArrayList<CoordTuple>();
|
||||
protected ArrayList<int[]> validAirCoords = new ArrayList<int[]>();
|
||||
protected CoordTuple returnStone;
|
||||
|
||||
private static boolean debug = System.getenv("DBG_MANTLE_TankLayerScan") != null;
|
||||
private static int MAX_LAYER_RECURSION_DEPTH = System.getProperty("os.arch").equals("amd64") ? 4000 : 2000; // Recursion causes overflows on 32-bit, so reduce if not 64-bit
|
||||
|
||||
public TankLayerScan(TileEntity te, Block... ids)
|
||||
{
|
||||
assert te instanceof IMasterLogic : "TileEntity must be an instance of IMasterLogic";
|
||||
master = te;
|
||||
imaster = (IMasterLogic) te;
|
||||
scanBlocks = ids;
|
||||
masterCoord = new CoordTuple(te.xCoord, te.yCoord, te.zCoord);
|
||||
validAirCoords.add(new int[] { 1, 0 });
|
||||
validAirCoords.add(new int[] { -1, 0 });
|
||||
validAirCoords.add(new int[] { 0, 1 });
|
||||
validAirCoords.add(new int[] { 0, -1 });
|
||||
if (debug)
|
||||
{
|
||||
TConstruct.logger.info("In debug mode: " + this);
|
||||
TConstruct.logger.info("Using recursion size " + MAX_LAYER_RECURSION_DEPTH + " on JVM arch " + System.getProperty("os.arch"));
|
||||
}
|
||||
}
|
||||
|
||||
public void checkValidStructure ()
|
||||
{
|
||||
bricks = 0;
|
||||
airBlocks = 0;
|
||||
blockCoords.clear();
|
||||
airCoords.clear();
|
||||
boolean validAir = false;
|
||||
//Check for air space in front of and behind the structure
|
||||
byte dir = getDirection();
|
||||
switch (getDirection())
|
||||
{
|
||||
case 2: // +z
|
||||
case 3: // -z
|
||||
if (checkAir(master.xCoord, master.yCoord, master.zCoord - 1) && checkAir(master.xCoord, master.yCoord, master.zCoord + 1))
|
||||
validAir = true;
|
||||
break;
|
||||
case 4: // +x
|
||||
case 5: // -x
|
||||
if (checkAir(master.xCoord - 1, master.yCoord, master.zCoord) && checkAir(master.xCoord + 1, master.yCoord, master.zCoord))
|
||||
validAir = true;
|
||||
break;
|
||||
}
|
||||
|
||||
//Recurse the structure
|
||||
boolean validBlocks = false;
|
||||
|
||||
int xPos = 0, zPos = 0;
|
||||
if (dir == 2)
|
||||
xPos = 1;
|
||||
if (dir == 3)
|
||||
xPos = -1;
|
||||
if (dir == 4)
|
||||
zPos = -1;
|
||||
if (dir == 5)
|
||||
zPos = 1;
|
||||
|
||||
returnStone = new CoordTuple(master.xCoord - xPos, master.yCoord, master.zCoord - zPos);
|
||||
if (initialRecurseLayer(master.xCoord + xPos, master.yCoord, master.zCoord + zPos))
|
||||
{
|
||||
xPos = 0;
|
||||
zPos = 0;
|
||||
switch (dir)
|
||||
{
|
||||
case 2: // +z
|
||||
zPos = 1;
|
||||
break;
|
||||
case 3: // -z
|
||||
zPos = -1;
|
||||
break;
|
||||
case 4: // +x
|
||||
xPos = 1;
|
||||
break;
|
||||
case 5: // -x
|
||||
xPos = -1;
|
||||
break;
|
||||
}
|
||||
if (!world.isRemote && debug)
|
||||
TConstruct.logger.info("Bricks in recursion: " + blockCoords.size());
|
||||
blockCoords.clear();
|
||||
bricks = 0;
|
||||
|
||||
//Does the actual adding of blocks in the ring
|
||||
boolean sealed = floodTest(master.xCoord + xPos, master.yCoord, master.zCoord + zPos);
|
||||
if (!world.isRemote && debug)
|
||||
{
|
||||
TConstruct.logger.info("Air in ring: " + airBlocks);
|
||||
TConstruct.logger.info("Bricks in ring: " + bricks);
|
||||
}
|
||||
|
||||
if (sealed)
|
||||
{
|
||||
blockCoords.add(new CoordTuple(master.xCoord, master.yCoord, master.zCoord)); //Don't forget me!
|
||||
layerAirCoords = new HashSet<CoordTuple>(airCoords);
|
||||
layerBlockCoords = new HashSet<CoordTuple>(blockCoords);
|
||||
|
||||
int lowY = recurseStructureDown(master.yCoord - 1);
|
||||
if (lowY != -1)
|
||||
{
|
||||
completeStructure = true;
|
||||
structureTop = recurseStructureUp(master.yCoord + 1);
|
||||
finalizeStructure();
|
||||
|
||||
if (!world.isRemote && debug)
|
||||
{
|
||||
TConstruct.logger.info("Air in structure: " + airCoords.size());
|
||||
TConstruct.logger.info("Bricks in structure: " + blockCoords.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//@SuppressWarnings({ "unchecked" })
|
||||
protected void finalizeStructure ()
|
||||
{
|
||||
Collections.sort(blockCoords, new CoordTupleSort());
|
||||
Collections.sort(airCoords, new CoordTupleSort());
|
||||
|
||||
for (CoordTuple coord : blockCoords)
|
||||
{
|
||||
TileEntity servant = world.getBlockTileEntity(coord.x, coord.y, coord.z);
|
||||
if (servant instanceof IServantLogic)
|
||||
((IServantLogic) servant).verifyMaster(imaster, world, master.xCoord, master.yCoord, master.zCoord);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isComplete ()
|
||||
{
|
||||
return completeStructure;
|
||||
}
|
||||
|
||||
public int getAirLayerSize ()
|
||||
{
|
||||
return layerAirCoords.size();
|
||||
}
|
||||
|
||||
public int getAirSize ()
|
||||
{
|
||||
return airBlocks;
|
||||
}
|
||||
|
||||
public CoordTuple getAirByIndex (int index)
|
||||
{
|
||||
if (index >= airCoords.size() || index < 0)
|
||||
return null;
|
||||
|
||||
return airCoords.get(index);
|
||||
}
|
||||
|
||||
private byte getDirection ()
|
||||
{
|
||||
if (master instanceof IFacingLogic)
|
||||
return ((IFacingLogic) master).getRenderDirection();
|
||||
return 0;
|
||||
}
|
||||
|
||||
protected boolean checkAir (int x, int y, int z)
|
||||
{
|
||||
Block block = Block.blocksList[world.getBlockId(x, y, z)];
|
||||
if (block == null || block.isAirBlock(world, x, y, z))// || block == TContent.tankAir)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
protected boolean checkServant (int x, int y, int z)
|
||||
{
|
||||
Block block = Block.blocksList[world.getBlockId(x, y, z)];
|
||||
if (block == null || block.isAirBlock(world, x, y, z) || !isValidBlock(x, y, z))
|
||||
return false;
|
||||
|
||||
if (!block.hasTileEntity(world.getBlockMetadata(x, y, z)))
|
||||
return false;
|
||||
|
||||
TileEntity be = world.getBlockTileEntity(x, y, z);
|
||||
if (be instanceof IServantLogic)
|
||||
return ((IServantLogic) be).setPotentialMaster(this.imaster, this.world, x, y, z);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
protected boolean initialRecurseLayer (int x, int y, int z)
|
||||
{
|
||||
if (bricks > MAX_LAYER_RECURSION_DEPTH)
|
||||
return false;
|
||||
|
||||
CoordTuple keystone = new CoordTuple(x, y, z);
|
||||
if (keystone.equals(returnStone))
|
||||
return true;
|
||||
|
||||
for (int xPos = -1; xPos <= 1; xPos++)
|
||||
{
|
||||
for (int zPos = -1; zPos <= 1; zPos++)
|
||||
{
|
||||
CoordTuple coord = new CoordTuple(x + xPos, y, z + zPos);
|
||||
if (!blockCoords.contains(coord))
|
||||
{
|
||||
if (isValidBlock(x + xPos, y, z + zPos))
|
||||
{
|
||||
bricks++;
|
||||
blockCoords.add(coord);
|
||||
return initialRecurseLayer(x + xPos, y, z + zPos);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
protected boolean isValidBlock (int x, int y, int z)
|
||||
{
|
||||
Block block = Block.blocksList[world.getBlockId(x, y, z)];
|
||||
if (block != null)
|
||||
{
|
||||
for (int i = 0; i < scanBlocks.length; i++)
|
||||
{
|
||||
if (block == scanBlocks[i])
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
protected boolean floodTest (int x, int y, int z)
|
||||
{
|
||||
if (airBlocks > MAX_LAYER_RECURSION_DEPTH)
|
||||
return false;
|
||||
|
||||
for (int[] offset : validAirCoords)
|
||||
{
|
||||
CoordTuple coord = new CoordTuple(x + offset[0], y, z + offset[1]);
|
||||
if (!airCoords.contains(coord))
|
||||
{
|
||||
if (checkAir(x + offset[0], y, z + offset[1]))
|
||||
{
|
||||
addAirBlock(coord.x, y, coord.z);
|
||||
floodTest(x + offset[0], y, z + offset[1]);
|
||||
}
|
||||
else if (!blockCoords.contains(coord) && checkServant(x + offset[0], y, z + offset[1]))
|
||||
{
|
||||
bricks++;
|
||||
blockCoords.add(coord);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public int recurseStructureDown (int y)
|
||||
{
|
||||
Iterator i = layerAirCoords.iterator();
|
||||
if (i.hasNext())
|
||||
{
|
||||
CoordTuple coord = (CoordTuple) i.next();
|
||||
if (checkAir(coord.x, y, coord.z))
|
||||
{
|
||||
boolean valid = true;
|
||||
addAirBlock(coord.x, y, coord.z); //Don't skip first one
|
||||
|
||||
//Air blocks
|
||||
while (i.hasNext())
|
||||
{
|
||||
coord = (CoordTuple) i.next();
|
||||
if (checkAir(coord.x, y, coord.z))
|
||||
{
|
||||
addAirBlock(coord.x, y, coord.z);
|
||||
}
|
||||
else
|
||||
{
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//Bricks
|
||||
i = layerBlockCoords.iterator();
|
||||
while (i.hasNext())
|
||||
{
|
||||
coord = (CoordTuple) i.next();
|
||||
if (checkServant(coord.x, y, coord.z))
|
||||
blockCoords.add(new CoordTuple(coord.x, y, coord.z));
|
||||
|
||||
else
|
||||
{
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (valid)
|
||||
return recurseStructureDown(y - 1);
|
||||
}
|
||||
else if (checkServant(coord.x, y, coord.z))
|
||||
{
|
||||
//Bottom floor. All blocks, please vacate the elevator
|
||||
boolean valid = true;
|
||||
while (i.hasNext())
|
||||
{
|
||||
coord = (CoordTuple) i.next();
|
||||
|
||||
if (checkServant(coord.x, y, coord.z))
|
||||
blockCoords.add(new CoordTuple(coord.x, y, coord.z));
|
||||
|
||||
else
|
||||
{
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (valid)
|
||||
return y + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
public int recurseStructureUp (int y)
|
||||
{
|
||||
Iterator i = layerBlockCoords.iterator();
|
||||
if (i.hasNext())
|
||||
{
|
||||
CoordTuple coord = (CoordTuple) i.next();
|
||||
if (checkServant(coord.x, y, coord.z))
|
||||
{
|
||||
boolean valid = true;
|
||||
|
||||
//Bricks
|
||||
while (i.hasNext())
|
||||
{
|
||||
coord = (CoordTuple) i.next();
|
||||
if (checkServant(coord.x, y, coord.z))
|
||||
blockCoords.add(new CoordTuple(coord.x, y, coord.z));
|
||||
|
||||
else
|
||||
{
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//Air blocks
|
||||
if (valid)
|
||||
{
|
||||
i = layerAirCoords.iterator();
|
||||
while (i.hasNext())
|
||||
{
|
||||
coord = (CoordTuple) i.next();
|
||||
if (checkAir(coord.x, y, coord.z))
|
||||
{
|
||||
addAirBlock(coord.x, y, coord.z);
|
||||
}
|
||||
else
|
||||
{
|
||||
valid = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (valid)
|
||||
recurseStructureUp(y + 1);
|
||||
}
|
||||
}
|
||||
return y - 1;
|
||||
}
|
||||
|
||||
protected void addAirBlock (int x, int y, int z)
|
||||
{
|
||||
airBlocks++;
|
||||
airCoords.add(new CoordTuple(x, y, z));
|
||||
}
|
||||
|
||||
/* Checking for valid structures */
|
||||
|
||||
public void recheckStructure ()
|
||||
{
|
||||
System.out.println("Rechecking structure");
|
||||
int height = -1;
|
||||
for (CoordTuple coord : blockCoords)
|
||||
{
|
||||
TileEntity servant = world.getBlockTileEntity(coord.x, coord.y, coord.z);
|
||||
boolean canPass = false;
|
||||
if (servant instanceof IServantLogic)
|
||||
{
|
||||
canPass = ((IServantLogic) servant).verifyMaster(imaster, world, master.xCoord, master.yCoord, master.zCoord);
|
||||
if (canPass)
|
||||
continue;
|
||||
}
|
||||
if (!canPass)
|
||||
{
|
||||
System.out.println("Coord: " + coord);
|
||||
height = coord.y;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (height != -1)
|
||||
{
|
||||
if (height <= master.yCoord)
|
||||
invalidateStructure();
|
||||
else
|
||||
invalidateBlocksAbove(height);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (structureTop == 0) //Workaround for missing data
|
||||
{
|
||||
for (CoordTuple coord : blockCoords)
|
||||
structureTop = coord.y;
|
||||
}
|
||||
structureTop = recurseStructureUp(structureTop + 1);
|
||||
finalizeStructure();
|
||||
}
|
||||
}
|
||||
|
||||
protected void invalidateStructure ()
|
||||
{
|
||||
completeStructure = false;
|
||||
for (CoordTuple coord : blockCoords)
|
||||
{
|
||||
TileEntity servant = world.getBlockTileEntity(coord.x, coord.y, coord.z);
|
||||
if (servant instanceof IServantLogic)
|
||||
((IServantLogic) servant).invalidateMaster(imaster, world, master.xCoord, master.yCoord, master.zCoord);
|
||||
}
|
||||
master.worldObj.markBlockForUpdate(master.xCoord, master.yCoord, master.zCoord);
|
||||
}
|
||||
|
||||
protected void invalidateBlocksAbove (int height)
|
||||
{
|
||||
for (CoordTuple coord : blockCoords)
|
||||
{
|
||||
if (coord.y < height)
|
||||
continue;
|
||||
|
||||
TileEntity servant = world.getBlockTileEntity(coord.x, coord.y, coord.z);
|
||||
if (servant instanceof IServantLogic)
|
||||
((IServantLogic) servant).invalidateMaster(imaster, world, master.xCoord, master.yCoord, master.zCoord);
|
||||
}
|
||||
}
|
||||
|
||||
/** Do any necessary cleanup here. Remove air blocks, invalidate servants, etc */
|
||||
public void cleanup ()
|
||||
{
|
||||
Iterator i = blockCoords.iterator();
|
||||
while (i.hasNext())
|
||||
{
|
||||
CoordTuple coord = (CoordTuple) i.next();
|
||||
TileEntity te = world.getBlockTileEntity(coord.x, coord.y, coord.z);
|
||||
if (te != null && te instanceof IServantLogic)
|
||||
{
|
||||
((IServantLogic) te).invalidateMaster(imaster, world, master.xCoord, master.yCoord, master.zCoord);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* NBT */
|
||||
@Override
|
||||
public void readFromNBT (NBTTagCompound tags)
|
||||
{
|
||||
super.readFromNBT(tags);
|
||||
NBTTagList layerAir = tags.getTagList("AirLayer");
|
||||
if (layerAir != null)
|
||||
{
|
||||
layerAirCoords.clear();
|
||||
|
||||
for (int i = 0; i < layerAir.tagCount(); ++i)
|
||||
{
|
||||
NBTTagIntArray tag = (NBTTagIntArray) layerAir.tagAt(i);
|
||||
int[] coord = tag.intArray;
|
||||
layerAirCoords.add(new CoordTuple(coord[0], coord[1], coord[2]));
|
||||
}
|
||||
}
|
||||
|
||||
NBTTagList blocks = tags.getTagList("Blocks");
|
||||
if (blocks != null)
|
||||
{
|
||||
blockCoords.clear();
|
||||
|
||||
for (int i = 0; i < blocks.tagCount(); ++i)
|
||||
{
|
||||
NBTTagIntArray tag = (NBTTagIntArray) blocks.tagAt(i);
|
||||
int[] coord = tag.intArray;
|
||||
blockCoords.add(new CoordTuple(coord[0], coord[1], coord[2]));
|
||||
}
|
||||
}
|
||||
|
||||
NBTTagList air = tags.getTagList("Air");
|
||||
if (air != null)
|
||||
{
|
||||
airCoords.clear();
|
||||
|
||||
for (int i = 0; i < air.tagCount(); ++i)
|
||||
{
|
||||
NBTTagIntArray tag = (NBTTagIntArray) air.tagAt(i);
|
||||
int[] coord = tag.intArray;
|
||||
airCoords.add(new CoordTuple(coord[0], coord[1], coord[2]));
|
||||
}
|
||||
}
|
||||
structureTop = tags.getInteger("structureTop");
|
||||
}
|
||||
|
||||
public void readNetworkNBT (NBTTagCompound tags)
|
||||
{
|
||||
completeStructure = tags.getBoolean("Complete");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToNBT (NBTTagCompound tags)
|
||||
{
|
||||
super.writeToNBT(tags);
|
||||
NBTTagList layerAir = new NBTTagList();
|
||||
for (CoordTuple coord : layerAirCoords)
|
||||
{
|
||||
layerAir.appendTag(new NBTTagIntArray("coord", new int[] { coord.x, coord.y, coord.z }));
|
||||
}
|
||||
tags.setTag("AirLayer", layerAir);
|
||||
|
||||
NBTTagList blocks = new NBTTagList();
|
||||
for (CoordTuple coord : blockCoords)
|
||||
{
|
||||
blocks.appendTag(new NBTTagIntArray("coord", new int[] { coord.x, coord.y, coord.z }));
|
||||
}
|
||||
tags.setTag("Blocks", blocks);
|
||||
|
||||
NBTTagList air = new NBTTagList();
|
||||
for (CoordTuple coord : airCoords)
|
||||
{
|
||||
air.appendTag(new NBTTagIntArray("coord", new int[] { coord.x, coord.y, coord.z }));
|
||||
}
|
||||
tags.setTag("Air", air);
|
||||
tags.setInteger("structureTop", structureTop);
|
||||
}
|
||||
|
||||
public void writeNetworkNBT (NBTTagCompound tags)
|
||||
{
|
||||
tags.setBoolean("Complete", completeStructure);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user