Solved How to find the corners of a cuboid?

Hey.

I have a list of blocks collected from the Minecraft world. These blocks form a cuboid. How would I go about finding the two opposite corners, as shown in this picture?

Show Spoiler Hide Spoiler

This is what I use to collect the blocks. I arrange the relatives into their own ArrayLists for simplicity.

Code:java

ArrayList<Location[]> cubes = new ArrayList<>(); // where the final cubes should be stored
ArrayList<ArrayList<Block>> bedrockConnections = new ArrayList<>(); // list of bedrocks that form a cube
 
Block startBlock = arena.getStartBlock();
Block endBlock = arena.getEndBlock();
 
for (int x = startBlock.getLocation().getBlockX(); x <= endBlock.getLocation().getBlockX(); x++) {
    for (int y = startBlock.getLocation().getBlockY(); y <= endBlock.getLocation().getBlockY(); y++) {
        for (int z = startBlock.getLocation().getBlockZ(); z <= endBlock.getLocation().getBlockZ(); z++) {
            Block block = startBlock.getWorld().getBlockAt(x, y, z);
            byte data = block.getData();
 
            if (block.getType() == Material.BEDROCK) {
                ArrayList <Block> connectionList = findConnectionList(block, bedrockConnections);
 
                if (connectionList == null) {
                    connectionList = new ArrayList < Block > ();
                    bedrockConnections.add(connectionList);
                }
 
                connectionList.add(block);
            }
        }
    }
}
 
for (ArrayList <Block> connectionList: bedrockConnections) {
    Block[] corners = findCorners(connectionList);
    Block b1 = corners[0];
    Block b2 = corners[1];
 
    if (b1 == null || b2 == null) {
        continue;
    }
 
    cubes.add(new Location[] { corners[0].getLocation(), corners[1].getLocation() });
}
 
// attempts to find the list that contains the relatives of that block
private ArrayList<Block> findConnectionList(Block origin, List <ArrayList<Block>> mainConnectionList) {
    for (ArrayList <Block> list: mainConnectionList) {
        for (BlockFace direction: DIRECTIONS) {
            if (list.contains(origin.getRelative(direction))) {
                return list;
            }
        }
    }
 
    return null;
}
 
// my failed attempt at getting the corners
private Block[] findCorners(ArrayList<Block> blocks) {
    Block b1 = null;
    Block b2 = null;
 
    for (Block block: blocks) {
        int x = block.getLocation().getBlockX();
        int y = block.getLocation().getBlockY();
        int z = block.getLocation().getBlockZ();
 
        int bX1 = b1 == null ? -1 : b1.getLocation().getBlockX();
        int bY1 = b1 == null ? -1 : b1.getLocation().getBlockY();
        int bZ1 = b1 == null ? -1 : b1.getLocation().getBlockZ();
 
        int bX2 = b2 == null ? -1 : b2.getLocation().getBlockX();
        int bY2 = b2 == null ? -1 : b2.getLocation().getBlockY();
        int bZ2 = b2 == null ? -1 : b2.getLocation().getBlockZ();
 
        if (b1 == null || x < bX1 && y < bY1 && z < bZ1) {
            b1 = block;
        } else if (b2 == null || x > bX2 && y > bY2 && z > bZ2) {
            b2 = block;
        }
    }
 
    b1.setType(Material.WOOD);
    b2.setType(Material.WOOD);
    return new Block[] { b1, b2 };
}

 

You could get the block y axis for the first and second position.
or something like:

Code:java

Location p1, p2; // Pretend it exists.
Location cornerBottom1XZ = new Location(p1.getBlockX(), p2.getBlockY(), p1.getBlockZ());
// That will get the bottom corner corresponding to p1's X and Z axis.
Location cornerBottom1X = new Location(p1.getBlockX(), p2.getBlockY(), p2.getBlockZ());
// That will get the bottom corner corresponding to p1's X axis and p2's Z axis.
// Do it for all of them, and then reversed.
Location cornerTop2XZ = new Location(p2.getBlockX(), p1.getBlockY(), p2.getBlockZ());

 

FabeGabeMC
I don't think I quite get what you mean. What would the p1 and p2 locations be?

I may have been a bit unclear in my first post, I was on a hurry. I'll try to update it later. But as I said earlier, I have a list of blocks that form a cube. Out of those blocks, I need to somehow find the two corner blocks so I can save them for further use. I tried finding the block with smallest x, y and z and same for biggest, however this returned only the bottom (same side) corners rather than the bottom and top opposite side corners as shown in the picture.

 

Assist
p1 and p2 are both positions (startBlock and endBlock)

 

FabeGabeMC
startBlock and endBlock are the corners of the whole arena. I'm collecting bedrock blocks that are connected to each other from the whole arena into ArrayLists.

Consider an arena within this stone brick foundation:

Show Spoiler Hide Spoiler

This arena contains two bedrock cubes which I both put into their own ArrayList<Block> using the code I provided above.

Show Spoiler Hide Spoiler

Now I need to find the opposite side, top and bottom corners, like in the picture provided in my first post.

Show Spoiler Hide Spoiler

I have already found one of the corners, so as a temporary solution, I could find the block that is furthest away from this corner to find the second corner.

My goal with this is to not make the user manually define all of the cubes in the arena, as that would take a lot of time (the ideal map for this plugin should contain a lot of them).

Thanks in advance.

Edit: Temporary solution for anyone who might be interested. Seems to be working fine.

Code:java

private Block[] findCorners(ArrayList<Block> blocks) {
    Block b1 = null;
 
    for (Block block: blocks) {
        int x = block.getLocation().getBlockX();
        int y = block.getLocation().getBlockY();
        int z = block.getLocation().getBlockZ();
 
        int bX1 = b1 == null ? -1 : b1.getLocation().getBlockX();
        int bY1 = b1 == null ? -1 : b1.getLocation().getBlockY();
        int bZ1 = b1 == null ? -1 : b1.getLocation().getBlockZ();
 
        if (b1 == null || x < bX1 && y < bY1 && z < bZ1) {
            b1 = block;
        }
    }
 
    Block b2 = null;
 
    for (Block block: blocks) {
        Location location = block.getLocation();
 
        if (b2 == null || (b1.getLocation().distanceSquared(location) > b2.getLocation().distanceSquared(b1.getLocation()))) {
            b2 = block;
        }
    }
 
    return new Block[] {
        b1, b2
    };
}

 

Assist I don't understand why this wouldn't work. That's basically what you describe in your first picture. Also, there are multiple opposite corners in a cuboid, you have to define more conditions : lowest and highest coordinates seems like the right way to do it.

I haven't read your whole code, and I don't know how you store blocks in your List, but I can think of multiple ways to improve efficiency. For example, you could make a class that extends ArrayList and for every block added, check its coordinates, and store its index in a field if it has the highest/lowest coordinates. Then implement getLowerCorner() / getHigherCorner().

Or even better : at the point where you add your blocks to the ArrayList, if you know the size of the cuboid AND have a way to loop through its contents in a linear way, then make a new class that only consists holds a Block[][][]. If you add your blocks in the right order, you can use blocks[0][0][0] and blocks[width-1][length-1][height-1] as your corners. If you don't want that array to store relative coordinates, you can always store the absolute origin of blocks[0][0][0] as another field to any origin later.

 

Avygeil
Thanks for the suggestions. Efficiency isn't that big of a deal in my opinion. This code will be executed only once, on the arena creation.

I don't know the size. The groups of blocks are collected from the world, and every map can be different.

 

Assist Yeah I just noticed the size of your bedrock cuboids in the picture above. In that case extending ArrayList sounds fine to me.