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