Encasing a Player in Glass

Hello, I am trying to work on a plugin which includes Spells. However, I'm having trouble with one. I'm currently trying to encase a player in glass which will only require 10 blocks to be laid down, then the glass will disappear in 8 seconds and revert the blocks that were changed to glass to their original state. Thank you!

 

Before you change the block's type, save the BlockState in a list. Then, after 8 seconds, loop through all the states in the list and revert it.

 

I understand that, but the main issue is getting the locations that surround the player so I know which blocks to change to glass, sorry for not specifying this.

 

AstramG

Locations should be:

• 1 up from player location
• 2 in front of player location
  • 1 directly in front of them
  • 1 below ^

• 2 behind player location
  • 1 directly behind them
  • 1 below ^
• 2 to each side
  • 1 directly to the side
  • 1 below ^
• 1 underneath the player

I'm pretty sure the player's location is taken from the block their head is at. Does that help?

 

Thank you, I'll try this! But do you mean 2 below the player for the last one?

 

AstramG

Oh right, yeah, 2 below the player. Even I get confused =P

 

This is my code and it seems to be generating something that is not relevant at all:

Code:

public List<BlockState> createGlass(Location loc) {
        //loc is the Player's location
        List<BlockState> blocks = new ArrayList<BlockState>();
        List<BlockState> blocks2 = new ArrayList<BlockState>();
        Block below = loc.add(0, -2, 0).getBlock();
        Block front1 = loc.add(1, 0, 0).getBlock();
        Block front2 = loc.add(1, -1, 0).getBlock();
        Block side11 = loc.add(0, 0, 1).getBlock();
        Block side12 = loc.add(0, -1, 1).getBlock();
        Block side21 = loc.add(0, 0, -1).getBlock();
        Block side22 = loc.add(0, -1, -1).getBlock();
        Block back1 = loc.add(-1, 0, 0).getBlock();
        Block back2 = loc.add(-1, -1, 0).getBlock();
        Block top = loc.add(0, 1, 0).getBlock();
        blocks = Arrays.asList(below.getState(), front1.getState(), front2.getState(), side11.getState(), side12.getState(), side21.getState(), side22.getState(), back1.getState(), back2.getState(), top.getState());
        blocks2 = blocks;
        for (BlockState bs : blocks) {
            Block b = bs.getBlock();
            b.setType(Material.GLASS);
        }
        return blocks2;
    }

Here is an image of what generates (Note it generates 2 below me):
http://i.imgur.com/Ctk6gRr.png

 

ERROR372 I believe it returns the location at their legs/feet.

 

AstramG chasechocolate

I'm doing some testing with the code. Lots of print statements x_x

And you are right, it seems to be from the feet, chase.

AstramG

OH! I got it!

location.add(x, y, z) isn't reset every time you call it. So when you have location 0,0,0... you do:

location.add(1,0,0)... now location is: 1,0,0
location.add(0,1,0)... now location is: 1,1,0


That make sense?

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Yes, that makes sense. You can use location.clone().add(1, 0, 0) instead to make sure to work on a new location object each time.

 

I recommend staying away from the Location object for this exact reason - it's not immutable, so it's very painful to use in algorithms such as this. Instead, just loop through all the blocks near the player.

You might also want to try sendBlockUpdate() instead, as then you don't have to store the original block ID yourself. Here's a very simple illustration of these two approaches:

Code:java

private void encasePlayer(Player player) {
    Location position = player.getLocation();
    World world = player.getWorld();
 
    // Location of the current player
    int pX = position.getBlockX();
    int pY = position.getBlockY();
    int pZ = position.getBlockZ();
 
    // Note that y goes from [-1, 2] + pY
    for (int x = pX - 1; x <= pX + 1; x++) {
        for (int y = pY - 1; y <= pY + 2; y++) {
            for (int z = pZ - 1; z <= pZ + 1; z++) {
 
                boolean insidePlayer = (x == pX && (y == pY || y == pY + 1) && z == pZ);
 
                // Only update if we are outside the player boundary box
                if (!insidePlayer) {
                    player.sendBlockChange(new Location(world, x, y, z), Material.GLASS.getId(), (byte)0);
                }
            }   
        }
    }
}

To reset the blocks, you simply resend the block changes, but with the block IDs of the actual block instead of glass.

You could also write your own BoundaryBox class and use that to "grow" the border around the player:

Code:java

public class BoundaryBox {
    public final int left;
    public final int top;
    public final int front;
    public final int right;
    public final int bottom;
    public final int behind;
 
    public BoundaryBox(int left, int top, int front, int right, int bottom, int behind) {
        this.left = left;
        this.top = top;
        this.front = front;
        this.right = right;
        this.bottom = bottom;
        this.behind = behind;
    }
 
    public BoundaryBox(Location minimum, Location maximum) {
        this.left = minimum.getBlockX();
        this.top = minimum.getBlockY();
        this.front = minimum.getBlockZ();
        this.right =  maximum.getBlockX();
        this.bottom = maximum.getBlockY();
        this.behind = maximum.getBlockZ();
    }
 
    public BoundaryBox grow(int dX, int dY, int dZ) {
        return new BoundaryBox(left - dX, top - dY, front - dZ, right + dX, bottom + dY, behind + dZ);
    }
 
    public boolean intersect(int x, int y, int z) {
        return (x >= left && x <= right) &&
               (y >= top && y <= bottom) &&
               (z >= front && z <= behind);
    }
}

Which you could use like so:

Code:java

private void encasePlayer(Player player) {
     // Bounding box of the given player
    Location position = player.getLocation();
    World world = position.getWorld();
 
    BoundaryBox playerBoundary = new BoundaryBox(
        position.clone(),
        position.clone().add(0, 1, 0)
    );
    BoundaryBox glassBoundary = playerBoundary.grow(1, 1, 1); 
 
    for (int x = glassBoundary.left; x <= glassBoundary.right; x++) {
        for (int y = glassBoundary.top; y <= glassBoundary.bottom; y++) {
            for (int z = glassBoundary.front; z <= glassBoundary.behind; z++) {
 
                // Only update if we are outside the player boundary box
                if (!playerBoundary.intersect(x, y, z)) {
                    player.sendBlockChange(new Location(world, x, y, z), Material.GLASS.getId(), (byte)0);
                }
            }   
        }
    }
}

That's the more general solution, which would work for bigger things than players.

 

Comphenix Thanks that's very in depth! I will probably be using it in the near future, thanks.