List of network game messages

There are three types of messages with overlapping message ids:
system messages, game messages and control messages
This list is only covering game messages.

When the client and server exchange packets. An integer field which usually does not exceed one byte. Is indicating which type of message was sent. This field is called the message id. These message ids are defined in generated/protocol.h which is generated by datasrc/network.py which also includes the message payload. There can be multiple messages in so called chunks in one teeworlds packet.
The message names give a hint about who is sending and receiving them. The format is always

                
    NETMSGTYPE_<sender>_<name>
                
            

• SV - Server sending to client
• CL - Client sending to server
• DE - used for Demos only and is not actually sent

NETMSG_INVALID

NETMSGTYPE_SV_MOTD

NETMSGTYPE_SV_BROADCAST

NETMSGTYPE_SV_CHAT

NETMSGTYPE_SV_TEAM

                
    40 06 0c 08 00 40 00 91 3b   @....@..;
    \______/ ^  ^  ^  ^  \___/
       |     |  |  |  |    |
    chunk    |  |  |  |   Cooldown Tick (3793)
    header   |  |  |  |
flags: vital |  |  |  Silent (0/false)
size: 6      |  |  |
seq: 12      |  | TEAM_SPECTATORS (-1)
             |  |
             | ClientID (0)
             |
        NETMSGTYPE_SV_TEAM (msg=4 system=false)
                
            

NETMSGTYPE_SV_KILLMSG

                
    void CCharacter::Die(int Killer, int Weapon)
    {
        // we got to wait 0.5 secs before respawning
        m_Alive = false;
        m_pPlayer->m_RespawnTick = Server()->Tick()+Server()->TickSpeed()/2;
        int ModeSpecial = GameServer()->m_pController->OnCharacterDeath(this, (Killer < 0) ? 0 : GameServer()->m_apPlayers[Killer], Weapon);

        char aBuf[256];
        if(Killer < 0)
        {
            str_format(aBuf, sizeof(aBuf), "kill killer='%d:%d:' victim='%d:%d:%s' weapon=%d special=%d",
                Killer, - 1 - Killer,
                m_pPlayer->GetCID(), m_pPlayer->GetTeam(), Server()->ClientName(m_pPlayer->GetCID()), Weapon, ModeSpecial
            );
        }
        else
        {
            str_format(aBuf, sizeof(aBuf), "kill killer='%d:%d:%s' victim='%d:%d:%s' weapon=%d special=%d",
                Killer, GameServer()->m_apPlayers[Killer]->GetTeam(), Server()->ClientName(Killer),
                m_pPlayer->GetCID(), m_pPlayer->GetTeam(), Server()->ClientName(m_pPlayer->GetCID()), Weapon, ModeSpecial
            );
        }
        GameServer()->Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "game", aBuf);

        // send the kill message
        CNetMsg_Sv_KillMsg Msg;
        Msg.m_Victim = m_pPlayer->GetCID();
        Msg.m_ModeSpecial = ModeSpecial;
        for(int i = 0 ; i < MAX_CLIENTS; i++)
        {
            if(!Server()->ClientIngame(i))
                continue;

            if(Killer < 0 && Server()->GetClientVersion(i) < MIN_KILLMESSAGE_CLIENTVERSION)
            {
                Msg.m_Killer = 0;
                Msg.m_Weapon = WEAPON_WORLD;
            }
            else
            {
                Msg.m_Killer = Killer;
                Msg.m_Weapon = Weapon;
            }
            Server()->SendPackMsg(&Msg, MSGFLAG_VITAL, i);
        }

        // a nice sound
        GameServer()->CreateSound(m_Pos, SOUND_PLAYER_DIE);

        // this is for auto respawn after 3 secs
        m_pPlayer->m_DieTick = Server()->Tick();

        GameWorld()->RemoveEntity(this);
        GameWorld()->m_Core.m_apCharacters[m_pPlayer->GetCID()] = 0;
        GameServer()->CreateDeath(m_Pos, m_pPlayer->GetCID());
    }
                
            

                
