public class NetGameInfo extends NetGameInfoHud
{

    private void CleanBeforeQuitGame()
    {
        DisableCallMethod(METHOD_LoadNextLevel);
        DisableCallMethod(METHOD_QuitGameOnGameOver);
        m_bWaitForLoadNextLevel = false;
        m_bWaitForQuitGameOnGameOver = false;
        UnregisterKeyRequest();
        HudNetStop();
    }

    void ClientCreateMyPlayerRequest()
    {
        MsgSendServerCreateMyPlayer(NetPlayerProfile.GetCurrent(), super.m_cModule);
        CallMethodIn(METHOD_ClientCreateMyPlayerRequest, 5F);
    }

    void MsgSendClientPlayersState()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(17);
            GetPlayerInfoList().MessagePackPlayersState(GetTime());
            MessageSend();
            return;
        }
    }

    int GetDominationBaseLocalState(DominationBase cBase, NetPlayerInfo cPlayerInfo)
    {
        return -1;
    }

    void ScheduleSendingMsgClientPlayersState()
    {
        StopSendingMsgClientPlayersState();
        CallMethodIn(METHOD_StartSendingMsgClientPlayersState, sm_fSendingMsgClientPlayersStateDelay);
    }

    void MsgRecvClientGameRestart()
    {
        super.m_bFirstRestart = MessageUnPackBoolean();
        super.m_nRestartMode = MessageUnPackInt();
        MessageEnd();
        SetGameResults(1);
        SetGameRestart();
    }

    void OnSetGameSettings()
    {
        super.OnSetGameSettings();
        if(super.Role < 4)
            CallMethodEvery(METHOD_MsgSendServerPing, 1.0F);
    }

    void CheckKickClientOnFailedCreatePlayer(int nClientId, int nResults)
    {
        boolean bKick = true;
        switch(nResults)
        {
        case 5: // '\005'
            bKick = false;
            break;

        case 1: // '\001'
        case 2: // '\002'
        case 3: // '\003'
        case 4: // '\004'
        case 6: // '\006'
            bKick = true;
            break;

        default:
            GameObject.CrashLog(" ECreatePlayerResults " + nResults + " unknown, cant check kick ");
            break;
        }
        if(bKick)
            ForceKickClient(nClientId);
    }

    void MsgSendServerCreateMyPlayer(NetPlayerProfile cProfile, ModuleNet cModule)
    {
        int aSkins[] = cProfile.GetSkinsIndex();
        MessageNew(10);
        MessagePackInt(GetGameVersion());
        MessagePackString(cProfile.GetPlayerName());
        MessagePackString(cProfile.GetMeshName());
        for(int i = 0; i < aSkins.length; i++)
            MessagePackInt(aSkins[i]);

        MessagePackString(cModule.GetGameInitInfo().GetCurrentLevelName());
        MessagePackInt(0);
        MessagePackBoolean(sm_bAutoPlayer);
        MessageSend();
    }

    void MsgSendClientPlayerJoined(int nJoinedInfoId)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(22);
            MessagePackInt(nJoinedInfoId);
            MessageSend();
            return;
        }
    }

    void MsgSendClientPlayerDied(int nVictimInfoID, int nAssassinInfoID, boolean bTeamKill)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(24);
            MessagePackInt(nVictimInfoID);
            MessagePackInt(nAssassinInfoID);
            MessagePackBoolean(bTeamKill);
            MessageSend();
            return;
        }
    }

    void EventMessageOnPlayerDied(int nVictimInfoId, int nAssassinInfoId, boolean bTeamKill)
    {
        AddIncomingMessage(9, nVictimInfoId, nAssassinInfoId);
        MsgSendClientPlayerDied(nVictimInfoId, nAssassinInfoId, false);
    }

    void EventObjectiveUpdated(int nUpdate, int iGroupNo, int iSubObjNo, boolean bMesssagesActive)
    {
        MsgSendClientObjectiveUpdated(nUpdate, iGroupNo, iSubObjNo, bMesssagesActive);
    }

    void MsgRecvClientObjectiveUpdated()
    {
        int nUpdate = MessageUnPackInt();
        int iGroupNo = MessageUnPackInt();
        int iSubObjNo = MessageUnPackInt();
        boolean bMesssagesActive = MessageUnPackBoolean();
        MessageEnd();
        ObjectivesManager cObjectivesManager = super.m_cModule.GetObjectivesManager();
        if(cObjectivesManager != null)
            cObjectivesManager.ObjectiveUpdated(nUpdate, iGroupNo, iSubObjNo, bMesssagesActive);
    }

    void MsgSendClientGameStatusMsgUpdated(NetDataContainer cContainer)
    {
        MessageNew(34);
        cContainer.ToMessage(this);
        MessageSend();
    }

    void MsgSendClientGameOver()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(30);
            MessagePackInt(GetGameResults());
            MessageSend();
            return;
        }
    }

    void ScheduleQuitGameOnGameOver()
    {
        RegisterKeyRequest();
        m_bWaitForQuitGameOnGameOver = true;
        ActivateStatisticsOnGameOverAndContinue();
        if(super.Role == 4)
            MsgSendClientNextLevel(null);
    }

    void EventDisconnectFromServer(int nReason)
    {
        super.EventDisconnectFromServer(nReason);
        if(!m_bWaitForLoadNextLevel && !m_bWaitForQuitGameOnGameOver)
            CallMethodIn(METHOD_ForceQuitGame, 5F);
    }

    void MsgSendClientPlayerLeft(int nLeftInfoId)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(23);
            MessagePackInt(nLeftInfoId);
            MessageSend();
            return;
        }
    }

    void MsgRecvClientTimeInfo()
    {
        SetGameTime(MessageUnPackFloat());
        GetPlayerInfoList().MessageUnPackPlayersPing();
        MessageEnd();
    }

    public void OnReplicateServer()
    {
    }

    void QuitGameOnGameOver()
    {
        DisableCallMethod(METHOD_QuitGameOnGameOver);
        if(((ChromeGame)Game.cSingleton).Menu.bInGameMenuAct)
        {
            CallMethodIn(METHOD_QuitGameOnGameOver, 3F);
            return;
        } else
        {
            CleanBeforeQuitGame();
            ForceQuitGame();
            return;
        }
    }

    void MsgRecvClientGameOver()
    {
        int nResults = MessageUnPackInt();
        MessageEnd();
        SetGameResults(nResults);
        SetGameOver();
    }

    void EventPlayerToKick(int nClientId, int nReason, String sReason)
    {
        NetPlayerInfo cPlayerInfo = GetPlayerInfoList().GetPlayerByHostId(nClientId);
        if(cPlayerInfo != null)
        {
            MsgSendClientPlayerKickedOut(cPlayerInfo.GetNetId(), nReason, sReason);
            FlushReplicationManagerBuffers();
            if(nReason != -1)
                sReason = EKickReason.GetText(nReason);
            AddIncomingMessage(12, sReason, cPlayerInfo.GetNetId());
            cPlayerInfo.ScheduleKickOutFromTheGame();
        }
    }

    void CreateHUDNet()
    {
        super.CreateHUDNet();
        if(GetHUDNet() != null)
            GetHUDNet().Init(this);
    }

    void MsgRecvServerIAmReady()
    {
        int nHost = MessageGetSenderId();
        MessageEnd();
        if(!sm_bSendGameSettingOnJoin)
            MsgSendClientGameSettings(nHost);
    }

    void MsgSendClientPlayerKickedOut(int nPlayerInfoId, int nReason, String sReason)
    {
        boolean bEnumedReason = nReason != -1;
        MessageNew(28);
        MessagePackInt(nPlayerInfoId);
        MessagePackBoolean(bEnumedReason);
        if(bEnumedReason)
            MessagePackInt(nReason);
        else
            MessagePackString(sReason == null ? "" : sReason);
        MessageSend();
    }

    boolean SetPhysicsGranularity(float fPhysicsGranularity)
    {
        boolean bRet = super.SetPhysicsGranularity(fPhysicsGranularity);
        if(bRet && super.Role == 4)
            MsgSendClientNewGameParams();
        return bRet;
    }

    void EventPlayerToKick(int nClientId, int nReason)
    {
        EventPlayerToKick(nClientId, nReason, null);
    }

    void EventPlayerToKick(int nClientId, String sReason)
    {
        EventPlayerToKick(nClientId, -1, sReason);
    }

    void EventPlayerExcluded(NetPlayerInfo cPlayerInfo)
    {
        int nPlayerInfoId = cPlayerInfo == null ? -1 : cPlayerInfo.GetNetId();
        AddIncomingMessage(20, nPlayerInfoId);
        MsgSendClientPlayerExcluded(nPlayerInfoId);
    }

    void MsgSendClientFXRespawnOnLevel(Vector vPos, byte nFx)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNewUnreliable(40);
            MessagePackVector(vPos);
            MessagePackByte(nFx);
            MessageSend();
            return;
        }
    }

    void ScheduleLoadNextLevel()
    {
        RegisterKeyRequest();
        m_bWaitForLoadNextLevel = true;
        String sLevel = m_cNextLevel.GetLevelName() + " " + ENetGameType.GetGameNameShort(m_cNextLevel.GetNetGameType());
        AddIncomingMessage(38, sLevel);
        float fTime = 0.0F;
        if(super.Role == 4)
        {
            fTime = 5F;
            ActivateStatisticsOnWaitForSpaceToContinue();
        } else
        {
            fTime = 12F;
            ActivateStatisticsOnPleaseWait();
        }
        CallMethodIn(METHOD_LoadNextLevel, fTime);
    }

    void LoadNextLevel()
    {
        DisableCallMethod(METHOD_LoadNextLevel);
        if(((ChromeGame)Game.cSingleton).Menu.bInGameMenuAct)
        {
            CallMethodIn(METHOD_LoadNextLevel, 3F);
            return;
        }
        CleanBeforeQuitGame();
        if(super.Role == 4)
        {
            ActivateStatisticsOnPleaseWait();
            ServerSendClientNextLevel();
            CallMethodIn(METHOD_ServerDelayedLoadNextLevel, 5F);
        } else
        {
            super.m_cModule.ClientLoadNextLevel();
        }
    }

    void ServerSendClientNextLevel()
    {
        for(int i = 0; i < 5; i++)
        {
            MsgSendClientNextLevel(m_cNextLevel);
            FlushReplicationManagerBuffers();
        }

        DisableCallMethod(METHOD_ServerSendClientNextLevel);
        CallMethodIn(METHOD_ServerSendClientNextLevel, 0.1F);
    }

    static String GetGameVersionFullString()
    {
        return NetGameVersion.GetFullName();
    }

    static String GetNetGameVersionNumberString()
    {
        return NetGameVersion.GetNetNumberName();
    }

    void MsgRecvClientPlayerExcluded()
    {
        int nPlayerInfoId = MessageUnPackInt();
        MessageEnd();
        AddIncomingMessage(20, nPlayerInfoId);
    }

    void MsgSendClientGameOverPing()
    {
        MessageNew(43);
        MessageSend();
    }

    void MsgSendClientNextLevel(LevelContent cLevel)
    {
        MessageNew(32);
        if(cLevel != null)
        {
            MessagePackBoolean(true);
            MessagePackString(cLevel.sLevelName);
            MessagePackInt(cLevel.GetNetGameType());
        } else
        {
            MessagePackBoolean(false);
        }
        MessageSend();
    }

    void MsgRecvClientNextLevel()
    {
        String sLevelName = null;
        int nGameType = 0;
        if(MessageUnPackBoolean())
        {
            sLevelName = MessageUnPackString();
            nGameType = MessageUnPackInt();
        }
        MessageEnd();
        DisableCallMethod(METHOD_ForceQuitGame);
        if(sLevelName != null)
        {
            if(!m_bWaitForLoadNextLevel)
            {
                m_cNextLevel = super.m_cModule.ClientSetNextLevel(sLevelName, nGameType);
                ScheduleLoadNextLevel();
            }
        } else
        if(!m_bWaitForQuitGameOnGameOver)
            ScheduleQuitGameOnGameOver();
    }

    static String GetGameVersionNumberString()
    {
        return NetGameVersion.GetNumberName();
    }

    void MsgRecvClientPlayersState()
    {
        GetPlayerInfoList().MessageUnPackPlayersState();
        MessageEnd();
        if(super.Role == 4)
        {
            return;
        } else
        {
            DisableCallMethod(METHOD_VerifyPlayersState);
            CallMethodIn(METHOD_VerifyPlayersState, sm_fVerifyPlayersStateDelay);
            return;
        }
    }

    void EventPlayerChangedNickForced(NetPlayerInfo cPlayerInfo, String sOldNick)
    {
        String sNewNick = cPlayerInfo.GetNick();
        AddIncomingMessage(18, sOldNick, sNewNick, cPlayerInfo.GetNetId());
        MsgSendClientPlayerChangedNick(sOldNick, sNewNick, cPlayerInfo.GetNetId(), true);
        ChangeNickInProfileIfOwner(cPlayerInfo.GetNetId(), sNewNick);
    }

    void MsgRecvClientGameOverPing()
    {
        MessageEnd();
    }

    void ForceQuitGame()
    {
        DisableCallMethod(METHOD_ForceQuitGame);
        if(super.m_cModule != null)
            super.m_cModule.ForceQuitGame();
    }

    void EventPlayersDamaged(PlayerNetBaseMortal playernetbasemortal, PlayerNetBaseMortal playernetbasemortal1)
    {
    }

    void MsgSendClientGameSettings(int nHost)
    {
        if(super.Role < 4)
            return;
        MessageNew(20);
        MessagePackBoolean(IsInternetGame());
        MessagePackInt(GetGameResults());
        MessagePackGameSettings();
        MessagePackObjectives();
        MessagePackCurrentGameStatus();
        MessagePackPlayersTeamSkins();
        MessagePackTeamRole();
        MessageSendHost(nHost);
        if(m_bGameParamsChanged)
            MsgSendClientNewGameParams();
    }

    void MsgSendClientCreatePlayerConfirm(int nClientId)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(15);
            MessageSendHost(nClientId);
            return;
        }
    }

    boolean SetClientShutdown()
    {
        boolean bRet = super.SetClientShutdown();
        if(bRet && super.Role == 4)
            MsgSendClientNewGameParams();
        return bRet;
    }

    static void SetCheckBreakpoint(boolean bVal)
    {
        sm_bBreakpoint = bVal;
    }

    void MsgSendClientPlayerBanned(int nPlayerInfoId, String sReason)
    {
        MessageNew(29);
        MessagePackInt(nPlayerInfoId);
        MessagePackString(sReason);
        MessageSend();
    }

    void EventPlayerJoined(PlayerNet player)
    {
        NetPlayerInfo cJoinedInfo = null;
        int nJoinedInfoId = -1;
        if(player != null)
        {
            cJoinedInfo = player.GetPlayerInfo();
            if(cJoinedInfo != null)
                nJoinedInfoId = cJoinedInfo.GetNetId();
            else
                GameObject.CrashLog("ERROR: " + this + " PlayerJoined " + player + " cNetPlayerInfo == null\n");
        }
        if(cJoinedInfo == null)
            return;
        if(sm_bSendGameSettingOnJoin)
        {
            int nJoinedHost = cJoinedInfo.GetClientOwnerId();
            MsgSendClientGameSettings(nJoinedHost);
        }
        if(cJoinedInfo.GetTeamId() != 0)
        {
            NetTeamInfo cJoinedTeamInfo = GetTeamInfoById(cJoinedInfo.GetTeamId());
            int nJoinedTeamInfoId = -1;
            int nSkin = 0;
            int nChangeSkinCounter = PlayerNetBase.GetNextGlobalChangeSkinCounter();
            if(cJoinedTeamInfo != null)
            {
                nJoinedTeamInfoId = cJoinedTeamInfo.GetNetId();
                nSkin = cJoinedTeamInfo.GetTeamId();
            }
            MsgSendClientPlayerJoinedTeam(nJoinedInfoId, nJoinedTeamInfoId, nSkin, nChangeSkinCounter);
            AddIncomingMessage(8, nJoinedInfoId, -1, nJoinedTeamInfoId);
            OnTeamChange();
            ChangePlayerTeamSkins(nJoinedInfoId, nSkin, nChangeSkinCounter);
        } else
        {
            MsgSendClientPlayerJoined(nJoinedInfoId);
            AddIncomingMessage(7, nJoinedInfoId);
        }
        cJoinedInfo.UpdateRespawnLimitCnt();
        UpdateEnableObjectivesIfOwner(nJoinedInfoId);
        if(!IsGameStarted())
            StartGameIfNeeded();
    }

    void EventPlayerDied(PlayerNetBaseMortal victim, PlayerNetBaseMortal assassin, int nMode)
    {
        if(super.Role < 4)
            return;
        NetPlayerInfo cVictimInfo = null;
        int nVictimInfoId = -1;
        if(victim != null)
        {
            cVictimInfo = victim.GetPlayerInfo();
            if(cVictimInfo != null)
                nVictimInfoId = cVictimInfo.GetNetId();
            else
                GameObject.CrashLog("ERROR: " + this + " PlayerDied victim " + victim + " cNetPlayerInfo == null\n");
        }
        NetPlayerInfo cAssassinInfo = null;
        int nAssassinInfoId = -1;
        if(assassin != null)
        {
            cAssassinInfo = assassin.GetPlayerInfo();
            if(cAssassinInfo != null)
                nAssassinInfoId = cAssassinInfo.GetNetId();
            else
                GameObject.CrashLog("ERROR: " + this + " PlayerDied assassin " + assassin + " cNetPlayerInfo == null\n");
        }
        if(cVictimInfo != null)
            if(cVictimInfo.CheckFailed())
            {
                cVictimInfo.SetExcluded(true);
            } else
            {
                float fMinRespawnTime = GetGameSettings().GetMinRespawnTime();
                if(fMinRespawnTime > 0.0F && nMode == 0)
                {
                    float fNextRespawnTime = GetTime() + fMinRespawnTime;
                    cVictimInfo.SetNextRespawnTime(fNextRespawnTime);
                }
            }
        if(!MessagesDisabled())
        {
            boolean bTeamKill = cVictimInfo != null && cAssassinInfo != null && cVictimInfo != cAssassinInfo && cVictimInfo.GetTeamId() == cAssassinInfo.GetTeamId();
            EventMessageOnPlayerDied(nVictimInfoId, nAssassinInfoId, bTeamKill);
        }
    }

    void MsgSendClientNewGameParams()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(42);
            MessagePackFloat(PlayerNetBase.sm_fPhysicsGranularity);
            MessagePackFloat(super.m_cModule == null ? -1F : super.m_cModule.GetPhysicsLastUpdateTime());
            MessagePackFloat(PlayerNetBaseMover._MAX_RESEND_MOVE_TIME);
            MessagePackBoolean(PlayerNetTestBot.sm_bCanUseWeapon);
            MessagePackBoolean(super.m_bClientGameShutdown);
            MessageSend();
            m_bGameParamsChanged = true;
            return;
        }
    }

    void MsgSendClientPlayerJoinedTeam(int i, int j, int k, int l)
    {
    }

    static boolean CheckBreakPoint()
    {
        return sm_bBreakpoint;
    }

    void MsgRecvClientPlayerDied()
    {
        int nVictimInfoId = MessageUnPackInt();
        int nAssassinInfoId = MessageUnPackInt();
        boolean bTeamKill = MessageUnPackBoolean();
        MessageEnd();
        if(bTeamKill)
            AddIncomingMessage(10, nVictimInfoId, nAssassinInfoId);
        else
            AddIncomingMessage(9, nVictimInfoId, nAssassinInfoId);
    }

    void MsgRecvClientPlayerJoined()
    {
        int nJoinedInfoId = MessageUnPackInt();
        MessageEnd();
        AddIncomingMessage(7, nJoinedInfoId);
        UpdateEnableObjectivesIfOwner(nJoinedInfoId);
    }

    void MsgSendClientUpdateGameSettings()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(21);
            MessagePackGameSettings();
            MessageSend();
            return;
        }
    }

    boolean SetAutoPlayersFire(boolean bFire)
    {
        boolean bRet = super.SetAutoPlayersFire(bFire);
        if(bRet && super.Role == 4)
            MsgSendClientNewGameParams();
        return bRet;
    }

    void EventPlayerLeft(PlayerNet cPlayer)
    {
        NetPlayerInfo cLeftInfo = null;
        int nLeftInfoId = -1;
        if(cPlayer != null)
        {
            cLeftInfo = cPlayer.GetPlayerInfo();
            if(cLeftInfo != null)
                nLeftInfoId = cLeftInfo.GetNetId();
            else
                GameObject.CrashLog("ERROR: " + this + " PlayerLeft " + cPlayer + " cPlayerInfo == null\n");
        }
        if(!MessagesDisabled() && (cLeftInfo == null || !cLeftInfo.IsKickedOutFromTheGame()))
        {
            AddIncomingMessage(11, nLeftInfoId);
            MsgSendClientPlayerLeft(nLeftInfoId);
        }
        boolean bMessagesDisabled = MessagesDisabled();
        DisableMessages();
        cPlayer.ForceDieOnLeftGame();
        if(!bMessagesDisabled)
            EnableMessages();
    }

    NetPlayerInfo ServerAddPlayerInfo(PlayerNet cNewPlayer, int nClientId, int nClientGameVersion)
    {
        NetPlayerInfo cPlayerInfo = super.ServerAddPlayerInfo(cNewPlayer, nClientId, nClientGameVersion);
        EventPlayerJoined(cNewPlayer);
        ScheduleSendingMsgClientPlayersState();
        return cPlayerInfo;
    }

    void ServerGameOver()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            super.ServerGameOver();
            CallMethodIn(METHOD_EventAfterGameOver, 5F);
            return;
        }
    }

    void EventAfterGameOver()
    {
        m_cNextLevel = super.m_cModule.GetGameInitInfo().GetNextLevel();
        if(m_cNextLevel != null)
            ScheduleLoadNextLevel();
        else
            ScheduleQuitGameOnGameOver();
    }

    void AddPlayerInfo(NetPlayerInfo cPlayerInfo)
    {
        super.AddPlayerInfo(cPlayerInfo);
        if(cPlayerInfo != null)
        {
            int nInfoId = cPlayerInfo.GetNetId();
            UpdateEnableObjectivesIfOwner(nInfoId);
        }
    }

    void MsgRecvClientGameSettings()
    {
        boolean bInternetGame = MessageUnPackBoolean();
        int nResults = MessageUnPackInt();
        MessageUnPackGameSettings();
        MessageUnPackObjectives();
        MessageUnPackCurrentGameStatus();
        MessageUnPackPlayersTeamSkins();
        MessageUnPackTeamRole();
        MessageEnd();
        SetInternetGame(bInternetGame);
        SetGameResults(nResults);
        OnSetGameSettings();
    }

    void MsgRecvClientPlayerLeft()
    {
        int nLeftInfoId = MessageUnPackInt();
        MessageEnd();
        AddIncomingMessage(11, nLeftInfoId);
    }

    void MsgRecvClientGameStatusMsgUpdated()
    {
        NetDataContainer cContainer = new NetDataContainer();
        cContainer.FromMessage(this);
        MessageEnd();
        if(GetGameStatusMsgManager() != null)
            GetGameStatusMsgManager().StatusUpdated(cContainer);
    }

    int GetWinnerId()
    {
        return GetPlayerInfoList().GetLeaderInfoId();
    }

    public void ReplicationInit()
    {
        SetNetPriority(1.0F);
    }

    void MsgSendClientPlayerRespawnLimitOut(int nPlayerInfoId)
    {
        MessageNew(26);
        MessagePackInt(nPlayerInfoId);
        MessageSend();
    }

    void MsgRecvClientPlayerKickedOut()
    {
        String sReason = null;
        int nPlayerInfoId = MessageUnPackInt();
        if(MessageUnPackBoolean())
        {
            int nReason = MessageUnPackInt();
            sReason = EKickReason.GetText(nReason);
        } else
        {
            sReason = MessageUnPackString();
        }
        MessageEnd();
        if(sReason == null)
            sReason = "";
        AddIncomingMessage(12, sReason, nPlayerInfoId);
    }

    void MsgRecvClientPlayerBanned()
    {
        int nPlayerInfoId = MessageUnPackInt();
        String sReason = MessageUnPackString();
        MessageEnd();
        AddIncomingMessage(13, sReason, nPlayerInfoId);
    }

    void MsgRecvClientFXRespawnOnLevel()
    {
        Vector vPos = MessageUnPackVector();
        byte nFx = MessageUnPackByte();
        MessageEnd();
        if(super.m_cModule != null)
            super.m_cModule.RespawnFX(vPos, nFx);
    }

    static String GetGameVersionShortString()
    {
        return NetGameVersion.GetShortName();
    }

    void OnPostCreate()
    {
        if(super.Role == 4)
        {
            ServerCleanGame();
            if(IsPlayerOnServer())
                CallMethodIn(METHOD_ServerCreateMyPlayer, 0.0F);
            CallMethodIn(METHOD_OnSetGameSettings, 1.0F);
        }
    }

    void MsgSendClientCreatePlayerCancel(int nClientId, int nReason)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(16);
            MessagePackInt(nReason);
            MessageSendHost(nClientId);
            return;
        }
    }

    void EventDisconnectByConnectionStatusManager()
    {
        super.EventDisconnectByConnectionStatusManager();
        if(!m_bWaitForLoadNextLevel && !m_bWaitForQuitGameOnGameOver)
            CallMethodIn(METHOD_ForceQuitGame, 0.0F);
    }

    public void OnMessage()
    {
        switch(MessageGetId())
        {
        case 12: // '\f'
            MessageEnd();
            break;

        case 18: // '\022'
            MsgRecvClientTimeInfo();
            break;

        case 10: // '\n'
            GameObject.LogD("_MSG_CREATE_PLAYER\n");
            MsgRecvServerCreatePlayer();
            break;

        case 24: // '\030'
            GameObject.LogD("_MSG_PLAYER_DIED\n");
            MsgRecvClientPlayerDied();
            break;

        case 25: // '\031'
            GameObject.LogD("_MSG_PLAYER_CHANGED_NICK\n");
            MsgRecvClientPlayerChangedNick();
            break;

        case 11: // '\013'
            GameObject.LogD("_MSG_I_AM_READY\n");
            MsgRecvServerIAmReady();
            break;

        case 15: // '\017'
            GameObject.LogD("_MSG_CREATE_PLAYER_CONFIRM\n");
            MsgRecvClientCreatePlayerConfirm();
            break;

        case 16: // '\020'
            GameObject.LogD("_MSG_CREATE_PLAYER_CANCEL\n");
            MsgRecvClientCreatePlayerCancel();
            break;

        case 17: // '\021'
            GameObject.LogD("_MSG_PLAYERS_STATE\n");
            MsgRecvClientPlayersState();
            break;

        case 20: // '\024'
            GameObject.LogD("_MSG_GAME_SETTINGS\n");
            MsgRecvClientGameSettings();
            break;

        case 21: // '\025'
            GameObject.LogD("_MSG_UPDATE_GAME_SETTINGS\n");
            MsgRecvClientUpdateGameSettings();
            break;

        case 22: // '\026'
            GameObject.LogD("_MSG_PLAYER_JOINED\n");
            MsgRecvClientPlayerJoined();
            break;

        case 23: // '\027'
            GameObject.LogD("_MSG_PLAYER_LEFT\n");
            MsgRecvClientPlayerLeft();
            break;

        case 26: // '\032'
            GameObject.LogD("_MSG_PLAYER_RESPAWN_LIMIT_OUT\n");
            MsgRecvClientPlayerRespawnLimitOut();
            break;

        case 27: // '\033'
            GameObject.LogD("_MSG_PLAYER_EXCLUDED\n");
            MsgRecvClientPlayerExcluded();
            break;

        case 28: // '\034'
            GameObject.LogD("_MSG_PLAYER_KICKED_OUT\n");
            MsgRecvClientPlayerKickedOut();
            break;

        case 29: // '\035'
            GameObject.LogD("_MSG_PLAYER_BANNED\n");
            MsgRecvClientPlayerBanned();
            break;

        case 40: // '('
            GameObject.LogD("_MSG_FX_RESPAWN_ON_LEVEL\n");
            MsgRecvClientFXRespawnOnLevel();
            break;

        case 30: // '\036'
            GameObject.LogD("_MSG_GAMEOVER\n");
            MsgRecvClientGameOver();
            break;

        case 31: // '\037'
            GameObject.LogD("_MSG_GAMERESTART\n");
            MsgRecvClientGameRestart();
            break;

        case 42: // '*'
            GameObject.LogD("_MSG_NEW_GAME_PARAMS\n");
            MsgRecvClientNewGameParams();
            break;

        case 32: // ' '
            GameObject.LogD("_MSG_NEXTLEVEL\n");
            MsgRecvClientNextLevel();
            break;

        case 33: // '!'
            GameObject.LogD("_MSG_OBJECTIVE_UPDATED\n");
            MsgRecvClientObjectiveUpdated();
            break;

        case 34: // '"'
            GameObject.LogD("_MSG_GAMESTATUSMSG_UPDATED\n");
            MsgRecvClientGameStatusMsgUpdated();
            break;

        case 43: // '+'
            GameObject.LogD("_MSG_AFTER_GAME_OVER_PING\n");
            MsgRecvClientGameOverPing();
            break;

        default:
            super.OnMessage();
            break;
        }
    }

    void MsgRecvServerCreatePlayer()
    {
        if(super.Role < 4)
            return;
        int aSkins[] = new int[NetPlayerModelInfo.GetSkinsPartialCnt()];
        int nClientId = MessageGetSenderId();
        int nGameVersion = MessageUnPackInt();
        String sPlayerName = MessageUnPackString();
        String sMeshName = MessageUnPackString();
        for(int i = 0; i < aSkins.length; i++)
            aSkins[i] = MessageUnPackInt();

        String sLevelName = MessageUnPackString();
        int nLevelCRC = MessageUnPackInt();
        boolean bAutoPlayer = MessageUnPackBoolean();
        MessageEnd();
        NetPlayerProfile cProfile = new NetPlayerProfile();
        if(bAutoPlayer)
        {
            sPlayerName = "autoplayer: " + sPlayerName;
            cProfile.SetAutoPlayer(true);
        }
        cProfile.SetPlayerName(sPlayerName);
        cProfile.SetMeshName(sMeshName);
        cProfile.SetSkins(aSkins);
        MsgSendClientCreatePlayerConfirm(nClientId);
        int nResults = ServerCreatePlayer(cProfile, nClientId, sLevelName, nLevelCRC, nGameVersion);
        if(nResults != 0 && nClientId != 0)
        {
            MsgSendClientCreatePlayerCancel(nClientId, nResults);
            CheckKickClientOnFailedCreatePlayer(nClientId, nResults);
        }
    }

    boolean IsPlayerWinner(NetPlayerInfo cPlayerInfo, int nWinnerId)
    {
        if(cPlayerInfo == null)
            return false;
        NetPlayerInfo cWinnerInfo = GetPlayerInfoByNetId(nWinnerId);
        if(cWinnerInfo == null)
            return false;
        return cPlayerInfo == cWinnerInfo;
    }

    void EventGameSettingsChanged()
    {
        super.EventGameSettingsChanged();
        MsgSendClientUpdateGameSettings();
    }

    void MsgRecvClientNewGameParams()
    {
        float fPhysicsGranularity = MessageUnPackFloat();
        float fPhysicsLastUpdateTime = MessageUnPackFloat();
        float fMaxResendMoveTime = MessageUnPackFloat();
        boolean bAutoPlayersCanFire = MessageUnPackBoolean();
        boolean bClientGameShutdown = MessageUnPackBoolean();
        MessageEnd();
        SetPhysicsGranularity(fPhysicsGranularity);
        if(super.m_cModule != null && fPhysicsLastUpdateTime >= 0.0F)
            super.m_cModule.SetPhysicsLastUpdateTime(fPhysicsLastUpdateTime);
        SetMaxResendMoveTime(fMaxResendMoveTime);
        SetAutoPlayersFire(bAutoPlayersCanFire);
        if(bClientGameShutdown)
            SetClientShutdown();
    }

    int ServerCreatePlayer(NetPlayerProfile cProfile, int nClientId, String sLevelName, int nLevelCRC, int nGameVersion)
    {
        if(!NetGameVersion.IsVersionCompatible(nGameVersion, GetGameVersion()))
            return 4;
        if(!sLevelName.equals(super.m_cModule.GetGameInitInfo().GetCurrentLevelName()))
        {
            return 2;
        } else
        {
            int nResults = ServerCreatePlayer(cProfile, nClientId, nGameVersion);
            return nResults;
        }
    }

    void MsgRecvClientCreatePlayerConfirm()
    {
        if(super.Role == 4)
        {
            return;
        } else
        {
            MessageEnd();
            DisableCallMethod(METHOD_ClientCreateMyPlayerRequest);
            return;
        }
    }

    void MsgRecvClientUpdateGameSettings()
    {
        boolean bChanged = MessageUnPackGameSettings();
        MessageEnd();
        if(bChanged)
            OnUpdateGameSettings();
    }

    static int GetGameVersion()
    {
        return NetGameVersion.Get();
    }

    static void SetAutoPlayer(boolean bAutoPlayer)
    {
        sm_bAutoPlayer = bAutoPlayer;
    }

    void OnUpdateGameSettings()
    {
        super.OnUpdateGameSettings();
        if(GetMyPlayerNet() != null)
            GetMyPlayerNet().OnUpdateGameSettings();
    }

    NetGameInfo()
    {
        METHOD_ClientCreateMyPlayerRequest = 0;
        METHOD_ServerCreateMyPlayer = 0;
        METHOD_OnSetGameSettings = 0;
        METHOD_EventAfterGameOver = 0;
        METHOD_LoadNextLevel = 0;
        METHOD_ServerDelayedLoadNextLevel = 0;
        METHOD_QuitGameOnGameOver = 0;
        METHOD_ForceQuitGame = 0;
        METHOD_StartSendingMsgClientPlayersState = 0;
        METHOD_MsgSendClientPlayersState = 0;
        METHOD_VerifyPlayersState = 0;
        METHOD_MsgSendServerPing = 0;
        METHOD_ServerSendClientNextLevel = 0;
        m_bGameParamsChanged = false;
        m_bWaitForQuitGameOnGameOver = false;
        m_bWaitForLoadNextLevel = false;
        m_cNextLevel = null;
        m_bCreatePlayerCancelReceived = false;
        super.Role = 1;
        SetGameType(0);
    }

    void EventPlayerSpawned(PlayerNet cPlayer)
    {
        if(super.Role < 4)
            return;
        NetPlayerInfo cPlayerInfo = null;
        if(cPlayer != null)
        {
            cPlayerInfo = cPlayer.GetPlayerInfo();
            if(cPlayerInfo != null)
            {
                cPlayerInfo.IncRespawnCnt();
                cPlayerInfo.UpdateRespawnLimitCnt();
                if(!cPlayerInfo.RespawnLimitAvailable())
                {
                    int nPlayerInfoId = cPlayerInfo.GetNetId();
                    MsgSendClientPlayerRespawnLimitOut(nPlayerInfoId);
                    AddIncomingMessage(19, nPlayerInfoId);
                }
            } else
            {
                GameObject.CrashLog("ERROR: " + this + " EventPlayerSpawned cPlayer " + cPlayer + " cNetPlayerInfo == null\n");
            }
        }
    }

    void MsgSendClientObjectiveUpdated(int nUpdate, int iGroupNo, int iSubObjNo, boolean bMesssagesActive)
    {
        MessageNew(33);
        MessagePackInt(nUpdate);
        MessagePackInt(iGroupNo);
        MessagePackInt(iSubObjNo);
        MessagePackBoolean(bMesssagesActive);
        MessageSend();
    }

    void ServerDeletePlayerInfo(PlayerNet cPlayer)
    {
        EventPlayerLeft(cPlayer);
        super.ServerDeletePlayerInfo(cPlayer);
        if(GetPlayerInfoList().GetSize() <= 0)
            StopSendingMsgClientPlayersState();
    }

    void MsgSendClientPlayerChangedNick(String sOldNick, String sNewNick, int nPlayerInfoId, boolean bForced)
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(25);
            MessagePackStringBool(sOldNick);
            MessagePackStringBool(sNewNick);
            MessagePackInt(nPlayerInfoId);
            MessagePackBoolean(bForced);
            MessageSend();
            return;
        }
    }

    void EventConnectionToServerLost()
    {
        super.EventConnectionToServerLost();
        if(!m_bWaitForLoadNextLevel && !m_bWaitForQuitGameOnGameOver)
            CallMethodIn(METHOD_ForceQuitGame, 5F);
    }

    void MsgRecvClientPlayerRespawnLimitOut()
    {
        int nPlayerInfoId = MessageUnPackInt();
        MessageEnd();
        AddIncomingMessage(19, nPlayerInfoId);
    }

    void MsgSendClientPlayerExcluded(int nPlayerInfoId)
    {
        MessageNew(27);
        MessagePackInt(nPlayerInfoId);
        MessageSend();
    }

    void EventTeamExcluded(NetTeamInfo netteaminfo)
    {
    }

    void ServerDelayedLoadNextLevel()
    {
        DisableCallMethod(METHOD_ServerDelayedLoadNextLevel);
        DisableCallMethod(METHOD_ServerSendClientNextLevel);
        super.m_cModule.CallMethodIn(super.m_cModule.METHOD_ServerLoadNextLevel, 0.0F);
    }

    void MsgSendServerPing()
    {
        MessageNew(12);
        MessageSend();
    }

    void MsgSendClientTimeInfo()
    {
        MessageNewUnreliable(18);
        MessagePackFloat(GetGameTime());
        GetPlayerInfoList().MessagePackPlayersPing();
        MessageSend();
    }

    void EventPlayerChangedNick(NetPlayerInfo cPlayerInfo, String sOldNick)
    {
        String sNewNick = cPlayerInfo.GetNick();
        AddIncomingMessage(17, sOldNick, sNewNick, cPlayerInfo.GetNetId());
        MsgSendClientPlayerChangedNick(sOldNick, sNewNick, cPlayerInfo.GetNetId(), false);
        ChangeNickInProfileIfOwner(cPlayerInfo.GetNetId(), sNewNick);
    }

    void MsgRecvClientPlayerChangedNick()
    {
        String sOldNick = MessageUnPackStringBool("");
        String sNewNick = MessageUnPackStringBool("");
        int nPlayerInfoId = MessageUnPackInt();
        boolean bForced = MessageUnPackBoolean();
        MessageEnd();
        int nMsgId = bForced ? 18 : 17;
        AddIncomingMessage(nMsgId, sOldNick, sNewNick, nPlayerInfoId);
        ChangeNickInProfileIfOwner(nPlayerInfoId, sNewNick);
    }

    void OnCreate()
    {
        METHOD_ClientCreateMyPlayerRequest = RegisterCallMethod("ClientCreateMyPlayerRequest");
        METHOD_ServerCreateMyPlayer = RegisterCallMethod("ServerCreateMyPlayer");
        METHOD_OnSetGameSettings = RegisterCallMethod("OnSetGameSettings");
        METHOD_EventAfterGameOver = RegisterCallMethod("EventAfterGameOver");
        METHOD_LoadNextLevel = RegisterCallMethod("LoadNextLevel");
        METHOD_ServerDelayedLoadNextLevel = RegisterCallMethod("ServerDelayedLoadNextLevel");
        METHOD_QuitGameOnGameOver = RegisterCallMethod("QuitGameOnGameOver");
        METHOD_ForceQuitGame = RegisterCallMethod("ForceQuitGame");
        METHOD_StartSendingMsgClientPlayersState = RegisterCallMethod("StartSendingMsgClientPlayersState");
        METHOD_MsgSendClientPlayersState = RegisterCallMethod("MsgSendClientPlayersState");
        METHOD_VerifyPlayersState = RegisterCallMethod("VerifyPlayersState");
        METHOD_MsgSendServerPing = RegisterCallMethod("MsgSendServerPing");
        METHOD_ServerSendClientNextLevel = RegisterCallMethod("ServerSendClientNextLevel");
        super.OnCreate();
        if(super.Role < 4)
        {
            super.m_cModule.SetGameInfo(this);
            InitTimeCompensator();
            GameObject.LogD("New player request\n");
            ClientCreateMyPlayerRequest();
        } else
        {
            if(((ModuleNetBase) (super.m_cModule)).bBotsForTest)
            {
                if(NetGameInfoBase.sm_nBotsCnt > 0)
                    super.nPlayersCntToAdd = NetGameInfoBase.sm_nBotsCnt;
                CallMethodEvery("CheckAdditionalPlayersToCreate", 1.0F);
            }
            ServerInitGame();
            ServerPostInitGame();
        }
        EnableMessages();
    }

    void OnInputKey(int nKeyCode, boolean bKeyState, char nKeyAscii)
    {
        if(!bKeyState)
            return;
        if(nKeyCode == 57)
            if(m_bWaitForLoadNextLevel && super.Role == 4)
                CallMethodIn(METHOD_LoadNextLevel, 0.0F);
            else
            if(m_bWaitForQuitGameOnGameOver)
                CallMethodIn(METHOD_QuitGameOnGameOver, 0.0F);
        if(Game.CheatsEnabled() && nKeyCode == 44)
        {
            String sText = "" + GetTime();
            if(super.m_cTimeCompensator != null)
                sText += " " + super.m_cTimeCompensator.GetInfo();
            AddIncomingMessage(37, sText);
        }
    }

    void MsgRecvClientCreatePlayerCancel()
    {
        int nResult = MessageUnPackInt();
        MessageEnd();
        if(super.Role == 4)
            return;
        DisableCallMethod(METHOD_ClientCreateMyPlayerRequest);
        if(nResult == 5)
            return;
        if(m_bCreatePlayerCancelReceived)
            return;
        m_bCreatePlayerCancelReceived = true;
        if(nResult == 2)
        {
            CallMethodIn(METHOD_LoadNextLevel, 0.0F);
            return;
        }
        if(super.m_cModule.m_cPrecache != null)
            super.m_cModule.m_cPrecache.StartGame();
        String sMsg = NetMsg.sYouCantJoinGame;
        switch(nResult)
        {
        case 3: // '\003'
            sMsg = NetMsg.sYouCantJoinGameBecauseWrongCRCMap;
            break;

        case 4: // '\004'
            sMsg = NetMsg.sYouCantJoinGameBecauseWrongGameVersion;
            break;

        case 6: // '\006'
            sMsg = sMsg + " " + Text.Get("&SERVER_FULL&");
            break;
        }
        AddIncomingMessage(sMsg);
    }

    void VerifyPlayersState()
    {
        GetPlayerInfoList().VerifyPlayersState();
    }

    void MsgSendServerIAmReady()
    {
        MessageNew(11);
        MessageSend();
    }

    void StartSendingMsgClientPlayersState()
    {
        StopSendingMsgClientPlayersState();
        CallMethodEvery(METHOD_MsgSendClientPlayersState, sm_fSendingMsgClientPlayersStatePeriod);
    }

    void StopSendingMsgClientPlayersState()
    {
        DisableCallMethod(METHOD_MsgSendClientPlayersState);
    }

    void StartTimeCompensator()
    {
        DisableCallMethod(METHOD_MsgSendServerPing);
        super.StartTimeCompensator();
    }

    void MsgSendClientGameRestart()
    {
        if(super.Role < 4)
        {
            return;
        } else
        {
            MessageNew(31);
            MessagePackBoolean(super.m_bFirstRestart);
            MessagePackInt(super.m_nRestartMode);
            MessageSend();
            return;
        }
    }

    boolean SetMaxResendMoveTime(float fMaxResendMoveTime)
    {
        boolean bRet = super.SetMaxResendMoveTime(fMaxResendMoveTime);
        if(bRet && super.Role == 4)
            MsgSendClientNewGameParams();
        return bRet;
    }

    static boolean sm_bSendGameSettingOnJoin = false;
    static final int _MSG_CREATE_PLAYER = 10;
    static final int _MSG_I_AM_READY = 11;
    static final int _MSG_PING_SERVER = 12;
    static final int _MSG_CREATE_PLAYER_CONFIRM = 15;
    static final int _MSG_CREATE_PLAYER_CANCEL = 16;
    static final int _MSG_PLAYERS_STATE = 17;
    static final int _MSG_TIME_INFO = 18;
    static final int _MSG_GAME_SETTINGS = 20;
    static final int _MSG_UPDATE_GAME_SETTINGS = 21;
    static final int _MSG_PLAYER_JOINED = 22;
    static final int _MSG_PLAYER_LEFT = 23;
    static final int _MSG_PLAYER_DIED = 24;
    static final int _MSG_PLAYER_CHANGED_NICK = 25;
    static final int _MSG_PLAYER_RESPAWN_LIMIT_OUT = 26;
    static final int _MSG_PLAYER_EXCLUDED = 27;
    static final int _MSG_PLAYER_KICKED_OUT = 28;
    static final int _MSG_PLAYER_BANNED = 29;
    static final int _MSG_GAMEOVER = 30;
    static final int _MSG_GAMERESTART = 31;
    static final int _MSG_NEXTLEVEL = 32;
    static final int _MSG_OBJECTIVE_UPDATED = 33;
    static final int _MSG_GAMESTATUSMSG_UPDATED = 34;
    static final int _MSG_FX_RESPAWN_ON_LEVEL = 40;
    static final int _MSG_NEW_GAME_PARAMS = 42;
    static final int _MSG_AFTER_GAME_OVER_PING = 43;
    int METHOD_ClientCreateMyPlayerRequest;
    int METHOD_ServerCreateMyPlayer;
    int METHOD_OnSetGameSettings;
    int METHOD_EventAfterGameOver;
    int METHOD_LoadNextLevel;
    int METHOD_ServerDelayedLoadNextLevel;
    int METHOD_QuitGameOnGameOver;
    int METHOD_ForceQuitGame;
    int METHOD_StartSendingMsgClientPlayersState;
    int METHOD_MsgSendClientPlayersState;
    int METHOD_VerifyPlayersState;
    int METHOD_MsgSendServerPing;
    int METHOD_ServerSendClientNextLevel;
    boolean m_bGameParamsChanged;
    static final float _EVENT_AFTER_GAME_OVER_TIME = 5F;
    static final float _LOAD_NEXT_LEVEL_ON_SERVER_DEFAULT_TIME = 5F;
    static final float _LOAD_NEXT_LEVEL_ON_SERVER_ADD_DELAY_TIME = 5F;
    static final float _LOAD_NEXT_LEVEL_ON_CLIENT_TIME = 12F;
    static final float _QUIT_GAME_AFTER_DISCONNECT_TIME = 5F;
    static final float _IN_GAME_MENU_DELAY = 3F;
    private boolean m_bWaitForQuitGameOnGameOver;
    private boolean m_bWaitForLoadNextLevel;
    LevelContent m_cNextLevel;
    static boolean sm_bBreakpoint = false;
    boolean m_bCreatePlayerCancelReceived;
    static boolean sm_bAutoPlayer = false;
    static float sm_fSendingMsgClientPlayersStatePeriod = 20F;
    static float sm_fSendingMsgClientPlayersStateDelay = 10F;
    static float sm_fVerifyPlayersStateDelay = 1.0F;

}