hoeruputils/creative/GeneralContractorCommands.java

package dk.thoerup.bukkit.hoeruputils.creative;

import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class GeneralContractorCommands implements CommandExecutor{

        class StoredCommand {
                public StoredCommand(String l, String a[]) {
                        this.label = l;
                        this.args = a;
                }
                public String label;
                public String args[];
        }

        final static int Y_MAX = 255;
        final Material valid_block_array[] = {
                        Material.STONE, 
                        Material.GRASS,
                        Material.DIRT,
                        Material.COBBLESTONE
        };
//4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 35, 41, 42, 43, 44, 45, 48, 49, 56, 57, 73, 74, 79, 80, 82} ;

        final Set<Material> valid_materials = new HashSet<Material>();

        HashMap<String,StoredCommand> commands = new HashMap<String,StoredCommand>();


        public GeneralContractorCommands() {
                Arrays.sort(valid_block_array);

                for (Material mat : valid_block_array) {
                        valid_materials.add( mat );
                }
        }
        
        //@Override
        public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
        
                if (! (sender instanceof Player) ) {
                        return false;
                }
                Player player = (Player) sender;
                
                Location loc = player.getLocation(); 
                
                if ( ! loc.getWorld().getName().equals("creative")) {
                        player.sendMessage( ChatColor.RED + "This command may only be used in creative world" );
                        return true;
                }


                if ( command.getLabel().equals("replay")  ) {
                        StoredCommand cmd = commands.get(player.getName() );
                        if (cmd != null) {
                                label = cmd.label;
                                args = cmd.args;
                        }
                } else {
                        commands.put(player.getName(), new StoredCommand(label,args) );
                }
                
                //System.out.println( ">>" + label); //DEBUG
                
                if ( label.equals("levelarea") ) {
                        if (validateLevelOrFill(player, label, args) ) {
                                levelArea(player, loc, args);
                        }
                        return true;
                }
                
                if ( label.equals("createcave") ) {
                        if (validateLevelOrFill(player, label, args) ) {
                                createCave(player, loc, args);
                        }
                        return true;
                }
                
                if ( label.equals("fillarea") ) {
                        if (validateLevelOrFill(player, label, args) ) {
                                fillArea(player, loc, args);
                        }       
                        return true;
                }
                
                if ( label.equals("slopearea") ) {
                        slopeArea(player, loc, args);   
                        return true;
                }

                
                if ( label.equals("setsurface") ) {
                        setSurface(player, loc, args);  
                        return true;
                }

                if (label.equals("platform") ) {
                        platform(player,loc,args);
                        return true;
                }

                if (label.equals("cylinder") ) {
                        if (validateLevelOrFill(player, label, args) ) {
                                cylinder(player,loc,args);
                        }
                        return true;
                }
        
        
                return false;
        }

        
        void slopeArea(Player player, Location loc, String[] split) {
                int radius;
                try {
                        radius = Integer.parseInt(split[0]);
                } catch (Exception e) {
                        player.sendMessage("setsurface: radius must be an integer");
                        return;
                }

                System.out.println("Player " + player.getName() + " used slopearea with radius=" + radius);
                

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();
                
                World world = loc.getWorld();

                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {


                                int xdist = Math.abs(playerX-x);
                                int zdist = Math.abs(playerZ-z);

                                int dist = Math.max(xdist,zdist);

                                //for (int y=playerY; y<=playerY+radius; y++) {
                                for (int y=(playerY+dist); y<=Y_MAX; y++) {
                                        world.getBlockAt(x, y, z).setType(Material.AIR);
                                }

                        }

                }               
        }
        
        private void platform(Player player, Location loc, String[] split) {

                if (split.length != 2) {
                        player.sendMessage("Usage /platform [radius] [material]");
                        return;
                }

                int radius;
                try {
                        radius = Integer.parseInt(split[0]);
                } catch (Exception e) {
                        player.sendMessage("platform: radius must be an integer");
                        return;
                }

                if (radius > 20) {
                        player.sendMessage("platform: radius may not exceed 20");
                        return;
                }

                Material material = Material.matchMaterial( split[1] );
                if (material == null) {
                        player.sendMessage("platform: blockid must be an integer");
                        return;
                }
/*
                boolean validblock = false;
                for (int i=0; i<valid_block_array.length; i++) {
                        if (valid_block_array[i] == blockid) {
                                validblock = true;
                                break;
                        }
                }

                if ( !validblock ) {
                        player.sendMessage("setsurface: block now allowed");
                        return;
                }*/

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();

                
                World world = loc.getWorld();

                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
                                int y = playerY - 1;
                                
                                world.getBlockAt(x, y, z).setType( material );
                        }
                }
        }

        private void setSurface(Player player, Location loc, String[] split) {

                if (split.length != 2) {
                        player.sendMessage("Usage /setsurface [radius] [blockID]");
                        return;
                }

                int radius;
                try {
                        radius = Integer.parseInt(split[0]);
                } catch (Exception e) {
                        player.sendMessage("setsurface: radius must be an integer");
                        return;
                }

                if (radius > 20) {
                        player.sendMessage("setsurface: radius may not exceed 20");
                        return;
                }

                Material material = Material.matchMaterial( split[1] );
                if (material == null) {
                        player.sendMessage("platform: blockid must be an integer");
                        return;
                }

                //check if the blockid is in the array of valid blocks
                if ( ! valid_materials.contains(material) ) {
                        player.sendMessage("setsurface: block now allowed");
                        return;
                }

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();

                if(playerY <= 2 && material != Material.BEDROCK ) {
                        player.sendMessage("setsurface: at this level you may only use bedrock(id=7)");
                        return;
                }
                
                World world = loc.getWorld();

                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
                                //int y = getGroundLevel(x,z) - 1;
                                int y = world.getHighestBlockYAt(x, z) ;
                                
                                world.getBlockAt(x, y, z).setType(material);
                        }
                }
        }

        private boolean validateLevelOrFill(Player player, String label, String[] split) {
                if (split.length < 1 || split.length > 2) {
                        player.sendMessage("Usage: " + label + " [radius]");
                        return false;
                }
                
                int radius;
                try {
                        radius = Integer.parseInt(split[0]);
                } catch (Exception e) {
                        player.sendMessage(label + ": radius must be an integer");
                        return false;
                }

                if (radius > 20) {
                        player.sendMessage(label + ": radius may not exceed 20");
                        return false;
                }
                
                if (split.length == 2) {
                        int id;
                        try {
                                id = Integer.parseInt( split[1] );
                        } catch (Exception e) {
                                player.sendMessage(label + ": id must be an integer");
                                return false;
                        }
                        if ( id == 46) {
                                player.sendMessage("Sorry dave, i can't do that");
                                return false;
                        }
                        
                }

                return true;
        }

        private void fillArea(Player player, Location loc, String[] split) {
                int radius = Integer.parseInt(split[0]);
                
                Material material = Material.DIRT;

                
                if (split.length == 2) {
                        material = Material.matchMaterial( split[1] );
                        if (material == null) {
                                player.sendMessage("Unknown material: " + split[1] );
                                return;
                        }
                }

                System.out.println("Player " + player.getName() + " used fillarea with radius=" + radius);
                

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();
                
                World world = loc.getWorld();

                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
                                
                                
                                for (int y=world.getHighestBlockYAt(x, z); y<playerY; y++) {                                    
                                        world.getBlockAt(x, y, z).setType( material );
                                }

                        }

                }
        }

        private void createCave(Player player, Location loc, String[] split) {

                int radius = Integer.parseInt(split[0]);

                System.out.println("Player " + player.getName() + " used levelarea with radius=" + radius);
                

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();
                

                World world = loc.getWorld();

                int count = 0;
                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {

                                int y_max = playerY+radius;
                                //for (int y=playerY; y<=playerY+radius; y++) {
                                for (int y=playerY; y<=y_max; y++) {
                                        count++;
                                        world.getBlockAt(x, y, z).setType(Material.AIR);
                                        
                                }

                        }

                }
        }
        
        private void levelArea(Player player, Location loc, String[] split) {

                int radius = Integer.parseInt(split[0]);

                System.out.println("Player " + player.getName() + " used levelarea with radius=" + radius);
                

                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();
                

                World world = loc.getWorld();

                int count = 0;
                for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                        for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {

                                //for (int y=playerY; y<=playerY+radius; y++) {
                                for (int y=playerY; y<=Y_MAX; y++) {
                                        count++;
                                        world.getBlockAt(x, y, z).setType(Material.AIR);
                                        
                                }

                        }

                }
        }
        

        private void resetMap(boolean[][] map) {
                for (int x=0; x<map.length; x++) {
                        for (int z=0; z<map[0].length; z++) {
                                map[x][z] = false;                              
                        }
                }
        }

        private void cylinder(Player player, Location loc, String[] split) {
                if (split.length != 2) {
                        player.sendMessage("Usage: /cylinder [radius] [material] ");
                        return;
                }

                Material material = Material.matchMaterial( split[1] );
                if ( material == null) {
                        player.sendMessage("/cylinder: unknown material: " + split[1]);
                        return;
                }

                int radius = Integer.parseInt(split[0]);
                int diameter = (radius*2) + 1;

                boolean map[][] = new boolean[diameter][diameter];
                resetMap( map );

/*              map[0][0] = true;
                map[0][diameter-1] = true;
                map[diameter-1][0] = true;
                map[diameter-1][diameter-1] = true;*/

                for (int r=0; r<360; r++) {
                        double rad = Math.toRadians( r );

                        double a = (double) radius * Math.sin( rad);
                        double b = (double) radius * Math.cos( rad);

                        int x = radius + (int)Math.round(a);
                        int y = radius + (int)Math.round(b);

                        map[x][y] = true;
                }

        
                drawMap( loc, map, material );  
        }

        private void drawMap(Location loc, boolean[][] map, Material material) {
                int playerX = loc.getBlockX();
                int playerY = loc.getBlockY();
                int playerZ = loc.getBlockZ();

                World world = loc.getWorld();

                for (int i=0; i<map.length; i++) {
                        for (int j=0; j<map[0].length; j++) {

                                int x = playerX + i + 1;
                                int z = playerZ + j;

                                if (map[i][j] == true) {
                                        for (int y=world.getHighestBlockYAt(x, z); y<playerY; y++) {                                    
                                                world.getBlockAt(x, y, z).setType(material);
                                        }
                                }
                                
                        }
                }
        }

        
}
1	package dk.thoerup.bukkit.hoeruputils.creative;
2
3	import org.bukkit.ChatColor;
4	import org.bukkit.Location;
5	import org.bukkit.Material;
6	import org.bukkit.World;
7	import org.bukkit.command.Command;
8	import org.bukkit.command.CommandExecutor;
9	import org.bukkit.command.CommandSender;
10	import org.bukkit.entity.Player;
11
12	import java.util.Arrays;
13	import java.util.HashMap;
14	import java.util.HashSet;
15	import java.util.Set;
16
17	public class GeneralContractorCommands implements CommandExecutor{
18
19	class StoredCommand {
20	public StoredCommand(String l, String a[]) {
21	this.label = l;
22	this.args = a;
23	}
24	public String label;
25	public String args[];
26	}
27
28	final static int Y_MAX = 255;
29	final Material valid_block_array[] = {
30	Material.STONE,
31	Material.GRASS,
32	Material.DIRT,
33	Material.COBBLESTONE
34	};
35	//4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 35, 41, 42, 43, 44, 45, 48, 49, 56, 57, 73, 74, 79, 80, 82} ;
36
37	final Set<Material> valid_materials = new HashSet<Material>();
38
39	HashMap<String,StoredCommand> commands = new HashMap<String,StoredCommand>();
40
41
42	public GeneralContractorCommands() {
43	Arrays.sort(valid_block_array);
44
45	for (Material mat : valid_block_array) {
46	valid_materials.add( mat );
47	}
48	}
49
50	//@Override
51	public boolean onCommand(final CommandSender sender, Command command, String label, String[] args) {
52
53	if (! (sender instanceof Player) ) {
54	return false;
55	}
56	Player player = (Player) sender;
57
58	Location loc = player.getLocation();
59
60	if ( ! loc.getWorld().getName().equals("creative")) {
61	player.sendMessage( ChatColor.RED + "This command may only be used in creative world" );
62	return true;
63	}
64
65
66	if ( command.getLabel().equals("replay") ) {
67	StoredCommand cmd = commands.get(player.getName() );
68	if (cmd != null) {
69	label = cmd.label;
70	args = cmd.args;
71	}
72	} else {
73	commands.put(player.getName(), new StoredCommand(label,args) );
74	}
75
76	//System.out.println( ">>" + label); //DEBUG
77
78	if ( label.equals("levelarea") ) {
79	if (validateLevelOrFill(player, label, args) ) {
80	levelArea(player, loc, args);
81	}
82	return true;
83	}
84
85	if ( label.equals("createcave") ) {
86	if (validateLevelOrFill(player, label, args) ) {
87	createCave(player, loc, args);
88	}
89	return true;
90	}
91
92	if ( label.equals("fillarea") ) {
93	if (validateLevelOrFill(player, label, args) ) {
94	fillArea(player, loc, args);
95	}
96	return true;
97	}
98
99	if ( label.equals("slopearea") ) {
100	slopeArea(player, loc, args);
101	return true;
102	}
103
104
105	if ( label.equals("setsurface") ) {
106	setSurface(player, loc, args);
107	return true;
108	}
109
110	if (label.equals("platform") ) {
111	platform(player,loc,args);
112	return true;
113	}
114
115	if (label.equals("cylinder") ) {
116	if (validateLevelOrFill(player, label, args) ) {
117	cylinder(player,loc,args);
118	}
119	return true;
120	}
121
122
123	return false;
124	}
125
126
127	void slopeArea(Player player, Location loc, String[] split) {
128	int radius;
129	try {
130	radius = Integer.parseInt(split[0]);
131	} catch (Exception e) {
132	player.sendMessage("setsurface: radius must be an integer");
133	return;
134	}
135
136	System.out.println("Player " + player.getName() + " used slopearea with radius=" + radius);
137
138
139	int playerX = loc.getBlockX();
140	int playerY = loc.getBlockY();
141	int playerZ = loc.getBlockZ();
142
143	World world = loc.getWorld();
144
145	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
146	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
147
148
149	int xdist = Math.abs(playerX-x);
150	int zdist = Math.abs(playerZ-z);
151
152	int dist = Math.max(xdist,zdist);
153
154	//for (int y=playerY; y<=playerY+radius; y++) {
155	for (int y=(playerY+dist); y<=Y_MAX; y++) {
156	world.getBlockAt(x, y, z).setType(Material.AIR);
157	}
158
159	}
160
161	}
162	}
163
164	private void platform(Player player, Location loc, String[] split) {
165
166	if (split.length != 2) {
167	player.sendMessage("Usage /platform [radius] [material]");
168	return;
169	}
170
171	int radius;
172	try {
173	radius = Integer.parseInt(split[0]);
174	} catch (Exception e) {
175	player.sendMessage("platform: radius must be an integer");
176	return;
177	}
178
179	if (radius > 20) {
180	player.sendMessage("platform: radius may not exceed 20");
181	return;
182	}
183
184	Material material = Material.matchMaterial( split[1] );
185	if (material == null) {
186	player.sendMessage("platform: blockid must be an integer");
187	return;
188	}
189	/*
190	boolean validblock = false;
191	for (int i=0; i<valid_block_array.length; i++) {
192	if (valid_block_array[i] == blockid) {
193	validblock = true;
194	break;
195	}
196	}
197
198	if ( !validblock ) {
199	player.sendMessage("setsurface: block now allowed");
200	return;
201	}*/
202
203	int playerX = loc.getBlockX();
204	int playerY = loc.getBlockY();
205	int playerZ = loc.getBlockZ();
206
207
208	World world = loc.getWorld();
209
210	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
211	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
212	int y = playerY - 1;
213
214	world.getBlockAt(x, y, z).setType( material );
215	}
216	}
217	}
218
219	private void setSurface(Player player, Location loc, String[] split) {
220
221	if (split.length != 2) {
222	player.sendMessage("Usage /setsurface [radius] [blockID]");
223	return;
224	}
225
226	int radius;
227	try {
228	radius = Integer.parseInt(split[0]);
229	} catch (Exception e) {
230	player.sendMessage("setsurface: radius must be an integer");
231	return;
232	}
233
234	if (radius > 20) {
235	player.sendMessage("setsurface: radius may not exceed 20");
236	return;
237	}
238
239	Material material = Material.matchMaterial( split[1] );
240	if (material == null) {
241	player.sendMessage("platform: blockid must be an integer");
242	return;
243	}
244
245	//check if the blockid is in the array of valid blocks
246	if ( ! valid_materials.contains(material) ) {
247	player.sendMessage("setsurface: block now allowed");
248	return;
249	}
250
251	int playerX = loc.getBlockX();
252	int playerY = loc.getBlockY();
253	int playerZ = loc.getBlockZ();
254
255	if(playerY <= 2 && material != Material.BEDROCK ) {
256	player.sendMessage("setsurface: at this level you may only use bedrock(id=7)");
257	return;
258	}
259
260	World world = loc.getWorld();
261
262	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
263	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
264	//int y = getGroundLevel(x,z) - 1;
265	int y = world.getHighestBlockYAt(x, z) ;
266
267	world.getBlockAt(x, y, z).setType(material);
268	}
269	}
270	}
271
272	private boolean validateLevelOrFill(Player player, String label, String[] split) {
273	if (split.length < 1 \|\| split.length > 2) {
274	player.sendMessage("Usage: " + label + " [radius]");
275	return false;
276	}
277
278	int radius;
279	try {
280	radius = Integer.parseInt(split[0]);
281	} catch (Exception e) {
282	player.sendMessage(label + ": radius must be an integer");
283	return false;
284	}
285
286	if (radius > 20) {
287	player.sendMessage(label + ": radius may not exceed 20");
288	return false;
289	}
290
291	if (split.length == 2) {
292	int id;
293	try {
294	id = Integer.parseInt( split[1] );
295	} catch (Exception e) {
296	player.sendMessage(label + ": id must be an integer");
297	return false;
298	}
299	if ( id == 46) {
300	player.sendMessage("Sorry dave, i can't do that");
301	return false;
302	}
303
304	}
305
306	return true;
307	}
308
309	private void fillArea(Player player, Location loc, String[] split) {
310	int radius = Integer.parseInt(split[0]);
311
312	Material material = Material.DIRT;
313
314
315	if (split.length == 2) {
316	material = Material.matchMaterial( split[1] );
317	if (material == null) {
318	player.sendMessage("Unknown material: " + split[1] );
319	return;
320	}
321	}
322
323	System.out.println("Player " + player.getName() + " used fillarea with radius=" + radius);
324
325
326	int playerX = loc.getBlockX();
327	int playerY = loc.getBlockY();
328	int playerZ = loc.getBlockZ();
329
330	World world = loc.getWorld();
331
332	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
333	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
334
335
336
337	for (int y=world.getHighestBlockYAt(x, z); y<playerY; y++) {
338	world.getBlockAt(x, y, z).setType( material );
339	}
340
341	}
342
343	}
344	}
345
346	private void createCave(Player player, Location loc, String[] split) {
347
348	int radius = Integer.parseInt(split[0]);
349
350	System.out.println("Player " + player.getName() + " used levelarea with radius=" + radius);
351
352
353	int playerX = loc.getBlockX();
354	int playerY = loc.getBlockY();
355	int playerZ = loc.getBlockZ();
356
357
358	World world = loc.getWorld();
359
360	int count = 0;
361	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
362	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
363
364	int y_max = playerY+radius;
365	//for (int y=playerY; y<=playerY+radius; y++) {
366	for (int y=playerY; y<=y_max; y++) {
367	count++;
368	world.getBlockAt(x, y, z).setType(Material.AIR);
369
370	}
371
372	}
373
374	}
375	}
376
377	private void levelArea(Player player, Location loc, String[] split) {
378
379	int radius = Integer.parseInt(split[0]);
380
381	System.out.println("Player " + player.getName() + " used levelarea with radius=" + radius);
382
383
384	int playerX = loc.getBlockX();
385	int playerY = loc.getBlockY();
386	int playerZ = loc.getBlockZ();
387
388
389	World world = loc.getWorld();
390
391	int count = 0;
392	for (int x=(playerX-radius); x<=(playerX+radius); x++) {
393	for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
394
395	//for (int y=playerY; y<=playerY+radius; y++) {
396	for (int y=playerY; y<=Y_MAX; y++) {
397	count++;
398	world.getBlockAt(x, y, z).setType(Material.AIR);
399
400	}
401
402	}
403
404	}
405	}
406
407
408
409	private void resetMap(boolean[][] map) {
410	for (int x=0; x<map.length; x++) {
411	for (int z=0; z<map[0].length; z++) {
412	map[x][z] = false;
413	}
414	}
415	}
416
417	private void cylinder(Player player, Location loc, String[] split) {
418	if (split.length != 2) {
419	player.sendMessage("Usage: /cylinder [radius] [material] ");
420	return;
421	}
422
423	Material material = Material.matchMaterial( split[1] );
424	if ( material == null) {
425	player.sendMessage("/cylinder: unknown material: " + split[1]);
426	return;
427	}
428
429	int radius = Integer.parseInt(split[0]);
430	int diameter = (radius*2) + 1;
431
432	boolean map[][] = new boolean[diameter][diameter];
433	resetMap( map );
434
435	/* map[0][0] = true;
436	map[0][diameter-1] = true;
437	map[diameter-1][0] = true;
438	map[diameter-1][diameter-1] = true;*/
439
440	for (int r=0; r<360; r++) {
441	double rad = Math.toRadians( r );
442
443	double a = (double) radius * Math.sin( rad);
444	double b = (double) radius * Math.cos( rad);
445
446	int x = radius + (int)Math.round(a);
447	int y = radius + (int)Math.round(b);
448
449	map[x][y] = true;
450	}
451
452
453	drawMap( loc, map, material );
454	}
455
456	private void drawMap(Location loc, boolean[][] map, Material material) {
457	int playerX = loc.getBlockX();
458	int playerY = loc.getBlockY();
459	int playerZ = loc.getBlockZ();
460
461	World world = loc.getWorld();
462
463	for (int i=0; i<map.length; i++) {
464	for (int j=0; j<map[0].length; j++) {
465
466	int x = playerX + i + 1;
467	int z = playerZ + j;
468
469	if (map[i][j] == true) {
470	for (int y=world.getHighestBlockYAt(x, z); y<playerY; y++) {
471	world.getBlockAt(x, y, z).setType(material);
472	}
473	}
474
475	}
476	}
477	}
478
479
480
481	}