hoeruputils/src/HoerupUtils.java


import java.util.logging.*;
import java.util.*;

public class HoerupUtils extends Plugin {

        final static Logger log = Logger.getLogger("HoerupUtils");

        //private boolean adminDestroy = false;
        private Set<String> adminDestroyers = new HashSet<String>();

        private void registerCommands() {
                etc e = etc.getInstance();
                e.addCommand("/setpos", "[x] [z] <height> - Teleports you to the given coordinates");
                e.addCommand("/whereis", "[player] - Tells you the position of another player");
                e.addCommand("/fillarea", "");
                e.addCommand("/levelarea", "");
                e.addCommand("/setsurface", "");
        }
        
        @Override
        public void disable() {
                registerCommands();
        }

        @Override
        public void enable() {
                etc e = etc.getInstance();
                e.removeCommand("/setpos");
                e.removeCommand("/whereis");
                e.removeCommand("/fillarea");
                e.removeCommand("/levelarea");
                e.removeCommand("/setsurface");
        }
        
        @Override 
        public void initialize() {
                PluginLoader loader = etc.getLoader();
                loader.addListener( PluginLoader.Hook.COMMAND, new HoerupUtilsPlugin(), this, PluginListener.Priority.MEDIUM );
                loader.addListener( PluginLoader.Hook.BLOCK_DESTROYED, new AdminDestroy(), this, PluginListener.Priority.MEDIUM );


                registerCommands();
        }

        final static int HAND_EMPTY = -1;


        public class AdminDestroy  extends PluginListener {     
                public boolean onBlockDestroy(Player player, Block block) {
                        if (player.isAdmin() && adminDestroyers.contains(player.getName() ) ) {
                                if (player.getItemInHand() == HAND_EMPTY) {
                                        block.setType(0);
                                        etc.getServer().setBlock(block);
                                        return true;
                                }
                        }
                        return false;
                }
        }

        public class HoerupUtilsPlugin extends PluginListener {
                final static String USAGE = "Usage: /setpos [x] [z] <height>";
                final static int BLOCK_AIR = 0; //block id = 0 is air
                final static int BLOCK_GRASS = 2;
                final static int BLOCK_DIRT = 3;

        
                //http://www.minecraftforum.net/viewtopic.php?f=35&t=14739
                //Y is height

                // air == blockID:0

                private int getGroundLevel(int x, int z) {
                        Server srv = etc.getServer();

                        int level = srv.getHighestBlockY(x,z);

                        if (level == -1)
                                level = 128;
                        return level;

/*
                        int y;

                        for (y=128; y>=0 && srv.getBlockIdAt(x,y-1,z) == AIRBLOCK; y--)
                                ;

                        System.out.println("Groundlevel: " + y);
                        System.out.println("getHighestBlockY: " + srv.getHighestBlockY(x,z) );

                        return y;
*/
                }


                private boolean isFree(int x, int y, int z) {
                        Server srv = etc.getServer();

                        return  (srv.getBlockIdAt(x,y,z) == BLOCK_AIR && srv.getBlockIdAt(x,y+1,z) == BLOCK_AIR);
                }

                
                public void adminDestroy(Player player, String[] split) {
                        String name = player.getName();
                        if (adminDestroyers.contains(name) ) {
                                adminDestroyers.remove(name);
                                player.sendMessage("Admindestroy disabled");
                        } else {
                                adminDestroyers.add(name);
                                player.sendMessage("Admindestroy enabled");
                        }
                }