void CInfoMessages::OnMessage(int MsgType, void *pRawMsg)
{
	// [..]

	bool Race = m_pClient->m_GameInfo.m_GameFlags&GAMEFLAG_RACE;

	if(MsgType == NETMSGTYPE_SV_KILLMSG)
	{
		// [..]

		CNetMsg_Sv_KillMsg *pMsg = (CNetMsg_Sv_KillMsg *)pRawMsg;

		// unpack messages
		CInfoMsg Kill;
		Kill.m_Player1ID = pMsg->m_Victim;
		if(Config()->m_ClShowsocial)
		{
			Kill.m_Player1NameCursor.m_FontSize = 36.0f;
			TextRender()->TextDeferred(&Kill.m_Player1NameCursor, m_pClient->m_aClients[Kill.m_Player1ID].m_aName, -1);
		}

		Kill.m_Player1RenderInfo = m_pClient->m_aClients[Kill.m_Player1ID].m_RenderInfo;

		Kill.m_Player2ID = pMsg->m_Killer;
		// [..]

		Kill.m_Weapon = pMsg->m_Weapon;
		Kill.m_ModeSpecial = pMsg->m_ModeSpecial;
		Kill.m_FlagCarrierBlue = m_pClient->m_Snap.m_pGameDataFlag ? m_pClient->m_Snap.m_pGameDataFlag->m_FlagCarrierBlue : -1;

		AddInfoMsg(INFOMSG_KILL, Kill);
	}
    // [..]
                
            

                
    void CHud::OnMessage(int MsgType, void *pRawMsg)
    {
        // [..]
        else if(MsgType == NETMSGTYPE_SV_KILLMSG && (m_pClient->m_GameInfo.m_GameFlags&GAMEFLAG_RACE))
        {
            // reset checkpoint time on death
            CNetMsg_Sv_KillMsg *pMsg = (CNetMsg_Sv_KillMsg *)pRawMsg;
            if(pMsg->m_Victim == m_pClient->m_LocalClientID)
                m_CheckpointTime = 0;
        }
    }
                
            

NETMSGTYPE_SV_TUNEPARAMS

                
    void CGameClient::OnMessage(int MsgId, CUnpacker *pUnpacker)
    {
        Client()->RecordGameMessage(true);

        // special messages
        if(MsgId == NETMSGTYPE_SV_TUNEPARAMS && Client()->State() != IClient::STATE_DEMOPLAYBACK)
        {
            Client()->RecordGameMessage(false);
            // unpack the new tuning
            CTuningParams NewTuning;
            int *pParams = (int *)&NewTuning;
            for(unsigned i = 0; i < sizeof(CTuningParams)/sizeof(int); i++)
                pParams[i] = pUnpacker->GetInt();

            // check for unpacking errors
            if(pUnpacker->Error())
                return;

            m_ServerMode = SERVERMODE_PURE;

            // apply new tuning
            m_Tuning = NewTuning;
            return;
        }
                
            

NETMSGTYPE_SV_EXTRAPROJECTILE

NETMSGTYPE_SV_READYTOENTER

                
    CNetMsg_Sv_ReadyToEnter m;
    Server()->SendPackMsg(&m, MSGFLAG_VITAL|MSGFLAG_FLUSH, ClientID);
                
            

                
    else if(MsgId == NETMSGTYPE_SV_READYTOENTER)
    {
        Client()->EnterGame();
    }
                
            

                
    void CClient::SendEnterGame()
    {
        CMsgPacker Msg(NETMSG_ENTERGAME, true);
        SendMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_FLUSH);
    }
                
            

NETMSGTYPE_SV_WEAPONPICKUP

NETMSGTYPE_SV_EMOTICON

NETMSGTYPE_SV_VOTECLEAROPTIONS

NETMSGTYPE_SV_VOTEOPTIONLISTADD

                
    else if(MsgId == NETMSGTYPE_SV_VOTEOPTIONLISTADD)
    {
        int NumOptions = pUnpacker->GetInt();
        for(int i = 0; i < NumOptions; i++)
        {
            const char *pDescription = pUnpacker->GetString(CUnpacker::SANITIZE_CC);
            if(pUnpacker->Error())
                return;

            m_pVoting->AddOption(pDescription);
        }
    }
                
            

                
    CVoteOptionServer *pCurrent = m_pVoteOptionFirst;
    while(pCurrent)
    {
        // count options for actual packet
        int NumOptions = 0;
        for(CVoteOptionServer *p = pCurrent; p && NumOptions < MAX_VOTE_OPTION_ADD; p = p->m_pNext, ++NumOptions);

        // pack and send vote list packet
        CMsgPacker Msg(NETMSGTYPE_SV_VOTEOPTIONLISTADD);
        Msg.AddInt(NumOptions);
        while(pCurrent && NumOptions--)
        {
            Msg.AddString(pCurrent->m_aDescription, VOTE_DESC_LENGTH);
            pCurrent = pCurrent->m_pNext;
        }
        Server()->SendMsg(&Msg, MSGFLAG_VITAL, ClientID);
    }
                
            

NETMSGTYPE_SV_VOTEOPTIONADD

                
    else if(MsgType == NETMSGTYPE_SV_VOTEOPTIONADD)
    {
        CNetMsg_Sv_VoteOptionAdd *pMsg = (CNetMsg_Sv_VoteOptionAdd *)pRawMsg;
        AddOption(pMsg->m_pDescription);
    }
                
            

NETMSGTYPE_SV_VOTEOPTIONREMOVE

NETMSGTYPE_SV_VOTESET

NETMSGTYPE_SV_VOTESTATUS

NETMSGTYPE_SV_SERVERSETTINGS

NETMSGTYPE_SV_CLIENTINFO

What is sent in NETMSGTYPE_SV_CLIENTINFO?

                
    const char * const CSkins::ms_apSkinPartNames[NUM_SKINPARTS] = {"body", "marking", "decoration", "hands", "feet", "eyes"};
                
            

When is NETMSGTYPE_SV_CLIENTINFO sent?

                
    void CGameContext::OnClientEnter(int ClientID)
    {
        // [..]

        // update client infos (others before local)
        CNetMsg_Sv_ClientInfo NewClientInfoMsg;
        NewClientInfoMsg.m_ClientID = ClientID;
        NewClientInfoMsg.m_Local = 0;
        NewClientInfoMsg.m_Team = m_apPlayers[ClientID]->GetTeam();
        NewClientInfoMsg.m_pName = Server()->ClientName(ClientID);
        NewClientInfoMsg.m_pClan = Server()->ClientClan(ClientID);
        NewClientInfoMsg.m_Country = Server()->ClientCountry(ClientID);
        NewClientInfoMsg.m_Silent = false;

        if(Config()->m_SvSilentSpectatorMode && m_apPlayers[ClientID]->GetTeam() == TEAM_SPECTATORS)
            NewClientInfoMsg.m_Silent = true;

        for(int p = 0; p < NUM_SKINPARTS; p++)
        {
            NewClientInfoMsg.m_apSkinPartNames[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aaSkinPartNames[p];
            NewClientInfoMsg.m_aUseCustomColors[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aUseCustomColors[p];
            NewClientInfoMsg.m_aSkinPartColors[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aSkinPartColors[p];
        }

        for(int i = 0; i < MAX_CLIENTS; ++i)
        {
            if(i == ClientID || !m_apPlayers[i] || (!Server()->ClientIngame(i) && !m_apPlayers[i]->IsDummy()))
                continue;

            // new info for others
            if(Server()->ClientIngame(i))
                Server()->SendPackMsg(&NewClientInfoMsg, MSGFLAG_VITAL|MSGFLAG_NORECORD, i);

            // existing infos for new player
            CNetMsg_Sv_ClientInfo ClientInfoMsg;
            ClientInfoMsg.m_ClientID = i;
            ClientInfoMsg.m_Local = 0;
            ClientInfoMsg.m_Team = m_apPlayers[i]->GetTeam();
            ClientInfoMsg.m_pName = Server()->ClientName(i);
            ClientInfoMsg.m_pClan = Server()->ClientClan(i);
            ClientInfoMsg.m_Country = Server()->ClientCountry(i);
            ClientInfoMsg.m_Silent = false;
            for(int p = 0; p < NUM_SKINPARTS; p++)
            {
                ClientInfoMsg.m_apSkinPartNames[p] = m_apPlayers[i]->m_TeeInfos.m_aaSkinPartNames[p];
                ClientInfoMsg.m_aUseCustomColors[p] = m_apPlayers[i]->m_TeeInfos.m_aUseCustomColors[p];
                ClientInfoMsg.m_aSkinPartColors[p] = m_apPlayers[i]->m_TeeInfos.m_aSkinPartColors[p];
            }
            Server()->SendPackMsg(&ClientInfoMsg, MSGFLAG_VITAL|MSGFLAG_NORECORD, ClientID);
        }

        // local info
        NewClientInfoMsg.m_Local = 1;
        Server()->SendPackMsg(&NewClientInfoMsg, MSGFLAG_VITAL|MSGFLAG_NORECORD, ClientID);

        // [..]
    }
                
            

NETMSGTYPE_SV_GAMEINFO

                
    void IGameController::UpdateGameInfo(int ClientID)
    {
        CNetMsg_Sv_GameInfo GameInfoMsg;
        GameInfoMsg.m_GameFlags = m_GameFlags;
        GameInfoMsg.m_ScoreLimit = m_GameInfo.m_ScoreLimit;
        GameInfoMsg.m_TimeLimit = m_GameInfo.m_TimeLimit;
        GameInfoMsg.m_MatchNum = m_GameInfo.m_MatchNum;
        GameInfoMsg.m_MatchCurrent = m_GameInfo.m_MatchCurrent;

        CNetMsg_Sv_GameInfo GameInfoMsgNoRace = GameInfoMsg;
        GameInfoMsgNoRace.m_GameFlags &= ~GAMEFLAG_RACE;

        if(ClientID == -1)
        {
            for(int i = 0; i < MAX_CLIENTS; ++i)
            {
                if(!GameServer()->m_apPlayers[i] || !Server()->ClientIngame(i))
                    continue;

                CNetMsg_Sv_GameInfo *pInfoMsg = (Server()->GetClientVersion(i) < CGameContext::MIN_RACE_CLIENTVERSION) ? &GameInfoMsgNoRace : &GameInfoMsg;
                Server()->SendPackMsg(pInfoMsg, MSGFLAG_VITAL|MSGFLAG_NORECORD, i);
            }
        }
        else
        {
            CNetMsg_Sv_GameInfo *pInfoMsg = (Server()->GetClientVersion(ClientID) < CGameContext::MIN_RACE_CLIENTVERSION) ? &GameInfoMsgNoRace : &GameInfoMsg;
            Server()->SendPackMsg(pInfoMsg, MSGFLAG_VITAL|MSGFLAG_NORECORD, ClientID);
        }
    }
                
            

                
    else if(MsgId == NETMSGTYPE_SV_GAMEINFO && Client()->State() != IClient::STATE_DEMOPLAYBACK)
    {
        Client()->RecordGameMessage(false);
        CNetMsg_Sv_GameInfo *pMsg = (CNetMsg_Sv_GameInfo *)pRawMsg;

        m_GameInfo.m_GameFlags = pMsg->m_GameFlags;
        m_GameInfo.m_ScoreLimit = pMsg->m_ScoreLimit;
        m_GameInfo.m_TimeLimit = pMsg->m_TimeLimit;
        m_GameInfo.m_MatchNum = pMsg->m_MatchNum;
        m_GameInfo.m_MatchCurrent = pMsg->m_MatchCurrent;
    }
                
            

NETMSGTYPE_SV_CLIENTDROP

                
    void CGameContext::OnClientDrop(int ClientID, const char *pReason)
    {
        AbortVoteOnDisconnect(ClientID);
        m_pController->OnPlayerDisconnect(m_apPlayers[ClientID]);

        // update clients on drop
        if(Server()->ClientIngame(ClientID) || IsClientBot(ClientID))
        {
            if(Server()->DemoRecorder_IsRecording())
            {
                CNetMsg_De_ClientLeave Msg;
                Msg.m_pName = Server()->ClientName(ClientID);
                Msg.m_pReason = pReason;
                Server()->SendPackMsg(&Msg, MSGFLAG_NOSEND, -1);
            }

            CNetMsg_Sv_ClientDrop Msg;
            Msg.m_ClientID = ClientID;
            Msg.m_pReason = pReason;
            Msg.m_Silent = false;
            if(Config()->m_SvSilentSpectatorMode && m_apPlayers[ClientID]->GetTeam() == TEAM_SPECTATORS)
                Msg.m_Silent = true;
            Server()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_NORECORD, -1);
        }

        // [..]
    }
                
            

                
    else if(MsgId == NETMSGTYPE_SV_CLIENTDROP && Client()->State() != IClient::STATE_DEMOPLAYBACK)
    {
        Client()->RecordGameMessage(false);
        CNetMsg_Sv_ClientDrop *pMsg = (CNetMsg_Sv_ClientDrop *)pRawMsg;

        if(m_LocalClientID == pMsg->m_ClientID || !m_aClients[pMsg->m_ClientID].m_Active)
        {
            if(Config()->m_Debug)
                Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "client", "invalid clientdrop");
            return;
        }

        if(!pMsg->m_Silent)
        {
            DoLeaveMessage(m_aClients[pMsg->m_ClientID].m_aName, pMsg->m_ClientID, pMsg->m_pReason);

            if(m_pDemoRecorder->IsRecording())
            {
                CNetMsg_De_ClientLeave Msg;
                Msg.m_pName = m_aClients[pMsg->m_ClientID].m_aName;
                Msg.m_ClientID = pMsg->m_ClientID;
                Msg.m_pReason = pMsg->m_pReason;
                Client()->SendPackMsg(&Msg, MSGFLAG_NOSEND | MSGFLAG_RECORD);
            }
        }

        // [..]
    }
                
            

NETMSGTYPE_SV_GAMEMSG

                            
    float Time = aParaI[2] / (float)Client()->GameTickSpeed();
                            
                        

                
    void CGameContext::SendGameMsg(int GameMsgID, int ClientID)
    {
        CMsgPacker Msg(NETMSGTYPE_SV_GAMEMSG);
        Msg.AddInt(GameMsgID);
        Server()->SendMsg(&Msg, MSGFLAG_VITAL, ClientID);
    }

    void CGameContext::SendGameMsg(int GameMsgID, int ParaI1, int ClientID)
    {
        CMsgPacker Msg(NETMSGTYPE_SV_GAMEMSG);
        Msg.AddInt(GameMsgID);
        Msg.AddInt(ParaI1);
        Server()->SendMsg(&Msg, MSGFLAG_VITAL, ClientID);
    }

    void CGameContext::SendGameMsg(int GameMsgID, int ParaI1, int ParaI2, int ParaI3, int ClientID)
    {
        CMsgPacker Msg(NETMSGTYPE_SV_GAMEMSG);
        Msg.AddInt(GameMsgID);
        Msg.AddInt(ParaI1);
        Msg.AddInt(ParaI2);
        Msg.AddInt(ParaI3);
        Server()->SendMsg(&Msg, MSGFLAG_VITAL, ClientID);
    }
                
            

                
    else if(MsgId == NETMSGTYPE_SV_GAMEMSG)
    {
        int GameMsgID = pUnpacker->GetInt();

        // check for valid gamemsgid
        if(GameMsgID < 0 || GameMsgID >= NUM_GAMEMSGS)
            return;

        int aParaI[3];
        int NumParaI = 0;

        // get paras
        switch(gs_GameMsgList[GameMsgID].m_ParaType)
        {
        case PARA_I: NumParaI = 1; break;
        case PARA_II: NumParaI = 2; break;
        case PARA_III: NumParaI = 3; break;
        }
        for(int i = 0; i < NumParaI; i++)
        {
            aParaI[i] = pUnpacker->GetInt();
        }

        // check for unpacking errors
        if(pUnpacker->Error())
            return;

        // handle special messages
        char aBuf[256];
        bool TeamPlay = m_GameInfo.m_GameFlags&GAMEFLAG_TEAMS;
        if(gs_GameMsgList[GameMsgID].m_Action == DO_SPECIAL)
        {
            switch(GameMsgID)
            {
            case GAMEMSG_CTF_DROP:
                m_pSounds->Enqueue(CSounds::CHN_GLOBAL, SOUND_CTF_DROP);
                break;
            case GAMEMSG_CTF_RETURN:
                m_pSounds->Enqueue(CSounds::CHN_GLOBAL, SOUND_CTF_RETURN);
                break;
            case GAMEMSG_TEAM_ALL:
                {
                    const char *pMsg = "";
                    switch(GetStrTeam(aParaI[0], TeamPlay))
                    {
                    case STR_TEAM_GAME: pMsg = Localize("All players were moved to the game"); break;
                    case STR_TEAM_RED: pMsg = Localize("All players were moved to the red team"); break;
                    case STR_TEAM_BLUE: pMsg = Localize("All players were moved to the blue team"); break;
                    case STR_TEAM_SPECTATORS: pMsg = Localize("All players were moved to the spectators"); break;
                    }
                    m_pBroadcast->DoClientBroadcast(pMsg);
                }
                break;
            case GAMEMSG_TEAM_BALANCE_VICTIM:
                {
                    const char *pMsg = "";
                    switch(GetStrTeam(aParaI[0], TeamPlay))
                    {
                    case STR_TEAM_RED: pMsg = Localize("You were moved to the red team due to team balancing"); break;
                    case STR_TEAM_BLUE: pMsg = Localize("You were moved to the blue team due to team balancing"); break;
                    }
                    m_pBroadcast->DoClientBroadcast(pMsg);
                }
                break;
            case GAMEMSG_CTF_GRAB:
                if(m_LocalClientID != -1 && (m_aClients[m_LocalClientID].m_Team != aParaI[0] || (m_Snap.m_SpecInfo.m_Active &&
                                ((m_Snap.m_SpecInfo.m_SpectatorID != -1 && m_aClients[m_Snap.m_SpecInfo.m_SpectatorID].m_Team != aParaI[0]) ||
                                (m_Snap.m_SpecInfo.m_SpecMode == SPEC_FLAGRED && aParaI[0] != TEAM_RED) ||
                                (m_Snap.m_SpecInfo.m_SpecMode == SPEC_FLAGBLUE && aParaI[0] != TEAM_BLUE)))))
                    m_pSounds->Enqueue(CSounds::CHN_GLOBAL, SOUND_CTF_GRAB_PL);
                else
                    m_pSounds->Enqueue(CSounds::CHN_GLOBAL, SOUND_CTF_GRAB_EN);
                break;
            case GAMEMSG_GAME_PAUSED:
                {
                    int ClientID = clamp(aParaI[0], 0, MAX_CLIENTS - 1);
                    char aLabel[64];
                    GetPlayerLabel(aLabel, sizeof(aLabel), ClientID, m_aClients[ClientID].m_aName);
                    str_format(aBuf, sizeof(aBuf), Localize("'%s' initiated a pause"), aLabel);
                    m_pChat->AddLine(aBuf);
                }
                break;
            case GAMEMSG_CTF_CAPTURE:
                m_pSounds->Enqueue(CSounds::CHN_GLOBAL, SOUND_CTF_CAPTURE);
                int ClientID = clamp(aParaI[1], 0, MAX_CLIENTS - 1);
                m_pStats->OnFlagCapture(ClientID);
                char aLabel[64];
                GetPlayerLabel(aLabel, sizeof(aLabel), ClientID, m_aClients[ClientID].m_aName);

                float Time = aParaI[2] / (float)Client()->GameTickSpeed();
                if(Time <= 60)
                {
                    if(aParaI[0])
                    {
                        str_format(aBuf, sizeof(aBuf), Localize("The blue flag was captured by '%s' (%.2f seconds)"), aLabel, Time);
                    }
                    else
                    {
                        str_format(aBuf, sizeof(aBuf), Localize("The red flag was captured by '%s' (%.2f seconds)"), aLabel, Time);
                    }
                }
                else
                {
                    if(aParaI[0])
                    {
                        str_format(aBuf, sizeof(aBuf), Localize("The blue flag was captured by '%s'"), aLabel);
                    }
                    else
                    {
                        str_format(aBuf, sizeof(aBuf), Localize("The red flag was captured by '%s'"), aLabel);
                    }
                }
                m_pChat->AddLine(aBuf);
            }
            return;
        }

        // build message
        const char *pText = "";
        if(NumParaI == 0)
        {
            pText = Localize(gs_GameMsgList[GameMsgID].m_pText);
        }

        // handle message
        switch(gs_GameMsgList[GameMsgID].m_Action)
        {
        case DO_CHAT:
            m_pChat->AddLine(pText);
            break;
        case DO_BROADCAST:
            m_pBroadcast->DoClientBroadcast(pText);
            break;
        }
    }
                
            

NETMSGTYPE_DE_CLIENTENTER

                
    if(MsgId == NETMSGTYPE_SV_CLIENTINFO && Client()->State() != IClient::STATE_DEMOPLAYBACK)
    {
        // [..]

        if(pMsg->m_Local)
        {
            // [..]
        }
        else
        {
            // [..]

            if(m_LocalClientID != -1 && !pMsg->m_Silent)
            {
                if(m_pDemoRecorder->IsRecording())
                {
                    CNetMsg_De_ClientEnter Msg;
                    Msg.m_pName = pMsg->m_pName;
                    Msg.m_ClientID = pMsg->m_ClientID;
                    Msg.m_Team = pMsg->m_Team;
                    Client()->SendPackMsg(&Msg, MSGFLAG_NOSEND|MSGFLAG_RECORD);
                }
            }
        }
    }
                
            

                
    else if(MsgId == NETMSGTYPE_DE_CLIENTENTER && Client()->State() == IClient::STATE_DEMOPLAYBACK)
    {
        CNetMsg_De_ClientEnter *pMsg = (CNetMsg_De_ClientEnter *)pRawMsg;
        DoEnterMessage(pMsg->m_pName, pMsg->m_ClientID, pMsg->m_Team);
        m_pStats->OnPlayerEnter(pMsg->m_ClientID, pMsg->m_Team);
    }
                
            

NETMSGTYPE_DE_CLIENTLEAVE

NETMSGTYPE_CL_SAY

NETMSGTYPE_CL_SETTEAM

NETMSGTYPE_CL_SETSPECTATORMODE

                
    void CSpectator::Spectate(int SpecMode, int SpectatorID)
    {
        if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
        {
            m_pClient->m_DemoSpecMode = clamp(SpecMode, 0, NUM_SPECMODES-1);
            m_pClient->m_DemoSpecID = clamp(SpectatorID, -1, MAX_CLIENTS-1);
            return;
        }

        if(m_pClient->m_Snap.m_SpecInfo.m_SpecMode == SpecMode && (SpecMode != SPEC_PLAYER || m_pClient->m_Snap.m_SpecInfo.m_SpectatorID == SpectatorID))
            return;

        CNetMsg_Cl_SetSpectatorMode Msg;
        Msg.m_SpecMode = SpecMode;
        Msg.m_SpectatorID = SpectatorID;
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
    }
                
            

NETMSGTYPE_CL_STARTINFO

                
    void CGameClient::SendStartInfo()
    {
        CNetMsg_Cl_StartInfo Msg;
        Msg.m_pName = Config()->m_PlayerName;
        Msg.m_pClan = Config()->m_PlayerClan;
        Msg.m_Country = Config()->m_PlayerCountry;
        for(int p = 0; p < NUM_SKINPARTS; p++)
        {
            Msg.m_apSkinPartNames[p] = CSkins::ms_apSkinVariables[p];
            Msg.m_aUseCustomColors[p] = *CSkins::ms_apUCCVariables[p];
            Msg.m_aSkinPartColors[p] = *CSkins::ms_apColorVariables[p];
        }
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_FLUSH);
    }
                
            

                
    void CGameClient::OnConnected()
    {
        m_Layers.Init(Kernel());
        m_Collision.Init(Layers());

        for(int i = 0; i < m_All.m_Num; i++)
        {
            m_All.m_paComponents[i]->OnMapLoad();
            m_All.m_paComponents[i]->OnReset();
        }

        m_ServerMode = SERVERMODE_PURE;

        // send the inital info
        SendStartInfo();
    }
                
            

NETMSGTYPE_CL_KILL

NETMSGTYPE_CL_READYCHANGE

                
    void CGameClient::SendReadyChange()
    {
        CNetMsg_Cl_ReadyChange Msg;
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
    }
                
            

                
    else if (MsgID == NETMSGTYPE_CL_READYCHANGE)
    {
        if(pPlayer->m_LastReadyChangeTick && pPlayer->m_LastReadyChangeTick+Server()->TickSpeed()*1 > Server()->Tick())
            return;

        pPlayer->m_LastReadyChangeTick = Server()->Tick();
        m_pController->OnPlayerReadyChange(pPlayer);
    }
                
            

NETMSGTYPE_CL_EMOTICON

                
    void CEmoticon::Emote(int Emoticon)
    {
        CNetMsg_Cl_Emoticon Msg;
        Msg.m_Emoticon = Emoticon;
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
    }
                
            

                
    else if (MsgID == NETMSGTYPE_CL_EMOTICON && !m_World.m_Paused)
    {
        CNetMsg_Cl_Emoticon *pMsg = (CNetMsg_Cl_Emoticon *)pRawMsg;

        if(Config()->m_SvSpamprotection && pPlayer->m_LastEmoteTick && pPlayer->m_LastEmoteTick+Server()->TickSpeed()*3 > Server()->Tick())
            return;

        pPlayer->m_LastEmoteTick = Server()->Tick();

        SendEmoticon(ClientID, pMsg->m_Emoticon);
    }
                
            

NETMSGTYPE_CL_VOTE

                
    void CVoting::Vote(int Choice)
    {
        CNetMsg_Cl_Vote Msg = { Choice };
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
    }
                
            

                
    else if(MsgID == NETMSGTYPE_CL_VOTE)
    {
        if(!m_VoteCloseTime)
            return;

        if(pPlayer->m_Vote == VOTE_CHOICE_PASS)
        {
            CNetMsg_Cl_Vote *pMsg = (CNetMsg_Cl_Vote *)pRawMsg;
            if(pMsg->m_Vote == VOTE_CHOICE_PASS)
                return;

            pPlayer->m_Vote = pMsg->m_Vote;
            pPlayer->m_VotePos = ++m_VotePos;
            m_VoteUpdate = true;
        }
        else if(m_VoteCreator == pPlayer->GetCID())
        {
            CNetMsg_Cl_Vote *pMsg = (CNetMsg_Cl_Vote *)pRawMsg;
            if(pMsg->m_Vote != VOTE_CHOICE_NO || m_VoteCancelTime<time_get())
                return;

            m_VoteCloseTime = -1;
        }
    }
                
            

NETMSGTYPE_CL_CALLVOTE

                
    void CVoting::Callvote(const char *pType, const char *pValue, const char *pReason, bool ForceVote)
    {
        CNetMsg_Cl_CallVote Msg = {0};
        Msg.m_Type = pType;
        Msg.m_Value = pValue;
        Msg.m_Reason = pReason;
        Msg.m_Force = ForceVote;
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);
    }
                
            

