001 package net.minecraft.src;
002
003 import cpw.mods.fml.common.Side;
004 import cpw.mods.fml.common.asm.SideOnly;
005 import java.io.File;
006 import java.net.SocketAddress;
007 import java.text.SimpleDateFormat;
008 import java.util.ArrayList;
009 import java.util.HashSet;
010 import java.util.Iterator;
011 import java.util.List;
012 import java.util.Set;
013 import java.util.logging.Logger;
014
015 import cpw.mods.fml.common.network.FMLNetworkHandler;
016 import cpw.mods.fml.common.network.NetworkRegistry;
017 import cpw.mods.fml.common.registry.GameRegistry;
018 import net.minecraft.server.MinecraftServer;
019 import net.minecraftforge.common.DimensionManager;
020
021 public abstract class ServerConfigurationManager
022 {
023 private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z");
024
025 /** Reference to the logger. */
026 public static final Logger logger = Logger.getLogger("Minecraft");
027
028 /** Reference to the MinecraftServer object. */
029 private final MinecraftServer mcServer;
030
031 /** A list of player entities that exist on this server. */
032 public final List playerEntityList = new ArrayList();
033 private final BanList bannedPlayers = new BanList(new File("banned-players.txt"));
034 private final BanList bannedIPs = new BanList(new File("banned-ips.txt"));
035
036 /** A set containing the OPs. */
037 private Set ops = new HashSet();
038
039 /** The Set of all whitelisted players. */
040 private Set whiteListedPlayers = new HashSet();
041
042 /** Reference to the PlayerNBTManager object. */
043 private IPlayerFileData playerNBTManagerObj;
044
045 /**
046 * Server setting to only allow OPs and whitelisted players to join the server.
047 */
048 private boolean whiteListEnforced;
049
050 /** The maximum number of players that can be connected at a time. */
051 protected int maxPlayers;
052 protected int viewDistance;
053 private EnumGameType gameType;
054
055 /** True if all players are allowed to use commands (cheats). */
056 private boolean commandsAllowedForAll;
057
058 /**
059 * index into playerEntities of player to ping, updated every tick; currently hardcoded to max at 200 players
060 */
061 private int playerPingIndex = 0;
062
063 public ServerConfigurationManager(MinecraftServer par1MinecraftServer)
064 {
065 this.mcServer = par1MinecraftServer;
066 this.bannedPlayers.setListActive(false);
067 this.bannedIPs.setListActive(false);
068 this.maxPlayers = 8;
069 }
070
071 public void initializeConnectionToPlayer(NetworkManager par1NetworkManager, EntityPlayerMP par2EntityPlayerMP)
072 {
073 this.readPlayerDataFromFile(par2EntityPlayerMP);
074 par2EntityPlayerMP.setWorld(this.mcServer.worldServerForDimension(par2EntityPlayerMP.dimension));
075 par2EntityPlayerMP.theItemInWorldManager.setWorld((WorldServer)par2EntityPlayerMP.worldObj);
076 String var3 = "local";
077
078 if (par1NetworkManager.getSocketAddress() != null)
079 {
080 var3 = par1NetworkManager.getSocketAddress().toString();
081 }
082
083 logger.info(par2EntityPlayerMP.username + "[" + var3 + "] logged in with entity id " + par2EntityPlayerMP.entityId + " at (" + par2EntityPlayerMP.posX + ", " + par2EntityPlayerMP.posY + ", " + par2EntityPlayerMP.posZ + ")");
084 WorldServer var4 = this.mcServer.worldServerForDimension(par2EntityPlayerMP.dimension);
085 ChunkCoordinates var5 = var4.getSpawnPoint();
086 this.func_72381_a(par2EntityPlayerMP, (EntityPlayerMP)null, var4);
087 NetServerHandler var6 = new NetServerHandler(this.mcServer, par1NetworkManager, par2EntityPlayerMP);
088 var6.sendPacketToPlayer(new Packet1Login(par2EntityPlayerMP.entityId, var4.getWorldInfo().getTerrainType(), par2EntityPlayerMP.theItemInWorldManager.getGameType(), var4.getWorldInfo().isHardcoreModeEnabled(), var4.provider.dimensionId, var4.difficultySetting, var4.getHeight(), this.getMaxPlayers()));
089 var6.sendPacketToPlayer(new Packet6SpawnPosition(var5.posX, var5.posY, var5.posZ));
090 var6.sendPacketToPlayer(new Packet202PlayerAbilities(par2EntityPlayerMP.capabilities));
091 this.updateTimeAndWeatherForPlayer(par2EntityPlayerMP, var4);
092 this.sendPacketToAllPlayers(new Packet3Chat("\u00a7e" + par2EntityPlayerMP.username + " joined the game."));
093 this.playerLoggedIn(par2EntityPlayerMP);
094 var6.setPlayerLocation(par2EntityPlayerMP.posX, par2EntityPlayerMP.posY, par2EntityPlayerMP.posZ, par2EntityPlayerMP.rotationYaw, par2EntityPlayerMP.rotationPitch);
095 this.mcServer.getNetworkThread().addPlayer(var6);
096 var6.sendPacketToPlayer(new Packet4UpdateTime(var4.getWorldTime()));
097
098 if (this.mcServer.getTexturePack().length() > 0)
099 {
100 par2EntityPlayerMP.requestTexturePackLoad(this.mcServer.getTexturePack(), this.mcServer.textureSize());
101 }
102
103 Iterator var7 = par2EntityPlayerMP.getActivePotionEffects().iterator();
104
105 while (var7.hasNext())
106 {
107 PotionEffect var8 = (PotionEffect)var7.next();
108 var6.sendPacketToPlayer(new Packet41EntityEffect(par2EntityPlayerMP.entityId, var8));
109 }
110
111 par2EntityPlayerMP.addSelfToInternalCraftingInventory();
112 FMLNetworkHandler.handlePlayerLogin(par2EntityPlayerMP, var6, par1NetworkManager);
113 }
114
115 /**
116 * Sets the NBT manager to the one for the WorldServer given.
117 */
118 public void setPlayerManager(WorldServer[] par1ArrayOfWorldServer)
119 {
120 this.playerNBTManagerObj = par1ArrayOfWorldServer[0].getSaveHandler().getSaveHandler();
121 }
122
123 public void func_72375_a(EntityPlayerMP par1EntityPlayerMP, WorldServer par2WorldServer)
124 {
125 WorldServer var3 = par1EntityPlayerMP.getServerForPlayer();
126
127 if (par2WorldServer != null)
128 {
129 par2WorldServer.getPlayerManager().removePlayer(par1EntityPlayerMP);
130 }
131
132 var3.getPlayerManager().addPlayer(par1EntityPlayerMP);
133 var3.theChunkProviderServer.loadChunk((int)par1EntityPlayerMP.posX >> 4, (int)par1EntityPlayerMP.posZ >> 4);
134 }
135
136 public int getEntityViewDistance()
137 {
138 return PlayerManager.func_72686_a(this.getViewDistance());
139 }
140
141 /**
142 * called during player login. reads the player information from disk.
143 */
144 public void readPlayerDataFromFile(EntityPlayerMP par1EntityPlayerMP)
145 {
146 NBTTagCompound var2 = this.mcServer.worldServers[0].getWorldInfo().getPlayerNBTTagCompound();
147
148 if (par1EntityPlayerMP.getCommandSenderName().equals(this.mcServer.getServerOwner()) && var2 != null)
149 {
150 par1EntityPlayerMP.readFromNBT(var2);
151 }
152 else
153 {
154 this.playerNBTManagerObj.readPlayerData(par1EntityPlayerMP);
155 }
156 }
157
158 /**
159 * also stores the NBTTags if this is an intergratedPlayerList
160 */
161 protected void writePlayerData(EntityPlayerMP par1EntityPlayerMP)
162 {
163 this.playerNBTManagerObj.writePlayerData(par1EntityPlayerMP);
164 }
165
166 /**
167 * Called when a player successfully logs in. Reads player data from disk and inserts the player into the world.
168 */
169 public void playerLoggedIn(EntityPlayerMP par1EntityPlayerMP)
170 {
171 this.sendPacketToAllPlayers(new Packet201PlayerInfo(par1EntityPlayerMP.username, true, 1000));
172 this.playerEntityList.add(par1EntityPlayerMP);
173 WorldServer var2 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
174
175 while (!var2.getCollidingBoundingBoxes(par1EntityPlayerMP, par1EntityPlayerMP.boundingBox).isEmpty())
176 {
177 par1EntityPlayerMP.setPosition(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY + 1.0D, par1EntityPlayerMP.posZ);
178 }
179
180 var2.spawnEntityInWorld(par1EntityPlayerMP);
181 this.func_72375_a(par1EntityPlayerMP, (WorldServer)null);
182 Iterator var3 = this.playerEntityList.iterator();
183
184 while (var3.hasNext())
185 {
186 EntityPlayerMP var4 = (EntityPlayerMP)var3.next();
187 par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet201PlayerInfo(var4.username, true, var4.ping));
188 }
189 }
190
191 /**
192 * using player's dimension, update their movement when in a vehicle (e.g. cart, boat)
193 */
194 public void serverUpdateMountedMovingPlayer(EntityPlayerMP par1EntityPlayerMP)
195 {
196 par1EntityPlayerMP.getServerForPlayer().getPlayerManager().updateMountedMovingPlayer(par1EntityPlayerMP);
197 }
198
199 /**
200 * Called when a player disconnects from the game. Writes player data to disk and removes them from the world.
201 */
202 public void playerLoggedOut(EntityPlayerMP par1EntityPlayerMP)
203 {
204 GameRegistry.onPlayerLogout(par1EntityPlayerMP);
205 this.writePlayerData(par1EntityPlayerMP);
206 WorldServer var2 = par1EntityPlayerMP.getServerForPlayer();
207 var2.setEntityDead(par1EntityPlayerMP);
208 var2.getPlayerManager().removePlayer(par1EntityPlayerMP);
209 this.playerEntityList.remove(par1EntityPlayerMP);
210 this.sendPacketToAllPlayers(new Packet201PlayerInfo(par1EntityPlayerMP.username, false, 9999));
211 }
212
213 /**
214 * checks ban-lists, then white-lists, then space for the server. Returns null on success, or an error message
215 */
216 public String allowUserToConnect(SocketAddress par1SocketAddress, String par2Str)
217 {
218 if (this.bannedPlayers.isBanned(par2Str))
219 {
220 BanEntry var6 = (BanEntry)this.bannedPlayers.getBannedList().get(par2Str);
221 String var7 = "You are banned from this server!\nReason: " + var6.getBanReason();
222
223 if (var6.getBanEndDate() != null)
224 {
225 var7 = var7 + "\nYour ban will be removed on " + dateFormat.format(var6.getBanEndDate());
226 }
227
228 return var7;
229 }
230 else if (!this.isAllowedToLogin(par2Str))
231 {
232 return "You are not white-listed on this server!";
233 }
234 else
235 {
236 String var3 = par1SocketAddress.toString();
237 var3 = var3.substring(var3.indexOf("/") + 1);
238 var3 = var3.substring(0, var3.indexOf(":"));
239
240 if (this.bannedIPs.isBanned(var3))
241 {
242 BanEntry var4 = (BanEntry)this.bannedIPs.getBannedList().get(var3);
243 String var5 = "Your IP address is banned from this server!\nReason: " + var4.getBanReason();
244
245 if (var4.getBanEndDate() != null)
246 {
247 var5 = var5 + "\nYour ban will be removed on " + dateFormat.format(var4.getBanEndDate());
248 }
249
250 return var5;
251 }
252 else
253 {
254 return this.playerEntityList.size() >= this.maxPlayers ? "The server is full!" : null;
255 }
256 }
257 }
258
259 /**
260 * also checks for multiple logins
261 */
262 public EntityPlayerMP createPlayerForUser(String par1Str)
263 {
264 ArrayList var2 = new ArrayList();
265 Iterator var3 = this.playerEntityList.iterator();
266 EntityPlayerMP var4;
267
268 while (var3.hasNext())
269 {
270 var4 = (EntityPlayerMP)var3.next();
271
272 if (var4.username.equalsIgnoreCase(par1Str))
273 {
274 var2.add(var4);
275 }
276 }
277
278 var3 = var2.iterator();
279
280 while (var3.hasNext())
281 {
282 var4 = (EntityPlayerMP)var3.next();
283 var4.playerNetServerHandler.kickPlayerFromServer("You logged in from another location");
284 }
285
286 Object var5;
287
288 if (this.mcServer.isDemo())
289 {
290 var5 = new DemoWorldManager(this.mcServer.worldServerForDimension(0));
291 }
292 else
293 {
294 var5 = new ItemInWorldManager(this.mcServer.worldServerForDimension(0));
295 }
296
297 return new EntityPlayerMP(this.mcServer, this.mcServer.worldServerForDimension(0), par1Str, (ItemInWorldManager)var5);
298 }
299
300 /**
301 * creates and returns a respawned player based on the provided PlayerEntity. Args are the PlayerEntityMP to
302 * respawn, an INT for the dimension to respawn into (usually 0), and a boolean value that is true if the player
303 * beat the game rather than dying
304 */
305 public EntityPlayerMP respawnPlayer(EntityPlayerMP par1EntityPlayerMP, int par2, boolean par3)
306 {
307 World world = mcServer.worldServerForDimension(par2);
308 if (world == null || !world.provider.canRespawnHere())
309 {
310 par2 = 0;
311 }
312
313 par1EntityPlayerMP.getServerForPlayer().getEntityTracker().removeAllTrackingPlayers(par1EntityPlayerMP);
314 par1EntityPlayerMP.getServerForPlayer().getEntityTracker().removeEntityFromAllTrackingPlayers(par1EntityPlayerMP);
315 par1EntityPlayerMP.getServerForPlayer().getPlayerManager().removePlayer(par1EntityPlayerMP);
316 this.playerEntityList.remove(par1EntityPlayerMP);
317 this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension).removeEntity(par1EntityPlayerMP);
318 ChunkCoordinates var4 = par1EntityPlayerMP.getSpawnChunk();
319 par1EntityPlayerMP.dimension = par2;
320 Object var5;
321
322 if (this.mcServer.isDemo())
323 {
324 var5 = new DemoWorldManager(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
325 }
326 else
327 {
328 var5 = new ItemInWorldManager(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
329 }
330
331 EntityPlayerMP var6 = new EntityPlayerMP(this.mcServer, this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension), par1EntityPlayerMP.username, (ItemInWorldManager)var5);
332 var6.clonePlayer(par1EntityPlayerMP, par3);
333 var6.dimension = par2;
334 var6.entityId = par1EntityPlayerMP.entityId;
335 var6.playerNetServerHandler = par1EntityPlayerMP.playerNetServerHandler;
336 WorldServer var7 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
337 this.func_72381_a(var6, par1EntityPlayerMP, var7);
338 ChunkCoordinates var8;
339
340 if (var4 != null)
341 {
342 var8 = EntityPlayer.verifyRespawnCoordinates(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension), var4);
343
344 if (var8 != null)
345 {
346 var6.setLocationAndAngles((double)((float)var8.posX + 0.5F), (double)((float)var8.posY + 0.1F), (double)((float)var8.posZ + 0.5F), 0.0F, 0.0F);
347 var6.setSpawnChunk(var4);
348 }
349 else
350 {
351 var6.playerNetServerHandler.sendPacketToPlayer(new Packet70GameEvent(0, 0));
352 }
353 }
354
355 var7.theChunkProviderServer.loadChunk((int)var6.posX >> 4, (int)var6.posZ >> 4);
356
357 while (!var7.getCollidingBoundingBoxes(var6, var6.boundingBox).isEmpty())
358 {
359 var6.setPosition(var6.posX, var6.posY + 1.0D, var6.posZ);
360 }
361
362 var6.playerNetServerHandler.sendPacketToPlayer(new Packet9Respawn(var6.dimension, (byte)var6.worldObj.difficultySetting, var6.worldObj.getWorldInfo().getTerrainType(), var6.worldObj.getHeight(), var6.theItemInWorldManager.getGameType()));
363 var8 = var7.getSpawnPoint();
364 var6.playerNetServerHandler.setPlayerLocation(var6.posX, var6.posY, var6.posZ, var6.rotationYaw, var6.rotationPitch);
365 var6.playerNetServerHandler.sendPacketToPlayer(new Packet6SpawnPosition(var8.posX, var8.posY, var8.posZ));
366 this.updateTimeAndWeatherForPlayer(var6, var7);
367 var7.getPlayerManager().addPlayer(var6);
368 var7.spawnEntityInWorld(var6);
369 this.playerEntityList.add(var6);
370 var6.addSelfToInternalCraftingInventory();
371 GameRegistry.onPlayerRespawn(var6);
372 return var6;
373 }
374
375 public void transferPlayerToDimension(EntityPlayerMP par1EntityPlayerMP, int par2)
376 {
377 transferPlayerToDimension(par1EntityPlayerMP, par2, new Teleporter());
378 }
379
380 public void transferPlayerToDimension(EntityPlayerMP par1EntityPlayerMP, int par2, Teleporter teleporter)
381 {
382 int var3 = par1EntityPlayerMP.dimension;
383 WorldServer var4 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
384 par1EntityPlayerMP.dimension = par2;
385 WorldServer var5 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
386 par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet9Respawn(par1EntityPlayerMP.dimension, (byte)par1EntityPlayerMP.worldObj.difficultySetting, var5.getWorldInfo().getTerrainType(), var5.getHeight(), par1EntityPlayerMP.theItemInWorldManager.getGameType()));
387 var4.removeEntity(par1EntityPlayerMP);
388 par1EntityPlayerMP.isDead = false;
389
390 WorldProvider pOld = DimensionManager.getProvider(var3);
391 WorldProvider pNew = DimensionManager.getProvider(par2);
392 double moveFactor = pOld.getMovementFactor() / pNew.getMovementFactor();
393 double var6 = par1EntityPlayerMP.posX * moveFactor;
394 double var8 = par1EntityPlayerMP.posZ * moveFactor;
395
396 if (par1EntityPlayerMP.dimension == 1)
397 {
398 ChunkCoordinates var12 = var5.getEntrancePortalLocation();
399 var6 = (double)var12.posX;
400 par1EntityPlayerMP.posY = (double)var12.posY;
401 var8 = (double)var12.posZ;
402 par1EntityPlayerMP.setLocationAndAngles(var6, par1EntityPlayerMP.posY, var8, 90.0F, 0.0F);
403
404 if (par1EntityPlayerMP.isEntityAlive())
405 {
406 var4.updateEntityWithOptionalForce(par1EntityPlayerMP, false);
407 }
408 }
409
410 if (var3 != 1)
411 {
412 var6 = (double)MathHelper.clamp_int((int)var6, -29999872, 29999872);
413 var8 = (double)MathHelper.clamp_int((int)var8, -29999872, 29999872);
414
415 if (par1EntityPlayerMP.isEntityAlive())
416 {
417 var5.spawnEntityInWorld(par1EntityPlayerMP);
418 par1EntityPlayerMP.setLocationAndAngles(var6, par1EntityPlayerMP.posY, var8, par1EntityPlayerMP.rotationYaw, par1EntityPlayerMP.rotationPitch);
419 var5.updateEntityWithOptionalForce(par1EntityPlayerMP, false);
420 teleporter.placeInPortal(var5, par1EntityPlayerMP);
421 }
422 }
423
424 par1EntityPlayerMP.setWorld(var5);
425 this.func_72375_a(par1EntityPlayerMP, var4);
426 par1EntityPlayerMP.playerNetServerHandler.setPlayerLocation(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY, par1EntityPlayerMP.posZ, par1EntityPlayerMP.rotationYaw, par1EntityPlayerMP.rotationPitch);
427 par1EntityPlayerMP.theItemInWorldManager.setWorld(var5);
428 this.updateTimeAndWeatherForPlayer(par1EntityPlayerMP, var5);
429 this.syncPlayerInventory(par1EntityPlayerMP);
430 Iterator var14 = par1EntityPlayerMP.getActivePotionEffects().iterator();
431
432 while (var14.hasNext())
433 {
434 PotionEffect var13 = (PotionEffect)var14.next();
435 par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet41EntityEffect(par1EntityPlayerMP.entityId, var13));
436 }
437
438 GameRegistry.onPlayerChangedDimension(par1EntityPlayerMP);
439 }
440
441 /**
442 * sends 1 player per tick, but only sends a player once every 600 ticks
443 */
444 public void sendPlayerInfoToAllPlayers()
445 {
446 if (++this.playerPingIndex > 600)
447 {
448 this.playerPingIndex = 0;
449 }
450
451 if (this.playerPingIndex < this.playerEntityList.size())
452 {
453 EntityPlayerMP var1 = (EntityPlayerMP)this.playerEntityList.get(this.playerPingIndex);
454 this.sendPacketToAllPlayers(new Packet201PlayerInfo(var1.username, true, var1.ping));
455 }
456 }
457
458 /**
459 * sends a packet to all players
460 */
461 public void sendPacketToAllPlayers(Packet par1Packet)
462 {
463 for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
464 {
465 ((EntityPlayerMP)this.playerEntityList.get(var2)).playerNetServerHandler.sendPacketToPlayer(par1Packet);
466 }
467 }
468
469 /**
470 * Sends a packet to all players in the specified Dimension
471 */
472 public void sendPacketToAllPlayersInDimension(Packet par1Packet, int par2)
473 {
474 Iterator var3 = this.playerEntityList.iterator();
475
476 while (var3.hasNext())
477 {
478 EntityPlayerMP var4 = (EntityPlayerMP)var3.next();
479
480 if (var4.dimension == par2)
481 {
482 var4.playerNetServerHandler.sendPacketToPlayer(par1Packet);
483 }
484 }
485 }
486
487 /**
488 * returns a string containing a comma-seperated list of player names
489 */
490 public String getPlayerListAsString()
491 {
492 String var1 = "";
493
494 for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
495 {
496 if (var2 > 0)
497 {
498 var1 = var1 + ", ";
499 }
500
501 var1 = var1 + ((EntityPlayerMP)this.playerEntityList.get(var2)).username;
502 }
503
504 return var1;
505 }
506
507 /**
508 * Returns an array of the usernames of all the connected players.
509 */
510 public String[] getAllUsernames()
511 {
512 String[] var1 = new String[this.playerEntityList.size()];
513
514 for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
515 {
516 var1[var2] = ((EntityPlayerMP)this.playerEntityList.get(var2)).username;
517 }
518
519 return var1;
520 }
521
522 public BanList getBannedPlayers()
523 {
524 return this.bannedPlayers;
525 }
526
527 public BanList getBannedIPs()
528 {
529 return this.bannedIPs;
530 }
531
532 /**
533 * This adds a username to the ops list, then saves the op list
534 */
535 public void addOp(String par1Str)
536 {
537 this.ops.add(par1Str.toLowerCase());
538 }
539
540 /**
541 * This removes a username from the ops list, then saves the op list
542 */
543 public void removeOp(String par1Str)
544 {
545 this.ops.remove(par1Str.toLowerCase());
546 }
547
548 /**
549 * Determine if the player is allowed to connect based on current server settings.
550 */
551 public boolean isAllowedToLogin(String par1Str)
552 {
553 par1Str = par1Str.trim().toLowerCase();
554 return !this.whiteListEnforced || this.ops.contains(par1Str) || this.whiteListedPlayers.contains(par1Str);
555 }
556
557 /**
558 * Returns true if the specific player is allowed to use commands.
559 */
560 public boolean areCommandsAllowed(String par1Str)
561 {
562 return this.ops.contains(par1Str.trim().toLowerCase()) || this.mcServer.isSinglePlayer() && this.mcServer.worldServers[0].getWorldInfo().areCommandsAllowed() && this.mcServer.getServerOwner().equalsIgnoreCase(par1Str) || this.commandsAllowedForAll;
563 }
564
565 public EntityPlayerMP getPlayerForUsername(String par1Str)
566 {
567 Iterator var2 = this.playerEntityList.iterator();
568 EntityPlayerMP var3;
569
570 do
571 {
572 if (!var2.hasNext())
573 {
574 return null;
575 }
576
577 var3 = (EntityPlayerMP)var2.next();
578 }
579 while (!var3.username.equalsIgnoreCase(par1Str));
580
581 return var3;
582 }
583
584 /**
585 * params: x,y,z,d,dimension. The packet is sent to all players within d distance of x,y,z (d^2<x^2+y^2+z^2)
586 */
587 public void sendToAllNear(double par1, double par3, double par5, double par7, int par9, Packet par10Packet)
588 {
589 this.sendToAllNearExcept((EntityPlayer)null, par1, par3, par5, par7, par9, par10Packet);
590 }
591
592 /**
593 * params: srcPlayer,x,y,z,d,dimension. The packet is not sent to the srcPlayer, but all other players where
594 * dx*dx+dy*dy+dz*dz<d*d
595 */
596 public void sendToAllNearExcept(EntityPlayer par1EntityPlayer, double par2, double par4, double par6, double par8, int par10, Packet par11Packet)
597 {
598 Iterator var12 = this.playerEntityList.iterator();
599
600 while (var12.hasNext())
601 {
602 EntityPlayerMP var13 = (EntityPlayerMP)var12.next();
603
604 if (var13 != par1EntityPlayer && var13.dimension == par10)
605 {
606 double var14 = par2 - var13.posX;
607 double var16 = par4 - var13.posY;
608 double var18 = par6 - var13.posZ;
609
610 if (var14 * var14 + var16 * var16 + var18 * var18 < par8 * par8)
611 {
612 var13.playerNetServerHandler.sendPacketToPlayer(par11Packet);
613 }
614 }
615 }
616 }
617
618 /**
619 * Saves all of the players' current states.
620 */
621 public void saveAllPlayerData()
622 {
623 Iterator var1 = this.playerEntityList.iterator();
624
625 while (var1.hasNext())
626 {
627 EntityPlayerMP var2 = (EntityPlayerMP)var1.next();
628 this.writePlayerData(var2);
629 }
630 }
631
632 /**
633 * Add the specified player to the white list.
634 */
635 public void addToWhiteList(String par1Str)
636 {
637 this.whiteListedPlayers.add(par1Str);
638 }
639
640 /**
641 * Remove the specified player from the whitelist.
642 */
643 public void removeFromWhitelist(String par1Str)
644 {
645 this.whiteListedPlayers.remove(par1Str);
646 }
647
648 /**
649 * Returns the whitelisted players.
650 */
651 public Set getWhiteListedPlayers()
652 {
653 return this.whiteListedPlayers;
654 }
655
656 public Set getOps()
657 {
658 return this.ops;
659 }
660
661 /**
662 * Either does nothing, or calls readWhiteList.
663 */
664 public void loadWhiteList() {}
665
666 /**
667 * Updates the time and weather for the given player to those of the given world
668 */
669 public void updateTimeAndWeatherForPlayer(EntityPlayerMP par1EntityPlayerMP, WorldServer par2WorldServer)
670 {
671 par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet4UpdateTime(par2WorldServer.getWorldTime()));
672
673 if (par2WorldServer.isRaining())
674 {
675 par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(new Packet70GameEvent(1, 0));
676 }
677 }
678
679 /**
680 * sends the players inventory to himself
681 */
682 public void syncPlayerInventory(EntityPlayerMP par1EntityPlayerMP)
683 {
684 par1EntityPlayerMP.sendContainerToPlayer(par1EntityPlayerMP.inventorySlots);
685 par1EntityPlayerMP.setPlayerHealthUpdated();
686 }
687
688 /**
689 * Returns the number of players currently on the server.
690 */
691 public int getCurrentPlayerCount()
692 {
693 return this.playerEntityList.size();
694 }
695
696 /**
697 * Returns the maximum number of players allowed on the server.
698 */
699 public int getMaxPlayers()
700 {
701 return this.maxPlayers;
702 }
703
704 /**
705 * Returns an array of usernames for which player.dat exists for.
706 */
707 public String[] getAvailablePlayerDat()
708 {
709 return this.mcServer.worldServers[0].getSaveHandler().getSaveHandler().getAvailablePlayerDat();
710 }
711
712 public boolean isWhiteListEnabled()
713 {
714 return this.whiteListEnforced;
715 }
716
717 public void setWhiteListEnabled(boolean par1)
718 {
719 this.whiteListEnforced = par1;
720 }
721
722 public List getPlayerList(String par1Str)
723 {
724 ArrayList var2 = new ArrayList();
725 Iterator var3 = this.playerEntityList.iterator();
726
727 while (var3.hasNext())
728 {
729 EntityPlayerMP var4 = (EntityPlayerMP)var3.next();
730
731 if (var4.func_71114_r().equals(par1Str))
732 {
733 var2.add(var4);
734 }
735 }
736
737 return var2;
738 }
739
740 /**
741 * Gets the View Distance.
742 */
743 public int getViewDistance()
744 {
745 return this.viewDistance;
746 }
747
748 public MinecraftServer getServerInstance()
749 {
750 return this.mcServer;
751 }
752
753 /**
754 * gets the tags created in the last writePlayerData call
755 */
756 public NBTTagCompound getTagsFromLastWrite()
757 {
758 return null;
759 }
760
761 @SideOnly(Side.CLIENT)
762 public void setGameType(EnumGameType par1EnumGameType)
763 {
764 this.gameType = par1EnumGameType;
765 }
766
767 private void func_72381_a(EntityPlayerMP par1EntityPlayerMP, EntityPlayerMP par2EntityPlayerMP, World par3World)
768 {
769 if (par2EntityPlayerMP != null)
770 {
771 par1EntityPlayerMP.theItemInWorldManager.setGameType(par2EntityPlayerMP.theItemInWorldManager.getGameType());
772 }
773 else if (this.gameType != null)
774 {
775 par1EntityPlayerMP.theItemInWorldManager.setGameType(this.gameType);
776 }
777
778 par1EntityPlayerMP.theItemInWorldManager.initializeGameType(par3World.getWorldInfo().getGameType());
779 }
780
781 @SideOnly(Side.CLIENT)
782
783 /**
784 * Sets whether all players are allowed to use commands (cheats) on the server.
785 */
786 public void setCommandsAllowedForAll(boolean par1)
787 {
788 this.commandsAllowedForAll = par1;
789 }
790
791 /**
792 * Kicks everyone with "Server closed" as reason.
793 */
794 public void removeAllPlayers()
795 {
796 while (!this.playerEntityList.isEmpty())
797 {
798 ((EntityPlayerMP)this.playerEntityList.get(0)).playerNetServerHandler.kickPlayerFromServer("Server closed");
799 }
800 }
801 }