                @Override
                public boolean onCommand(Player player, java.lang.String[] split) {
                        if ( split[0].equals("/admindestroy") && player.canUseCommand("/admindestroy") ) {
                                adminDestroy(player,split);
                                return true;
                        } else if( split[0].equals("/setpos") && player.canUseCommand("/setpos") ) {
                                setPos(player, split);
                                return true;
                        } else if ( split[0].equals("/whereis" ) && player.canUseCommand("/whereis")) {
                                whereIs(player, split);
                                return true;
                        } else if (split[0].equals("/levelarea") && player.canUseCommand("/levelarea")) {
                                if (validateLevelOrFill(player,split)) {
                                        levelArea(player, split);
                                }
                                return true;
                        } else if (split[0].equals("/fillarea") && player.canUseCommand("/fillarea")) {
                                if (validateLevelOrFill(player,split)) {
                                        fillArea(player, split);
                                }
                                return true;
                        } else if (split[0].equals("/setsurface") && player.canUseCommand("/setsurface")) {
                                setSurface(player,split);
                                return true;
                        } else {
                                return false;
                        }
        
                }

                int roundPos(double input) {
                        int result = (int) input;
                        if (input < 0.0) {
                                result--;
                        }

                        return result;
                }

                private void setSurface(Player player, String[] split) {
                        int valid_block_array[] = {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 35, 41, 42, 43, 44, 45, 46, 48, 49, 56, 57, 73, 74, 79, 80, 82} ;

                        final int BLOCK_MAX = 86;

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


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

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


                        int blockid;
                        try {
                                blockid = Integer.parseInt(split[2]);
                        } catch (Exception e) {
                                player.sendMessage("setsurface: 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 = roundPos( player.getX() );
                        int playerY = (int) player.getY();
                        int playerZ = roundPos( player.getZ() );

                        if(playerY <= 2 && blockid != 7) {
                                player.sendMessage("setsurface: at this level you may only use bedrock(id=7)");
                                return;
                        }
                        
                        Server srv = etc.getServer();

                        for (int x=(playerX-radius); x<=(playerX+radius); x++) {
                                for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
                                        int y = getGroundLevel(x,z) - 1;
                                        srv.setBlockAt(blockid, x, y, z);
                                }
                        }
                }

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

                        if (radius > 20) {
                                player.sendMessage(split[0] + ": radius may not exceed 20");
                                return false;
                        }
                        
                        if (split.length == 3) {
                                try {
                                        Integer.parseInt( split[2] );
                                } catch (Exception e) {
                                        player.sendMessage(split[0] + ": radius must be an integer");
                                        return false;
                                }
                        }

                        return true;
                }