NETMSGTYPE_SV_SKINCHANGE

                
    void CGameContext::SendSkinChange(int ClientID, int TargetID)
    {
        CNetMsg_Sv_SkinChange Msg;
        Msg.m_ClientID = ClientID;
        for(int p = 0; p < NUM_SKINPARTS; p++)
        {
            Msg.m_apSkinPartNames[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aaSkinPartNames[p];
            Msg.m_aUseCustomColors[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aUseCustomColors[p];
            Msg.m_aSkinPartColors[p] = m_apPlayers[ClientID]->m_TeeInfos.m_aSkinPartColors[p];
        }
        Server()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_NORECORD, TargetID);
    }
                
            

                
    else if(MsgId == NETMSGTYPE_SV_SKINCHANGE && Client()->State() != IClient::STATE_DEMOPLAYBACK)
	{
		Client()->RecordGameMessage(false);
		CNetMsg_Sv_SkinChange *pMsg = (CNetMsg_Sv_SkinChange *)pRawMsg;

		if(!m_aClients[pMsg->m_ClientID].m_Active)
		{
			if(Config()->m_Debug)
				Console()->Print(IConsole::OUTPUT_LEVEL_ADDINFO, "client", "invalid skin info");
			return;
		}

		for(int i = 0; i < NUM_SKINPARTS; i++)
		{
			str_utf8_copy_num(m_aClients[pMsg->m_ClientID].m_aaSkinPartNames[i], pMsg->m_apSkinPartNames[i], sizeof(m_aClients[pMsg->m_ClientID].m_aaSkinPartNames[i]), MAX_SKIN_LENGTH);
			m_aClients[pMsg->m_ClientID].m_aUseCustomColors[i] = pMsg->m_aUseCustomColors[i];
			m_aClients[pMsg->m_ClientID].m_aSkinPartColors[i] = pMsg->m_aSkinPartColors[i];
		}
		m_aClients[pMsg->m_ClientID].UpdateRenderInfo(this, pMsg->m_ClientID, true);
	}
                
            

NETMSGTYPE_CL_SKINCHANGE

                
    void CGameClient::SendSkinChange()
    {
        CNetMsg_Cl_SkinChange Msg;
        for(int p = 0; p < NUM_SKINPARTS; p++)
        {
            Msg.m_apSkinPartNames[p] = CSkins::ms_apSkinVariables[p];
            Msg.m_aUseCustomColors[p] = *CSkins::ms_apUCCVariables[p];
            Msg.m_aSkinPartColors[p] = *CSkins::ms_apColorVariables[p];
        }
        Client()->SendPackMsg(&Msg, MSGFLAG_VITAL|MSGFLAG_NORECORD|MSGFLAG_FLUSH);
        m_LastSkinChangeTime = Client()->LocalTime();
    }
                
            

                
    else if(MsgID == NETMSGTYPE_CL_SKINCHANGE)
    {
        if(pPlayer->m_LastChangeInfoTick && pPlayer->m_LastChangeInfoTick+Server()->TickSpeed()*5 > Server()->Tick())
            return;

        pPlayer->m_LastChangeInfoTick = Server()->Tick();
        CNetMsg_Cl_SkinChange *pMsg = (CNetMsg_Cl_SkinChange *)pRawMsg;

        for(int p = 0; p < NUM_SKINPARTS; p++)
        {
            str_utf8_copy_num(pPlayer->m_TeeInfos.m_aaSkinPartNames[p], pMsg->m_apSkinPartNames[p], sizeof(pPlayer->m_TeeInfos.m_aaSkinPartNames[p]), MAX_SKIN_LENGTH);
            pPlayer->m_TeeInfos.m_aUseCustomColors[p] = pMsg->m_aUseCustomColors[p];
            pPlayer->m_TeeInfos.m_aSkinPartColors[p] = pMsg->m_aSkinPartColors[p];
        }

        // update all clients
        for(int i = 0; i < MAX_CLIENTS; ++i)
        {
            if(!m_apPlayers[i] || (!Server()->ClientIngame(i) && !m_apPlayers[i]->IsDummy()) || Server()->GetClientVersion(i) < MIN_SKINCHANGE_CLIENTVERSION)
                continue;

            SendSkinChange(pPlayer->GetCID(), i);
        }

        m_pController->OnPlayerInfoChange(pPlayer);
    }
                
            

NETMSGTYPE_SV_RACEFINISH

                
    else if(MsgType == NETMSGTYPE_SV_RACEFINISH && Race)
    {
        CNetMsg_Sv_RaceFinish *pMsg = (CNetMsg_Sv_RaceFinish *)pRawMsg;

        char aBuf[256];
        char aTime[32];
        char aLabel[64];

        FormatTime(aTime, sizeof(aTime), pMsg->m_Time, m_pClient->RacePrecision());
        m_pClient->GetPlayerLabel(aLabel, sizeof(aLabel), pMsg->m_ClientID, m_pClient->m_aClients[pMsg->m_ClientID].m_aName);

        str_format(aBuf, sizeof(aBuf), "%2d: %s: finished in %s", pMsg->m_ClientID, m_pClient->m_aClients[pMsg->m_ClientID].m_aName, aTime);
        Console()->Print(IConsole::OUTPUT_LEVEL_STANDARD, "race", aBuf);

        if(pMsg->m_RecordPersonal || pMsg->m_RecordServer)
        {
            if(pMsg->m_RecordServer)
                str_format(aBuf, sizeof(aBuf), Localize("'%s' has set a new map record: %s"), aLabel, aTime);
            else // m_RecordPersonal
                str_format(aBuf, sizeof(aBuf), Localize("'%s' has set a new personal record: %s"), aLabel, aTime);

            if(pMsg->m_Diff < 0)
            {
                char aImprovement[64];
                char aDiff[32];
                FormatTimeDiff(aDiff, sizeof(aDiff), absolute(pMsg->m_Diff), m_pClient->RacePrecision(), false);
                str_format(aImprovement, sizeof(aImprovement), Localize(" (%s seconds faster)"), aDiff);
                str_append(aBuf, aImprovement, sizeof(aBuf));
            }

            m_pClient->m_pChat->AddLine(aBuf);
        }

        if(m_pClient->m_Snap.m_pGameDataRace && m_pClient->m_Snap.m_pGameDataRace->m_RaceFlags&RACEFLAG_FINISHMSG_AS_CHAT)
        {
            if(!pMsg->m_RecordPersonal && !pMsg->m_RecordServer) // don't print the time twice
            {
                str_format(aBuf, sizeof(aBuf), Localize("'%s' finished in: %s"), aLabel, aTime);
                m_pClient->m_pChat->AddLine(aBuf);
            }
        }
        else
        {
            CInfoMsg Finish;
            Finish.m_Player1ID = pMsg->m_ClientID;
            Finish.m_Player1RenderInfo = m_pClient->m_aClients[Finish.m_Player1ID].m_RenderInfo;

            Finish.m_TimeCursor.m_FontSize = 36.0f;
            if(pMsg->m_RecordServer)
                TextRender()->TextColor(1.0f, 0.5f, 0.0f, 1.0f);
            else if(pMsg->m_RecordPersonal)
                TextRender()->TextColor(0.2f, 0.6f, 1.0f, 1.0f);
            TextRender()->TextDeferred(&Finish.m_TimeCursor, aTime, -1);

            if(Config()->m_ClShowsocial)
            {
                Finish.m_Player1NameCursor.m_FontSize = 36.0f;
                TextRender()->TextDeferred(&Finish.m_Player1NameCursor, m_pClient->m_aClients[pMsg->m_ClientID].m_aName, -1);
            }

            FormatTimeDiff(aTime, sizeof(aTime), pMsg->m_Diff, m_pClient->RacePrecision());
            str_format(aBuf, sizeof(aBuf), "(%s)", aTime);
            Finish.m_DiffCursor.m_FontSize = 36.0f;
            if(pMsg->m_Diff < 0)
                TextRender()->TextColor(0.5f, 1.0f, 0.5f, 1.0f);
            else
                TextRender()->TextColor(1.0f, 0.5f, 0.5f, 1.0f);
            TextRender()->TextDeferred(&Finish.m_DiffCursor, aBuf, -1);
            TextRender()->TextColor(1.0f, 1.0f, 1.0f, 1.0f);

            Finish.m_Time = pMsg->m_Time;
            Finish.m_Diff = pMsg->m_Diff;
            Finish.m_RecordPersonal = pMsg->m_RecordPersonal;
            Finish.m_RecordServer = pMsg->m_RecordServer;

            AddInfoMsg(INFOMSG_FINISH, Finish);
        }
    }
                
            

NETMSGTYPE_SV_CHECKPOINT

                
    void CHud::OnMessage(int MsgType, void *pRawMsg)
    {
        if(MsgType == NETMSGTYPE_SV_CHECKPOINT)
        {
            CNetMsg_Sv_Checkpoint *pMsg = (CNetMsg_Sv_Checkpoint *)pRawMsg;
            m_CheckpointDiff = pMsg->m_Diff;
            m_CheckpointTime = time_get();
        }
        // [..]
    }
                
            

NETMSGTYPE_SV_COMMANDINFO

                
    void CChat::OnMessage(int MsgType, void *pRawMsg)
    {
        // [..]
        else if(MsgType == NETMSGTYPE_SV_COMMANDINFO)
        {
            CNetMsg_Sv_CommandInfo *pMsg = (CNetMsg_Sv_CommandInfo *)pRawMsg;
            if(!m_CommandManager.AddCommand(pMsg->m_Name, pMsg->m_HelpText, pMsg->m_ArgsFormat, ServerCommandCallback, this))
                dbg_msg("chat_commands", "adding server chat command: name='%s' args='%s' help='%s'", pMsg->m_Name, pMsg->m_ArgsFormat, pMsg->m_HelpText);
            else
                dbg_msg("chat_commands", "failed to add command '%s'", pMsg->m_Name);

        }
        // [..]
    }
                
            

NETMSGTYPE_SV_COMMANDINFOREMOVE

                
    void CChat::OnMessage(int MsgType, void *pRawMsg)
    {
        // [..]
        else if(MsgType == NETMSGTYPE_SV_COMMANDINFOREMOVE)
        {
            CNetMsg_Sv_CommandInfoRemove *pMsg = (CNetMsg_Sv_CommandInfoRemove *)pRawMsg;

            if(!m_CommandManager.RemoveCommand(pMsg->m_Name))
            {
                dbg_msg("chat_commands", "removed chat command: name='%s'", pMsg->m_Name);
            }
        }
    }
                
            

NETMSGTYPE_CL_COMMAND

                
    void CChat::ServerCommandCallback(IConsole::IResult *pResult, void *pContext)
    {
        CCommandManager::SCommandContext *pComContext = (CCommandManager::SCommandContext *)pContext;
        CChat *pChatData = (CChat *)pComContext->m_pContext;

        CNetMsg_Cl_Command Msg;
        Msg.m_Name = pComContext->m_pCommand;
        Msg.m_Arguments = pComContext->m_pArgs;
        pChatData->Client()->SendPackMsg(&Msg, MSGFLAG_VITAL);

        pChatData->m_pHistoryEntry = 0x0;
        pChatData->Disable();
        pChatData->m_pClient->OnRelease();
    }
                
            

                
    else if (MsgID == NETMSGTYPE_CL_COMMAND)
    {
        CNetMsg_Cl_Command *pMsg = (CNetMsg_Cl_Command*)pRawMsg;
        CommandManager()->OnCommand(pMsg->m_Name, pMsg->m_Arguments, ClientID);
    }