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