                private void fillArea(Player player, String[] split) {
                        int radius = Integer.parseInt(split[1]);
                        
                        int material = BLOCK_DIRT;
                        if (split.length == 3) {
                                material = Integer.parseInt( split[2] );
                        }

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

                        int playerX = roundPos( player.getX() );
                        int playerY = (int) player.getY();
                        int playerZ = roundPos( player.getZ() );
                        
                        Server srv = etc.getServer();

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

                                        for (int y=getGroundLevel(x,z); y<playerY; y++) {
                                                srv.setBlockAt(material, x, y, z);
                                        }

                                }

                        }
                }

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

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

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

                        int playerX = roundPos( player.getX() );
                        int playerY = (int) player.getY();
                        int playerZ = roundPos( player.getZ() );
                        
                        Server srv = etc.getServer();

                        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<=128; y++) {
                                                count++;
                                                srv.setBlockAt(BLOCK_AIR, x, y, z);
                                        }

                                }

                        }
                }


         double roundToPlaces(double value, int places) {
                double pow = Math.pow(10, places);
                double temp = Math.round( value*pow );

                return temp / pow;
        }


        private String getBearingStr(int angle) {
                if (angle < 22) {
                        return "N";
                } else if (angle < 67) {
                        return "NE";
                } else if (angle < 112) {
                        return "E";
                } else if (angle < 157) {
                        return "SE";
                } else if (angle < 202) {
                        return "S";
                } else if (angle < 257) {
                        return "SW";
                } else if (angle < 292) {
                        return "W";
                } else if (angle < 337) {
                        return "NW";
                } else {
                        return "N";
                }
        }

        public void whereIs(Player p1, java.lang.String[] split) {
                if (split.length < 2 || split.length >3) {
                        p1.sendMessage( Colors.Rose + "usage: /whereis (playername|home|warp) <warpname>" );
                        return;
                }

                Location loc1 = p1.getLocation();
                Location loc2;
                String name2;

                if (split[1].equals("home") ) {
                        
                        Warp home = etc.getDataSource().getHome( p1.getName() );
                        if (home == null) {
                                p1.sendMessage(Colors.Rose + "you haven't set a home.");
                                return;
                        }
                        loc2 = home.Location;
                        name2 = "Your home";
                } else if (split[1].equals("warp")) {
                        if (split.length != 3) {
                                p1.sendMessage("you have to enter the name of the warp point");
                                return;
                        }
                        Warp warp = etc.getDataSource().getWarp( split[2] );
                        if (warp == null) {
                                p1.sendMessage("Found now warp with name " + split[2]);
                                return;
                        }
                        loc2 = warp.Location;
                        name2 = "Warppoint " + split[2];
                        

                } else {

                        Player p2 = etc.getServer().getPlayer(split[1]);

                        if (p2 == null) {
                                p1.sendMessage( Colors.Rose + "whereis: no player named " + split[1] );
                                return;
                        }
                        
                        loc2 = p2.getLocation();
                        name2 = p2.getName();
                }
                //Location loc2 = new Location();
                //loc2.x = loc2.y = loc2.z = 0;

//System.out.println("p1: " + loc1.x + "," + loc1.z );
//System.out.println("p2: " + loc2.x + "," + loc2.z );

                double distX =   loc1.x - loc2.x  ;
                double distZ =   loc1.z - loc2.z  ;

                int dist = (int) Math.round( Math.sqrt( (distX*distX) + (distZ*distZ)) );
/*System.out.println("distX:" + distX );
System.out.println("distZ:" + distZ );

System.out.println(">> " + (distZ / distX ) );*/

                double angle = Math.toDegrees( Math.atan( distZ / distX ) );
                if (angle < 0.0) 
                        angle += 90.0;


                if (distX >= 0.0 && distZ >= 0.0) { //both positive, 0-90 degrees
                        //do nothing
                } else if (distX < 0.0 && distZ >= 0.0) { // 90-180 degrees
                        angle += 90.0;
                } else if (distX < 0.0 && distZ < 0.0) {//Both negative 180-270 degrees
                        angle += 180.0; 
                } else {
                        angle += 270.0;
                }

                p1.sendMessage( Colors.Yellow + name2 + " is at x:" + roundToPlaces(loc2.x, 2) + " y:" + roundToPlaces(loc2.y, 2) + " z: " + roundToPlaces(loc2.z, 2) );
                p1.sendMessage( Colors.Yellow + "Distance is " + dist + " blocks" );
                p1.sendMessage( Colors.Yellow + "Bearing: " + (int) angle  + " (" + getBearingStr( (int) angle) + ")" );

                
        }


        public void setPos(Player player, java.lang.String[] split) {
                int x;
                int z;
                int y;

                int userY = 0;
                boolean hasY = false;

                if (split.length <3 || split.length > 4) {
                        player.sendMessage(USAGE);
                        return;
                }

                try {
                        x = Integer.parseInt( split[1] );
                        z = Integer.parseInt( split[2] );
                        if (split.length == 4) {
                                hasY = true;
                                userY = Integer.parseInt( split[3] );                                   
                        }
                } catch (Exception e) {
                        player.sendMessage("/setpos error: non numeric argument");
                        return;
                }


                if (hasY) {
                        if (isFree(x,userY,z)) {
                                y = userY;
                        } else {
                                player.sendMessage("/setpos: that position is not free");
                                return;
                        }
                } else {
                        y = getGroundLevel(x,z);
                }

                log.info("Transporting " + player.getName() + " to " + x + " " + z + "(" + y + ")" );


                Location newLocation = new Location();
                newLocation.rotY = player.getPitch();
                newLocation.rotX = player.getRotation();
                newLocation.x = x + 0.5;
                newLocation.z = z + 0.5;
                newLocation.y = y;
        
                player.teleportTo(newLocation);
                player.sendMessage("Whooooooosh");
        }
        }
}
1	torben	1166
2			import java.util.logging.*;
3	torben	1184	import java.util.*;
4	torben	1166
5	torben	1174	public class HoerupUtils extends Plugin {
6	torben	1166
7	torben	1174	final static Logger log = Logger.getLogger("HoerupUtils");
8	torben	1166
9	torben	1184	//private boolean adminDestroy = false;
10			private Set<String> adminDestroyers = new HashSet<String>();
11	torben	1183
12	torben	1178	private void registerCommands() {
13			etc e = etc.getInstance();
14			e.addCommand("/setpos", "[x] [z] <height> - Teleports you to the given coordinates");
15			e.addCommand("/whereis", "[player] - Tells you the position of another player");
16			e.addCommand("/fillarea", "");
17			e.addCommand("/levelarea", "");
18			e.addCommand("/setsurface", "");
19			}
20	torben	1166
21			@Override
22	torben	1178	public void disable() {
23			registerCommands();
24			}
25	torben	1166
26			@Override
27	torben	1178	public void enable() {
28			etc e = etc.getInstance();
29			e.removeCommand("/setpos");
30			e.removeCommand("/whereis");
31			e.removeCommand("/fillarea");
32			e.removeCommand("/levelarea");
33			e.removeCommand("/setsurface");
34			}
35	torben	1166
36			@Override
37			public void initialize() {
38			PluginLoader loader = etc.getLoader();
39	torben	1174	loader.addListener( PluginLoader.Hook.COMMAND, new HoerupUtilsPlugin(), this, PluginListener.Priority.MEDIUM );
40	torben	1183	loader.addListener( PluginLoader.Hook.BLOCK_DESTROYED, new AdminDestroy(), this, PluginListener.Priority.MEDIUM );
41	torben	1178
42	torben	1183
43	torben	1178	registerCommands();
44	torben	1166	}
45
46	torben	1184	final static int HAND_EMPTY = -1;
47	torben	1166
48	torben	1184
49	torben	1183	public class AdminDestroy extends PluginListener {
50			public boolean onBlockDestroy(Player player, Block block) {
51	torben	1184	if (player.isAdmin() && adminDestroyers.contains(player.getName() ) ) {
52			if (player.getItemInHand() == HAND_EMPTY) {
53			block.setType(0);
54			etc.getServer().setBlock(block);
55			return true;
56			}
57	torben	1183	}
58			return false;
59			}
60			}
61
62			public class HoerupUtilsPlugin extends PluginListener {
63	torben	1178	final static String USAGE = "Usage: /setpos [x] [z] <height>";
64	torben	1176	final static int BLOCK_AIR = 0; //block id = 0 is air
65			final static int BLOCK_GRASS = 2;
66			final static int BLOCK_DIRT = 3;
67	torben	1166
68
69
70			//http://www.minecraftforum.net/viewtopic.php?f=35&t=14739
71			//Y is height
72
73			// air == blockID:0
74
75			private int getGroundLevel(int x, int z) {
76			Server srv = etc.getServer();
77
78			int level = srv.getHighestBlockY(x,z);
79
80			if (level == -1)
81			level = 128;
82			return level;
83
84			/*
85			int y;
86
87			for (y=128; y>=0 && srv.getBlockIdAt(x,y-1,z) == AIRBLOCK; y--)
88			;
89
90			System.out.println("Groundlevel: " + y);
91			System.out.println("getHighestBlockY: " + srv.getHighestBlockY(x,z) );
92
93			return y;
94			*/
95			}
96
97
98			private boolean isFree(int x, int y, int z) {
99			Server srv = etc.getServer();
100
101	torben	1176	return (srv.getBlockIdAt(x,y,z) == BLOCK_AIR && srv.getBlockIdAt(x,y+1,z) == BLOCK_AIR);
102	torben	1166	}
103
104	torben	1184
105	torben	1166
106	torben	1184	public void adminDestroy(Player player, String[] split) {
107			String name = player.getName();
108			if (adminDestroyers.contains(name) ) {
109			adminDestroyers.remove(name);
110			player.sendMessage("Admindestroy disabled");
111			} else {
112			adminDestroyers.add(name);
113			player.sendMessage("Admindestroy enabled");
114			}
115			}
116	torben	1166
117	torben	1184
118	torben	1166	@Override
119			public boolean onCommand(Player player, java.lang.String[] split) {
120	torben	1183	if ( split[0].equals("/admindestroy") && player.canUseCommand("/admindestroy") ) {
121	torben	1184	adminDestroy(player,split);
122	torben	1183	return true;
123			} else if( split[0].equals("/setpos") && player.canUseCommand("/setpos") ) {
124	torben	1166	setPos(player, split);
125			return true;
126	torben	1170	} else if ( split[0].equals("/whereis" ) && player.canUseCommand("/whereis")) {
127	torben	1166	whereIs(player, split);
128			return true;
129	torben	1170	} else if (split[0].equals("/levelarea") && player.canUseCommand("/levelarea")) {
130	torben	1176	if (validateLevelOrFill(player,split)) {
131			levelArea(player, split);
132			}
133	torben	1169	return true;
134	torben	1176	} else if (split[0].equals("/fillarea") && player.canUseCommand("/fillarea")) {
135			if (validateLevelOrFill(player,split)) {
136			fillArea(player, split);
137			}
138			return true;
139	torben	1175	} else if (split[0].equals("/setsurface") && player.canUseCommand("/setsurface")) {
140			setSurface(player,split);
141			return true;
142	torben	1166	} else {
143			return false;
144			}
145
146			}
147
148	torben	1177	int roundPos(double input) {
149			int result = (int) input;
150			if (input < 0.0) {
151			result--;
152			}
153
154			return result;
155			}
156
157	torben	1175	private void setSurface(Player player, String[] split) {
158			int valid_block_array[] = {1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 35, 41, 42, 43, 44, 45, 46, 48, 49, 56, 57, 73, 74, 79, 80, 82} ;
159
160			final int BLOCK_MAX = 86;
161
162			if (split.length != 3) {
163	torben	1178	player.sendMessage("Usage /setsurface [radius] [blockID]");
164	torben	1175	return;
165			}
166
167
168			int radius;
169			try {
170			radius = Integer.parseInt(split[1]);
171			} catch (Exception e) {
172			player.sendMessage("setsurface: radius must be an integer");
173			return;
174			}
175
176			if (radius > 20) {
177			player.sendMessage("setsurface: radius may not exceed 20");
178			return;
179			}
180
181
182			int blockid;
183			try {
184			blockid = Integer.parseInt(split[2]);
185			} catch (Exception e) {
186			player.sendMessage("setsurface: 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	torben	1177	int playerX = roundPos( player.getX() );
204	torben	1175	int playerY = (int) player.getY();
205	torben	1177	int playerZ = roundPos( player.getZ() );
206	torben	1175
207			if(playerY <= 2 && blockid != 7) {
208			player.sendMessage("setsurface: at this level you may only use bedrock(id=7)");
209			return;
210			}
211
212			Server srv = etc.getServer();
213
214			for (int x=(playerX-radius); x<=(playerX+radius); x++) {
215			for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
216			int y = getGroundLevel(x,z) - 1;
217			srv.setBlockAt(blockid, x, y, z);
218			}
219			}
220			}
221
222	torben	1176	private boolean validateLevelOrFill(Player player, String[] split) {
223	torben	1183	if (split.length < 2 \|\| split.length > 3) {
224	torben	1178	player.sendMessage("Usage: " + split[0] + " [radius]");
225	torben	1176	return false;
226	torben	1169	}
227
228			int radius;
229			try {
230			radius = Integer.parseInt(split[1]);
231			} catch (Exception e) {
232	torben	1176	player.sendMessage(split[0] + ": radius must be an integer");
233			return false;
234	torben	1169	}
235	torben	1166
236	torben	1169	if (radius > 20) {
237	torben	1176	player.sendMessage(split[0] + ": radius may not exceed 20");
238			return false;
239	torben	1169	}
240	torben	1183
241			if (split.length == 3) {
242			try {
243			Integer.parseInt( split[2] );
244			} catch (Exception e) {
245			player.sendMessage(split[0] + ": radius must be an integer");
246			return false;
247			}
248			}
249	torben	1166
250	torben	1176	return true;
251			}
252	torben	1169
253	torben	1176	private void fillArea(Player player, String[] split) {
254			int radius = Integer.parseInt(split[1]);
255	torben	1183
256			int material = BLOCK_DIRT;
257			if (split.length == 3) {
258			material = Integer.parseInt( split[2] );
259			}
260	torben	1175
261	torben	1176	System.out.println("Player " + player.getName() + " used fillarea with radius=" + radius);
262
263
264	torben	1177	int playerX = roundPos( player.getX() );
265	torben	1176	int playerY = (int) player.getY();
266	torben	1177	int playerZ = roundPos( player.getZ() );
267	torben	1176
268			Server srv = etc.getServer();
269
270			for (int x=(playerX-radius); x<=(playerX+radius); x++) {
271			for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
272
273			for (int y=getGroundLevel(x,z); y<playerY; y++) {
274	torben	1183	srv.setBlockAt(material, x, y, z);
275	torben	1176	}
276
277			}
278
279			}
280			}
281
282			private void levelArea(Player player, String[] split) {
283
284			int radius = Integer.parseInt(split[1]);
285
286	torben	1169	System.out.println("Player " + player.getName() + " used levelarea with radius=" + radius);
287
288
289	torben	1177	int playerX = roundPos( player.getX() );
290	torben	1169	int playerY = (int) player.getY();
291	torben	1177	int playerZ = roundPos( player.getZ() );
292	torben	1169
293			Server srv = etc.getServer();
294
295			int count = 0;
296			for (int x=(playerX-radius); x<=(playerX+radius); x++) {
297			for (int z=(playerZ-radius); z<=(playerZ+radius); z++) {
298
299			//for (int y=playerY; y<=playerY+radius; y++) {
300			for (int y=playerY; y<=128; y++) {
301			count++;
302	torben	1176	srv.setBlockAt(BLOCK_AIR, x, y, z);
303	torben	1169	}
304
305			}
306
307			}
308			}
309
310
311
312	torben	1166	double roundToPlaces(double value, int places) {
313			double pow = Math.pow(10, places);
314			double temp = Math.round( value*pow );
315
316			return temp / pow;
317			}
318
319
320			private String getBearingStr(int angle) {
321			if (angle < 22) {
322			return "N";
323			} else if (angle < 67) {
324			return "NE";
325			} else if (angle < 112) {
326			return "E";
327			} else if (angle < 157) {
328			return "SE";
329			} else if (angle < 202) {
330			return "S";
331			} else if (angle < 257) {
332			return "SW";
333			} else if (angle < 292) {
334			return "W";
335			} else if (angle < 337) {
336			return "NW";
337			} else {
338			return "N";
339			}
340			}
341
342			public void whereIs(Player p1, java.lang.String[] split) {
343	torben	1167	if (split.length < 2 \|\| split.length >3) {
344	torben	1178	p1.sendMessage( Colors.Rose + "usage: /whereis (playername\|home\|warp) <warpname>" );
345	torben	1166	return;
346			}
347
348	torben	1167	Location loc1 = p1.getLocation();
349			Location loc2;
350			String name2;
351
352			if (split[1].equals("home") ) {
353
354			Warp home = etc.getDataSource().getHome( p1.getName() );
355			if (home == null) {
356			p1.sendMessage(Colors.Rose + "you haven't set a home.");
357			return;
358			}
359			loc2 = home.Location;
360			name2 = "Your home";
361			} else if (split[1].equals("warp")) {
362			if (split.length != 3) {
363			p1.sendMessage("you have to enter the name of the warp point");
364			return;
365			}
366			Warp warp = etc.getDataSource().getWarp( split[2] );
367			if (warp == null) {
368			p1.sendMessage("Found now warp with name " + split[2]);
369			return;
370			}
371			loc2 = warp.Location;
372			name2 = "Warppoint " + split[2];
373
374
375			} else {
376
377			Player p2 = etc.getServer().getPlayer(split[1]);
378
379			if (p2 == null) {
380			p1.sendMessage( Colors.Rose + "whereis: no player named " + split[1] );
381			return;
382			}
383
384			loc2 = p2.getLocation();
385			name2 = p2.getName();
386	torben	1166	}
387			//Location loc2 = new Location();
388			//loc2.x = loc2.y = loc2.z = 0;
389
390			//System.out.println("p1: " + loc1.x + "," + loc1.z );
391			//System.out.println("p2: " + loc2.x + "," + loc2.z );
392
393			double distX = loc1.x - loc2.x ;
394			double distZ = loc1.z - loc2.z ;
395
396			int dist = (int) Math.round( Math.sqrt( (distXdistX) + (distZdistZ)) );
397			/*System.out.println("distX:" + distX );
398			System.out.println("distZ:" + distZ );
399
400			System.out.println(">> " + (distZ / distX ) );*/
401
402			double angle = Math.toDegrees( Math.atan( distZ / distX ) );
403			if (angle < 0.0)
404			angle += 90.0;
405
406
407			if (distX >= 0.0 && distZ >= 0.0) { //both positive, 0-90 degrees
408			//do nothing
409			} else if (distX < 0.0 && distZ >= 0.0) { // 90-180 degrees
410			angle += 90.0;
411			} else if (distX < 0.0 && distZ < 0.0) {//Both negative 180-270 degrees
412			angle += 180.0;
413			} else {
414			angle += 270.0;
415			}
416
417	torben	1167	p1.sendMessage( Colors.Yellow + name2 + " is at x:" + roundToPlaces(loc2.x, 2) + " y:" + roundToPlaces(loc2.y, 2) + " z: " + roundToPlaces(loc2.z, 2) );
418	torben	1166	p1.sendMessage( Colors.Yellow + "Distance is " + dist + " blocks" );
419			p1.sendMessage( Colors.Yellow + "Bearing: " + (int) angle + " (" + getBearingStr( (int) angle) + ")" );
420
421
422
423			}
424
425
426			public void setPos(Player player, java.lang.String[] split) {
427			int x;
428			int z;
429			int y;
430
431			int userY = 0;
432			boolean hasY = false;
433
434			if (split.length <3 \|\| split.length > 4) {
435			player.sendMessage(USAGE);
436			return;
437			}
438
439			try {
440			x = Integer.parseInt( split[1] );
441			z = Integer.parseInt( split[2] );
442			if (split.length == 4) {
443			hasY = true;
444			userY = Integer.parseInt( split[3] );
445			}
446			} catch (Exception e) {
447			player.sendMessage("/setpos error: non numeric argument");
448			return;
449			}
450
451
452
453			if (hasY) {
454			if (isFree(x,userY,z)) {
455			y = userY;
456			} else {
457			player.sendMessage("/setpos: that position is not free");
458			return;
459			}
460			} else {
461			y = getGroundLevel(x,z);
462			}
463
464			log.info("Transporting " + player.getName() + " to " + x + " " + z + "(" + y + ")" );
465
466
467			Location newLocation = new Location();
468			newLocation.rotY = player.getPitch();
469			newLocation.rotX = player.getRotation();
470			newLocation.x = x + 0.5;
471			newLocation.z = z + 0.5;
472			newLocation.y = y;
473
474			player.teleportTo(newLocation);
475			player.sendMessage("Whooooooosh");
476			}
477			}
478			}