fCraft.World.AcceptPlayer C# (CSharp) Method

        public Map AcceptPlayer( [NotNull] Player player, bool announce )
        {
            if ( player == null )
                throw new ArgumentNullException( "player" );

            lock ( SyncRoot ) {
                if ( IsFull ) {
                    if ( player.Info.Rank.ReservedSlot ) {
                        Player idlestPlayer = Players.Where( p => p.Info.Rank.IdleKickTimer != 0 )
                                                     .OrderBy( p => p.LastActiveTime )
                                                     .FirstOrDefault();
                        if ( idlestPlayer != null ) {
                            idlestPlayer.Kick( Player.Console, "Auto-kicked to make room (idle).",
                                               LeaveReason.IdleKick, false, false, false );

                            Server.Players
                                  .CanSee( player )
                                  .Message( "&SPlayer {0}&S was auto-kicked to make room for {1}",
                                            idlestPlayer.ClassyName, player.ClassyName );
                            Server.Players
                                  .CantSee( player )
                                  .Message( "{0}&S was kicked for being idle for {1} min",
                                            player.ClassyName, player.Info.Rank.IdleKickTimer );
                        } else {
                            return null;
                        }
                    } else {
                        return null;
                    }
                }

                if ( playerIndex.ContainsKey( player.Name.ToLower() ) ) {
                    Logger.Log( LogType.Error,
                                "This world already contains the player by name ({0}). " +
                                "Some sort of state corruption must have occured.",
                                player.Name );
                    playerIndex.Remove( player.Name.ToLower() );
                }

                playerIndex.Add( player.Name.ToLower(), player );

                // load the map, if it's not yet loaded
                IsPendingMapUnload = false;
                Map = LoadMap();

                if ( ConfigKey.BackupOnJoin.Enabled() && ( Map.HasChangedSinceBackup || !ConfigKey.BackupOnlyWhenChanged.Enabled() ) ) {
                    string backupFileName = String.Format( JoinBackupFormat,
                                                         Name, DateTime.Now, player.Name ); // localized
                    SaveBackup( MapFileName );
                }

                UpdatePlayerList();

                if ( !IsRealm && announce && ConfigKey.ShowJoinedWorldMessages.Enabled() ) {
                    Server.Players.CanSee( player )
                                  .Message( "&SPlayer {0}&S joined world {1}",
                                            player.ClassyName, ClassyName );
                }

                //realm joining announcer
                if ( IsRealm && announce && ConfigKey.ShowJoinedWorldMessages.Enabled() ) {
                    Server.Players.CanSee( player )
                                  .Message( "&SPlayer {0}&S joined realm {1}",
                                            player.ClassyName, ClassyName );
                }

                if ( IsRealm ) {
                    Logger.Log( LogType.ChangedWorld,
                    "Player {0} joined realm {1}.",
                    player.Name, Name );
                }

                if ( !IsRealm ) {
                    Logger.Log( LogType.ChangedWorld,
                    "Player {0} joined world {1}.",
                    player.Name, Name );
                }

                if ( IsLocked ) {
                    player.Message( "&WThis map is currently locked (read-only)." );
                }

                if ( player.Info.IsHidden ) {
                    player.Message( "&8Reminder: You are still hidden." );
                }

                return Map;
            }
        }

        public bool JoinWorld( World newWorld, bool useHandshakePacket )
        {
            if( newWorld.classAccess.rank > player.info.playerClass.rank ) {
                return false;
            }

            if( !newWorld.FirePlayerTriedToJoinEvent( player ) ) {
                return false;
            }

            isBetweenWorlds = true;
            if( player.world != null ) {
                player.world.ReleasePlayer( player );
            }
            ClearQueues();

            client.NoDelay = false;

            World oldWorld = player.world;
            newWorld.AcceptPlayer( player );
            player.world = newWorld;

            // Start sending over the level copy
            if( useHandshakePacket ) {
                writer.Write( PacketWriter.MakeHandshake( player, Config.GetString( ConfigKey.ServerName ), "Loading world \"" + player.world.name + "\"" ) );
            }
            writer.WriteLevelBegin();
            byte[] buffer = new byte[1024];
            int bytesSent = 0;

            // Fetch compressed map copy
            byte[] blockData;
            using( MemoryStream stream = new MemoryStream() ) {
                player.world.map.GetCompressedCopy( stream, true );
                blockData = stream.ToArray();
            }
            Logger.Log( "Session.LoginSequence: Sending compressed level copy ({0} bytes) to {1}.", LogType.Debug,
                           blockData.Length, player.name );

            while ( bytesSent < blockData.Length ) {
                int chunkSize = blockData.Length - bytesSent;
                if ( chunkSize > 1024 ) {
                    chunkSize = 1024;
                }
                Array.Copy( blockData, bytesSent, buffer, 0, chunkSize );
                byte progress = (byte)( 100 * bytesSent / blockData.Length );

                // write in chunks of 1024 bytes or less
                writer.WriteLevelChunk( buffer, chunkSize, progress );
                bytesSent += chunkSize;
            }

            writer.Write( PacketWriter.MakeHandshake( player, Config.GetString( ConfigKey.ServerName ), "Almost there..." ) );

            // Done sending over level copy
            writer.Write( PacketWriter.MakeLevelEnd( player.world.map ) );

            // Send new spawn
            player.pos = player.world.map.spawn;
            Thread.Sleep( 100 );
            writer.WriteAddEntity( 255, player, player.pos );
            writer.WriteTeleport( 255, player.pos );

            isBetweenWorlds = false;

            // Send player list
            player.world.SendPlayerList( player );

            if( Config.GetBool( ConfigKey.LowLatencyMode ) ) {
                client.NoDelay = true;
            }

            Server.FireWorldChangedEvent( player, oldWorld, newWorld );

            // Done.
            GC.Collect( GC.MaxGeneration, GCCollectionMode.Optimized );

            return true;
        }