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            World world = mcServer.worldServerForDimension(par2);
304            if (world == null || !world.provider.canRespawnHere())
305            {
306                par2 = 0;
307            }
308    
309            par1EntityPlayerMP.getServerForPlayer().getEntityTracker().removeAllTrackingPlayers(par1EntityPlayerMP);
310            par1EntityPlayerMP.getServerForPlayer().getEntityTracker().removeEntityFromAllTrackingPlayers(par1EntityPlayerMP);
311            par1EntityPlayerMP.getServerForPlayer().getPlayerManager().removePlayer(par1EntityPlayerMP);
312            this.playerEntityList.remove(par1EntityPlayerMP);
313            this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension).removeEntity(par1EntityPlayerMP);
314            ChunkCoordinates var4 = par1EntityPlayerMP.getSpawnChunk();
315            par1EntityPlayerMP.dimension = par2;
316            Object var5;
317    
318            if (this.mcServer.isDemo())
319            {
320                var5 = new DemoWorldManager(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
321            }
322            else
323            {
324                var5 = new ItemInWorldManager(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
325            }
326    
327            EntityPlayerMP var6 = new EntityPlayerMP(this.mcServer, this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension), par1EntityPlayerMP.username, (ItemInWorldManager)var5);
328            var6.clonePlayer(par1EntityPlayerMP, par3);
329            var6.dimension = par2;
330            var6.entityId = par1EntityPlayerMP.entityId;
331            var6.serverForThisPlayer = par1EntityPlayerMP.serverForThisPlayer;
332            WorldServer var7 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
333            this.func_72381_a(var6, par1EntityPlayerMP, var7);
334            ChunkCoordinates var8;
335    
336            if (var4 != null)
337            {
338                var8 = EntityPlayer.verifyRespawnCoordinates(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension), var4);
339    
340                if (var8 != null)
341                {
342                    var6.setLocationAndAngles((double)((float)var8.posX + 0.5F), (double)((float)var8.posY + 0.1F), (double)((float)var8.posZ + 0.5F), 0.0F, 0.0F);
343                    var6.setSpawnChunk(var4);
344                }
345                else
346                {
347                    var6.serverForThisPlayer.sendPacketToPlayer(new Packet70GameEvent(0, 0));
348                }
349            }
350    
351            var7.theChunkProviderServer.loadChunk((int)var6.posX >> 4, (int)var6.posZ >> 4);
352    
353            while (!var7.getCollidingBoundingBoxes(var6, var6.boundingBox).isEmpty())
354            {
355                var6.setPosition(var6.posX, var6.posY + 1.0D, var6.posZ);
356            }
357    
358            var6.serverForThisPlayer.sendPacketToPlayer(new Packet9Respawn(var6.dimension, (byte)var6.worldObj.difficultySetting, var6.worldObj.getWorldInfo().getTerrainType(), var6.worldObj.getHeight(), var6.theItemInWorldManager.getGameType()));
359            var8 = var7.getSpawnPoint();
360            var6.serverForThisPlayer.setPlayerLocation(var6.posX, var6.posY, var6.posZ, var6.rotationYaw, var6.rotationPitch);
361            var6.serverForThisPlayer.sendPacketToPlayer(new Packet6SpawnPosition(var8.posX, var8.posY, var8.posZ));
362            this.sendTimeAndRainingToPlayer(var6, var7);
363            var7.getPlayerManager().addPlayer(var6);
364            var7.spawnEntityInWorld(var6);
365            this.playerEntityList.add(var6);
366            var6.addSelfToInternalCraftingInventory();
367            GameRegistry.onPlayerRespawn(var6);
368            return var6;
369        }
370    
371        public void transferPlayerToDimension(EntityPlayerMP par1EntityPlayerMP, int par2)
372        {
373            transferPlayerToDimension(par1EntityPlayerMP, par2, new Teleporter());
374        }
375    
376        public void transferPlayerToDimension(EntityPlayerMP par1EntityPlayerMP, int par2, Teleporter teleporter)
377        {
378            int var3 = par1EntityPlayerMP.dimension;
379            WorldServer var4 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
380            par1EntityPlayerMP.dimension = par2;
381            WorldServer var5 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
382            par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet9Respawn(par1EntityPlayerMP.dimension, (byte)par1EntityPlayerMP.worldObj.difficultySetting, var5.getWorldInfo().getTerrainType(), var5.getHeight(), par1EntityPlayerMP.theItemInWorldManager.getGameType()));
383            var4.removeEntity(par1EntityPlayerMP);
384            par1EntityPlayerMP.isDead = false;
385    
386            WorldProvider pOld = DimensionManager.getProvider(var3);
387            WorldProvider pNew = DimensionManager.getProvider(par2);
388            double moveFactor = pOld.getMovementFactor() / pNew.getMovementFactor();
389            double var6 = par1EntityPlayerMP.posX * moveFactor;
390            double var8 = par1EntityPlayerMP.posZ * moveFactor;
391    
392            if (par1EntityPlayerMP.dimension == 1)
393            {
394                ChunkCoordinates var12 = var5.getEntrancePortalLocation();
395                var6 = (double)var12.posX;
396                par1EntityPlayerMP.posY = (double)var12.posY;
397                var8 = (double)var12.posZ;
398                par1EntityPlayerMP.setLocationAndAngles(var6, par1EntityPlayerMP.posY, var8, 90.0F, 0.0F);
399    
400                if (par1EntityPlayerMP.isEntityAlive())
401                {
402                    var4.updateEntityWithOptionalForce(par1EntityPlayerMP, false);
403                }
404            }
405    
406            if (var3 != 1)
407            {
408                var6 = (double)MathHelper.clamp_int((int)var6, -29999872, 29999872);
409                var8 = (double)MathHelper.clamp_int((int)var8, -29999872, 29999872);
410    
411                if (par1EntityPlayerMP.isEntityAlive())
412                {
413                    var5.spawnEntityInWorld(par1EntityPlayerMP);
414                    par1EntityPlayerMP.setLocationAndAngles(var6, par1EntityPlayerMP.posY, var8, par1EntityPlayerMP.rotationYaw, par1EntityPlayerMP.rotationPitch);
415                    var5.updateEntityWithOptionalForce(par1EntityPlayerMP, false);
416                    teleporter.placeInPortal(var5, par1EntityPlayerMP);
417                }
418            }
419    
420            par1EntityPlayerMP.setWorld(var5);
421            this.func_72375_a(par1EntityPlayerMP, var4);
422            par1EntityPlayerMP.serverForThisPlayer.setPlayerLocation(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY, par1EntityPlayerMP.posZ, par1EntityPlayerMP.rotationYaw, par1EntityPlayerMP.rotationPitch);
423            par1EntityPlayerMP.theItemInWorldManager.setWorld(var5);
424            this.sendTimeAndRainingToPlayer(par1EntityPlayerMP, var5);
425            this.syncPlayerInventory(par1EntityPlayerMP);
426            Iterator var14 = par1EntityPlayerMP.getActivePotionEffects().iterator();
427    
428            while (var14.hasNext())
429            {
430                PotionEffect var13 = (PotionEffect)var14.next();
431                par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet41EntityEffect(par1EntityPlayerMP.entityId, var13));
432            }
433    
434            GameRegistry.onPlayerChangedDimension(par1EntityPlayerMP);
435        }
436    
437        /**
438         * sends 1 player per tick, but only sends a player once every 600 ticks
439         */
440        public void sendPlayerInfoToAllPlayers()
441        {
442            if (++this.playerPingIndex > 600)
443            {
444                this.playerPingIndex = 0;
445            }
446    
447            if (this.playerPingIndex < this.playerEntityList.size())
448            {
449                EntityPlayerMP var1 = (EntityPlayerMP)this.playerEntityList.get(this.playerPingIndex);
450                this.sendPacketToAllPlayers(new Packet201PlayerInfo(var1.username, true, var1.ping));
451            }
452        }
453    
454        public void sendPacketToAllPlayers(Packet par1Packet)
455        {
456            for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
457            {
458                ((EntityPlayerMP)this.playerEntityList.get(var2)).serverForThisPlayer.sendPacketToPlayer(par1Packet);
459            }
460        }
461    
462        public void sendPacketToAllPlayersInDimension(Packet par1Packet, int par2)
463        {
464            Iterator var3 = this.playerEntityList.iterator();
465    
466            while (var3.hasNext())
467            {
468                EntityPlayerMP var4 = (EntityPlayerMP)var3.next();
469    
470                if (var4.dimension == par2)
471                {
472                    var4.serverForThisPlayer.sendPacketToPlayer(par1Packet);
473                }
474            }
475        }
476    
477        /**
478         * returns a string containing a comma-seperated list of player names
479         */
480        public String getPlayerList()
481        {
482            String var1 = "";
483    
484            for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
485            {
486                if (var2 > 0)
487                {
488                    var1 = var1 + ", ";
489                }
490    
491                var1 = var1 + ((EntityPlayerMP)this.playerEntityList.get(var2)).username;
492            }
493    
494            return var1;
495        }
496    
497        public String[] getAllUsernames()
498        {
499            String[] var1 = new String[this.playerEntityList.size()];
500    
501            for (int var2 = 0; var2 < this.playerEntityList.size(); ++var2)
502            {
503                var1[var2] = ((EntityPlayerMP)this.playerEntityList.get(var2)).username;
504            }
505    
506            return var1;
507        }
508    
509        public BanList getBannedPlayers()
510        {
511            return this.bannedPlayers;
512        }
513    
514        public BanList getBannedIPs()
515        {
516            return this.bannedIPs;
517        }
518    
519        /**
520         * This adds a username to the ops list, then saves the op list
521         */
522        public void addOp(String par1Str)
523        {
524            this.ops.add(par1Str.toLowerCase());
525        }
526    
527        /**
528         * This removes a username from the ops list, then saves the op list
529         */
530        public void removeOp(String par1Str)
531        {
532            this.ops.remove(par1Str.toLowerCase());
533        }
534    
535        /**
536         * Determine if the player is allowed to connect based on current server settings.
537         */
538        public boolean isAllowedToLogin(String par1Str)
539        {
540            par1Str = par1Str.trim().toLowerCase();
541            return !this.whiteListEnforced || this.ops.contains(par1Str) || this.whiteListIPs.contains(par1Str);
542        }
543    
544        public boolean areCommandsAllowed(String par1Str)
545        {
546            return this.ops.contains(par1Str.trim().toLowerCase()) || this.mcServer.isSinglePlayer() && this.mcServer.theWorldServer[0].getWorldInfo().areCommandsAllowed() && this.mcServer.getServerOwner().equalsIgnoreCase(par1Str) || this.commandsAllowedForAll;
547        }
548    
549        public EntityPlayerMP getPlayerForUsername(String par1Str)
550        {
551            Iterator var2 = this.playerEntityList.iterator();
552            EntityPlayerMP var3;
553    
554            do
555            {
556                if (!var2.hasNext())
557                {
558                    return null;
559                }
560    
561                var3 = (EntityPlayerMP)var2.next();
562            }
563            while (!var3.username.equalsIgnoreCase(par1Str));
564    
565            return var3;
566        }
567    
568        /**
569         * 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)
570         */
571        public void sendToAllNear(double par1, double par3, double par5, double par7, int par9, Packet par10Packet)
572        {
573            this.sendToAllNearExcept((EntityPlayer)null, par1, par3, par5, par7, par9, par10Packet);
574        }
575    
576        /**
577         * params: srcPlayer,x,y,z,d,dimension. The packet is not sent to the srcPlayer, but all other players where
578         * dx*dx+dy*dy+dz*dz<d*d
579         */
580        public void sendToAllNearExcept(EntityPlayer par1EntityPlayer, double par2, double par4, double par6, double par8, int par10, Packet par11Packet)
581        {
582            Iterator var12 = this.playerEntityList.iterator();
583    
584            while (var12.hasNext())
585            {
586                EntityPlayerMP var13 = (EntityPlayerMP)var12.next();
587    
588                if (var13 != par1EntityPlayer && var13.dimension == par10)
589                {
590                    double var14 = par2 - var13.posX;
591                    double var16 = par4 - var13.posY;
592                    double var18 = par6 - var13.posZ;
593    
594                    if (var14 * var14 + var16 * var16 + var18 * var18 < par8 * par8)
595                    {
596                        var13.serverForThisPlayer.sendPacketToPlayer(par11Packet);
597                    }
598                }
599            }
600        }
601    
602        public void saveAllPlayerData()
603        {
604            Iterator var1 = this.playerEntityList.iterator();
605    
606            while (var1.hasNext())
607            {
608                EntityPlayerMP var2 = (EntityPlayerMP)var1.next();
609                this.writePlayerData(var2);
610            }
611        }
612    
613        /**
614         * Add the specified player to the white list.
615         */
616        public void addToWhiteList(String par1Str)
617        {
618            this.whiteListIPs.add(par1Str);
619        }
620    
621        /**
622         * Remove the specified player from the whitelist.
623         */
624        public void removeFromWhitelist(String par1Str)
625        {
626            this.whiteListIPs.remove(par1Str);
627        }
628    
629        public Set getIPWhiteList()
630        {
631            return this.whiteListIPs;
632        }
633    
634        public Set getNamesWhiteList()
635        {
636            return this.ops;
637        }
638    
639        /**
640         * Either does nothing, or calls readWhiteList.
641         */
642        public void loadWhiteList() {}
643    
644        public void sendTimeAndRainingToPlayer(EntityPlayerMP par1EntityPlayerMP, WorldServer par2WorldServer)
645        {
646            par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet4UpdateTime(par2WorldServer.getWorldTime()));
647    
648            if (par2WorldServer.isRaining())
649            {
650                par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet70GameEvent(1, 0));
651            }
652        }
653    
654        /**
655         * sends the players inventory to himself
656         */
657        public void syncPlayerInventory(EntityPlayerMP par1EntityPlayerMP)
658        {
659            par1EntityPlayerMP.sendContainerToPlayer(par1EntityPlayerMP.inventorySlots);
660            par1EntityPlayerMP.setPlayerHealthUpdated();
661        }
662    
663        public int getPlayerListSize()
664        {
665            return this.playerEntityList.size();
666        }
667    
668        public int getMaxPlayers()
669        {
670            return this.maxPlayers;
671        }
672    
673        /**
674         * returns a list of usernames for which playerData is available
675         */
676        public String[] getAvailablePlayerDat()
677        {
678            return this.mcServer.theWorldServer[0].getSaveHandler().getSaveHandler().getAvailablePlayerDat();
679        }
680    
681        public boolean isWhiteListEnabled()
682        {
683            return this.whiteListEnforced;
684        }
685    
686        public void setWhiteListEnabled(boolean par1)
687        {
688            this.whiteListEnforced = par1;
689        }
690    
691        public List getPlayerList(String par1Str)
692        {
693            ArrayList var2 = new ArrayList();
694            Iterator var3 = this.playerEntityList.iterator();
695    
696            while (var3.hasNext())
697            {
698                EntityPlayerMP var4 = (EntityPlayerMP)var3.next();
699    
700                if (var4.func_71114_r().equals(par1Str))
701                {
702                    var2.add(var4);
703                }
704            }
705    
706            return var2;
707        }
708    
709        /**
710         * Gets the View Distance.
711         */
712        public int getViewDistance()
713        {
714            return this.viewDistance;
715        }
716    
717        public MinecraftServer getServerInstance()
718        {
719            return this.mcServer;
720        }
721    
722        /**
723         * gets the tags created in the last writePlayerData call
724         */
725        public NBTTagCompound getTagsFromLastWrite()
726        {
727            return null;
728        }
729    
730        @SideOnly(Side.CLIENT)
731        public void setGameType(EnumGameType par1EnumGameType)
732        {
733            this.gameType = par1EnumGameType;
734        }
735    
736        private void func_72381_a(EntityPlayerMP par1EntityPlayerMP, EntityPlayerMP par2EntityPlayerMP, World par3World)
737        {
738            if (par2EntityPlayerMP != null)
739            {
740                par1EntityPlayerMP.theItemInWorldManager.setGameType(par2EntityPlayerMP.theItemInWorldManager.getGameType());
741            }
742            else if (this.gameType != null)
743            {
744                par1EntityPlayerMP.theItemInWorldManager.setGameType(this.gameType);
745            }
746    
747            par1EntityPlayerMP.theItemInWorldManager.initializeGameType(par3World.getWorldInfo().getGameType());
748        }
749    
750        @SideOnly(Side.CLIENT)
751    
752        /**
753         * Sets whether all players are allowed to use commands (cheats) on the server.
754         */
755        public void setCommandsAllowedForAll(boolean par1)
756        {
757            this.commandsAllowedForAll = par1;
758        }
759    
760        /**
761         * kicks everyone with the "Server closed"
762         */
763        public void removeAllPlayers()
764        {
765            while (!this.playerEntityList.isEmpty())
766            {
767                ((EntityPlayerMP)this.playerEntityList.get(0)).serverForThisPlayer.kickPlayerFromServer("Server closed");
768            }
769        }
770    }