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