cl_parse.h File Reference

#include "qtypes.h"
#include "cvar.h"

Include dependency graph for cl_parse.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	CL_KeepaliveMessage (qbool readmessages)
void	CL_Parse_DumpPacket (void)
void	CL_Parse_ErrorCleanUp (void)
void	CL_Parse_Init (void)
void	CL_Parse_Shutdown (void)
void	CL_ParseServerMessage (void)
void	QW_CL_StartUpload (unsigned char *data, int size)

Variables
cvar_t	qport

Function Documentation

CL_KeepaliveMessage()

void CL_KeepaliveMessage

(

qbool

readmessages

)

Definition at line 314 of file cl_parse.c.

{
    static double lastdirtytime = 0;
    static qbool recursive = false;
    double dirtytime;
    double deltatime;
    static double countdownmsg = 0;
    static double countdownupdate = 0;
    sizebuf_t old;
 
    qbool thisrecursive;
 
    thisrecursive = recursive;
    recursive = true;
 
    dirtytime = Sys_DirtyTime();
    deltatime = dirtytime - lastdirtytime;
    lastdirtytime = dirtytime;
    if (deltatime <= 0 || deltatime >= 1800.0)
        return;
 
    countdownmsg -= deltatime;
    countdownupdate -= deltatime;
 
    if(!thisrecursive)
    {
        if(cls.state != ca_dedicated)
        {
            if(countdownupdate <= 0) // check if time stepped backwards
                countdownupdate = 2;
        }
    }
 
    // no need if server is local and definitely not if this is a demo
    if (sv.active || !cls.netcon || cls.protocol == PROTOCOL_QUAKEWORLD || cls.signon >= SIGNONS)
    {
        recursive = thisrecursive;
        return;
    }
 
    if (readmessages)
    {
        // read messages from server, should just be nops
        old = cl_message;
        memcpy(olddata, cl_message.data, cl_message.cursize);
 
        NetConn_ClientFrame();
 
        cl_message = old;
        memcpy(cl_message.data, olddata, cl_message.cursize);
    }
 
    if (cls.netcon && countdownmsg <= 0) // check if time stepped backwards
    {
        sizebuf_t   msg;
        unsigned char       buf[4];
        countdownmsg = 5;
        // write out a nop
        // LadyHavoc: must use unreliable because reliable could kill the sigon message!
        Con_Print("--> client to server keepalive\n");
        memset(&msg, 0, sizeof(msg));
        msg.data = buf;
        msg.maxsize = sizeof(buf);
        MSG_WriteChar(&msg, clc_nop);
        NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000, 0, false);
    }
 
    recursive = thisrecursive;
}

References server_t::active, buf, ca_dedicated, cl_message, clc_nop, cls, Con_Print(), sizebuf_t::cursize, sizebuf_t::data, sizebuf_t::maxsize, MSG_WriteChar(), client_static_t::netcon, NetConn_ClientFrame(), NetConn_SendUnreliableMessage(), olddata, client_static_t::protocol, PROTOCOL_QUAKEWORLD, client_static_t::signon, SIGNONS, client_static_t::state, sv, and Sys_DirtyTime().

Referenced by CL_BeginDownloads(), CL_ParseServerMessage(), CL_SetupWorldModel(), loadimagepixelsbgra(), Mod_Q2BSP_LoadBrushes(), Mod_Q3BSP_Load(), Mod_Q3BSP_LoadBrushes(), Mod_ShadowMesh_AddMesh(), Mod_ShadowMesh_Begin(), Mod_ShadowMesh_Finish(), and R_LoadTextureDDSFile().

CL_Parse_DumpPacket()

void CL_Parse_DumpPacket

(

void

)

Definition at line 4308 of file cl_parse.c.

{
    if (!parsingerror)
        return;
    Con_Print("Packet dump:\n");
    SZ_HexDumpToConsole(&cl_message);
    parsingerror = false;
}

References cl_message, Con_Print(), parsingerror, and SZ_HexDumpToConsole().

Referenced by Host_Error().

CL_Parse_ErrorCleanUp()

void CL_Parse_ErrorCleanUp

(

void

)

Definition at line 4317 of file cl_parse.c.

{
    CL_StopDownload(0, 0);
    QW_CL_StopUpload_f(cmd_local);
}

References CL_StopDownload(), cmd_local, and QW_CL_StopUpload_f().

Referenced by CL_DisconnectEx(), and Host_Error().

CL_Parse_Init()

void CL_Parse_Init

(

void

)

Definition at line 4323 of file cl_parse.c.

{
    Cvar_RegisterVariable(&cl_worldmessage);
    Cvar_RegisterVariable(&cl_worldname);
    Cvar_RegisterVariable(&cl_worldnamenoextension);
    Cvar_RegisterVariable(&cl_worldbasename);
 
    Cvar_RegisterVariable(&developer_networkentities);
    Cvar_RegisterVariable(&cl_gameplayfix_soundsmovewithentities);
 
    Cvar_RegisterVariable(&cl_sound_wizardhit);
    Cvar_RegisterVariable(&cl_sound_hknighthit);
    Cvar_RegisterVariable(&cl_sound_tink1);
    Cvar_RegisterVariable(&cl_sound_ric1);
    Cvar_RegisterVariable(&cl_sound_ric2);
    Cvar_RegisterVariable(&cl_sound_ric3);
    Cvar_RegisterVariable(&cl_sound_ric_gunshot);
    Cvar_RegisterVariable(&cl_sound_r_exp3);
    Cvar_RegisterVariable(&snd_cdautopause);
 
    Cvar_RegisterVariable(&cl_joinbeforedownloadsfinish);
 
    // server extension cvars set by commands issued from the server during connect
    Cvar_RegisterVariable(&cl_serverextension_download);
 
    Cvar_RegisterVariable(&cl_nettimesyncfactor);
    Cvar_RegisterVariable(&cl_nettimesyncboundmode);
    Cvar_RegisterVariable(&cl_nettimesyncboundtolerance);
    Cvar_RegisterVariable(&cl_iplog_name);
    Cvar_RegisterVariable(&cl_readpicture_force);
 
    Cmd_AddCommand(CF_CLIENT, "nextul", QW_CL_NextUpload_f, "sends next fragment of current upload buffer (screenshot for example)");
    Cmd_AddCommand(CF_CLIENT, "stopul", QW_CL_StopUpload_f, "aborts current upload (screenshot for example)");
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "skins", QW_CL_Skins_f, "downloads missing qw skins from server");
    Cmd_AddCommand(CF_CLIENT, "changing", QW_CL_Changing_f, "sent by qw servers to tell client to wait for level change");
    Cmd_AddCommand(CF_CLIENT, "cl_begindownloads", CL_BeginDownloads_f, "used internally by darkplaces client while connecting (causes loading of models and sounds or triggers downloads for missing ones)");
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "cl_downloadbegin", CL_DownloadBegin_f, "(networking) informs client of download file information, client replies with sv_startsoundload to begin the transfer");
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "stopdownload", CL_StopDownload_f, "terminates a download");
    Cmd_AddCommand(CF_CLIENT | CF_CLIENT_FROM_SERVER, "cl_downloadfinished", CL_DownloadFinished_f, "signals that a download has finished and provides the client with file size and crc to check its integrity");
    Cmd_AddCommand(CF_CLIENT, "iplog_list", CL_IPLog_List_f, "lists names of players whose IP address begins with the supplied text (example: iplog_list 123.456.789)");
}

References CF_CLIENT, CF_CLIENT_FROM_SERVER, CL_BeginDownloads_f(), CL_DownloadBegin_f(), CL_DownloadFinished_f(), cl_gameplayfix_soundsmovewithentities, CL_IPLog_List_f(), cl_iplog_name, cl_joinbeforedownloadsfinish, cl_nettimesyncboundmode, cl_nettimesyncboundtolerance, cl_nettimesyncfactor, cl_readpicture_force, cl_serverextension_download, cl_sound_hknighthit, cl_sound_r_exp3, cl_sound_ric1, cl_sound_ric2, cl_sound_ric3, cl_sound_ric_gunshot, cl_sound_tink1, cl_sound_wizardhit, CL_StopDownload_f(), cl_worldbasename, cl_worldmessage, cl_worldname, cl_worldnamenoextension, Cmd_AddCommand(), Cvar_RegisterVariable(), developer_networkentities, QW_CL_Changing_f(), QW_CL_NextUpload_f(), QW_CL_Skins_f(), QW_CL_StopUpload_f(), and snd_cdautopause.

Referenced by CL_Init().

CL_Parse_Shutdown()

void CL_Parse_Shutdown

(

void

)

Definition at line 4365 of file cl_parse.c.

{
}

Referenced by CL_Shutdown().

CL_ParseServerMessage()

void CL_ParseServerMessage

(

void

)

Definition at line 3435 of file cl_parse.c.

{
    int         cmd;
    int         i;
    protocolversion_t protocol;
    unsigned char       cmdlog[32];
    const char      *cmdlogname[32], *temp;
    int         cmdindex, cmdcount = 0;
    qbool   qwplayerupdatereceived;
    qbool   strip_pqc;
    char vabuf[1024];
    size_t cl_readstring_len;
 
    // LadyHavoc: moved demo message writing from before the packet parse to
    // after the packet parse so that CL_Stop_f can be called by cl_autodemo
    // code in CL_ParseServerinfo
    //if (cls.demorecording)
    //  CL_WriteDemoMessage (&cl_message);
 
    cl.last_received_message = host.realtime;
 
    CL_KeepaliveMessage(false);
 
//
// if recording demos, copy the message out
//
    if (cl_shownet.integer == 1)
        Con_Printf("%f %i\n", host.realtime, cl_message.cursize);
    else if (cl_shownet.integer == 2)
        Con_Print("------------------\n");
 
//
// parse the message
//
    //MSG_BeginReading ();
 
    parsingerror = true;
 
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
    {
        CL_NetworkTimeReceived(host.realtime); // qw has no clock
 
        // kill all qw nails
        cl.qw_num_nails = 0;
 
        // fade weapon view kick
        cl.qw_weaponkick = min(cl.qw_weaponkick + 10 * bound(0, cl.time - cl.oldtime, 0.1), 0);
 
        cls.servermovesequence = cls.netcon->qw.incoming_sequence;
 
        qwplayerupdatereceived = false;
 
        while (1)
        {
            if (cl_message.badread)
                Host_Error ("CL_ParseServerMessage: Bad QW server message");
 
            cmd = MSG_ReadByte(&cl_message);
 
            if (cmd == -1)
            {
                SHOWNET("END OF MESSAGE");
                break;      // end of message
            }
 
            cmdindex = cmdcount & 31;
            cmdcount++;
            cmdlog[cmdindex] = cmd;
 
            SHOWNET(qw_svc_strings[cmd]);
            cmdlogname[cmdindex] = qw_svc_strings[cmd];
            if (!cmdlogname[cmdindex])
            {
                // LadyHavoc: fix for bizarre problem in MSVC that I do not understand (if I assign the string pointer directly it ends up storing a NULL pointer)
                const char *d = "<unknown>";
                cmdlogname[cmdindex] = d;
            }
 
            // other commands
            switch (cmd)
            {
            default:
                {
                    char description[32*64], logtemp[64];
                    int count;
                    dp_strlcpy(description, "packet dump: ", sizeof(description));
                    i = cmdcount - 32;
                    if (i < 0)
                        i = 0;
                    count = cmdcount - i;
                    i &= 31;
                    while(count > 0)
                    {
                        dpsnprintf(logtemp, sizeof(logtemp), "%3i:%s ", cmdlog[i], cmdlogname[i]);
                        dp_strlcat(description, logtemp, sizeof(description));
                        count--;
                        i++;
                        i &= 31;
                    }
                    description[strlen(description)-1] = '\n'; // replace the last space with a newline
                    Con_Print(description);
                    Host_Error("CL_ParseServerMessage: Illegible server message");
                }
                break;
 
            case qw_svc_nop:
                //Con_Printf("qw_svc_nop\n");
                break;
 
            case qw_svc_disconnect:
                if (cls.demonum != -1)
                    CL_NextDemo();
                else
                    CL_DisconnectEx(true, "Server disconnected");
                break;
 
            case qw_svc_print:
                i = MSG_ReadByte(&cl_message);
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                temp = cl_readstring;
                if (CL_ExaminePrintString(temp)) // look for anything interesting like player IP addresses or ping reports
                {
                    if (i == 3) // chat
                    {
                        cl_readstring_len = dpsnprintf(vabuf, sizeof(vabuf), "\1%s", temp);
                        CSQC_AddPrintText(vabuf, cl_readstring_len);    //[515]: csqc
                    }
                    else
                        CSQC_AddPrintText(temp, cl_readstring_len);
                }
                break;
 
            case qw_svc_centerprint:
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                CL_VM_Parse_CenterPrint(cl_readstring, cl_readstring_len);  //[515]: csqc
                break;
 
            case qw_svc_stufftext:
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                CL_VM_Parse_StuffCmd(cl_readstring, cl_readstring_len); //[515]: csqc
                break;
 
            case qw_svc_damage:
                // svc_damage protocol is identical to nq
                V_ParseDamage ();
                break;
 
            case qw_svc_serverdata:
                //Cbuf_Execute(); // make sure any stuffed commands are done
                CL_ParseServerInfo();
                break;
 
            case qw_svc_setangle:
                for (i=0 ; i<3 ; i++)
                    cl.viewangles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                if (!cls.demoplayback)
                {
                    cl.fixangle[0] = true;
                    VectorCopy(cl.viewangles, cl.mviewangles[0]);
                    // disable interpolation if this is new
                    if (!cl.fixangle[1])
                        VectorCopy(cl.viewangles, cl.mviewangles[1]);
                }
                break;
 
            case qw_svc_lightstyle:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.max_lightstyle)
                {
                    Con_Printf ("svc_lightstyle >= MAX_LIGHTSTYLES");
                    break;
                }
                dp_strlcpy (cl.lightstyle[i].map,  MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.lightstyle[i].map));
                cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
                cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
                break;
 
            case qw_svc_sound:
                CL_ParseStartSoundPacket(false);
                break;
 
            case qw_svc_stopsound:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                S_StopSound(i>>3, i&7);
                break;
 
            case qw_svc_updatefrags:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
                cl.scores[i].frags = (signed short) MSG_ReadShort(&cl_message);
                break;
 
            case qw_svc_updateping:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error("CL_ParseServerMessage: svc_updateping >= cl.maxclients");
                cl.scores[i].qw_ping = MSG_ReadShort(&cl_message);
                break;
 
            case qw_svc_updatepl:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error("CL_ParseServerMessage: svc_updatepl >= cl.maxclients");
                cl.scores[i].qw_packetloss = MSG_ReadByte(&cl_message);
                break;
 
            case qw_svc_updateentertime:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error("CL_ParseServerMessage: svc_updateentertime >= cl.maxclients");
                // seconds ago
                cl.scores[i].qw_entertime = cl.time - MSG_ReadFloat(&cl_message);
                break;
 
            case qw_svc_spawnbaseline:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                if (i < 0 || i >= MAX_EDICTS)
                    Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
                if (i >= cl.max_entities)
                    CL_ExpandEntities(i);
                CL_ParseBaseline(cl.entities + i, false);
                break;
            case qw_svc_spawnstatic:
                CL_ParseStatic(false);
                break;
            case qw_svc_temp_entity:
                if(!CL_VM_Parse_TempEntity())
                    CL_ParseTempEntity ();
                break;
 
            case qw_svc_killedmonster:
                cl.stats[STAT_MONSTERS]++;
                break;
 
            case qw_svc_foundsecret:
                cl.stats[STAT_SECRETS]++;
                break;
 
            case qw_svc_updatestat:
                i = MSG_ReadByte(&cl_message);
                if (i < 0 || i >= MAX_CL_STATS)
                    Host_Error ("svc_updatestat: %i is invalid", i);
                cl.stats[i] = MSG_ReadByte(&cl_message);
                break;
 
            case qw_svc_updatestatlong:
                i = MSG_ReadByte(&cl_message);
                if (i < 0 || i >= MAX_CL_STATS)
                    Host_Error ("svc_updatestatlong: %i is invalid", i);
                cl.stats[i] = MSG_ReadLong(&cl_message);
                break;
 
            case qw_svc_spawnstaticsound:
                CL_ParseStaticSound (false);
                break;
 
            case qw_svc_cdtrack:
                cl.cdtrack = cl.looptrack = MSG_ReadByte(&cl_message);
                if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
                    CDAudio_Play ((unsigned char)cls.forcetrack, true);
                else
                    CDAudio_Play ((unsigned char)cl.cdtrack, true);
                break;
 
            case qw_svc_intermission:
                if(!cl.intermission)
                    cl.completed_time = cl.time;
                cl.intermission = 1;
                MSG_ReadVector(&cl_message, cl.qw_intermission_origin, cls.protocol);
                for (i = 0;i < 3;i++)
                    cl.qw_intermission_angles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                break;
 
            case qw_svc_finale:
                if(!cl.intermission)
                    cl.completed_time = cl.time;
                cl.intermission = 2;
                SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                break;
 
            case qw_svc_sellscreen:
                Cmd_ExecuteString(cmd_local, "help", 4, src_local, true);
                break;
 
            case qw_svc_smallkick:
                cl.qw_weaponkick = -2;
                break;
            case qw_svc_bigkick:
                cl.qw_weaponkick = -4;
                break;
 
            case qw_svc_muzzleflash:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                // NOTE: in QW this only worked on clients
                if (i < 0 || i >= MAX_EDICTS)
                    Host_Error("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
                if (i >= cl.max_entities)
                    CL_ExpandEntities(i);
                cl.entities[i].persistent.muzzleflash = 1.0f;
                break;
 
            case qw_svc_updateuserinfo:
                QW_CL_UpdateUserInfo();
                break;
 
            case qw_svc_setinfo:
                QW_CL_SetInfo();
                break;
 
            case qw_svc_serverinfo:
                QW_CL_ServerInfo();
                break;
 
            case qw_svc_download:
                QW_CL_ParseDownload();
                break;
 
            case qw_svc_playerinfo:
                // slightly kill qw player entities now that we know there is
                // an update of player entities this frame...
                if (!qwplayerupdatereceived)
                {
                    qwplayerupdatereceived = true;
                    for (i = 1;i < cl.maxclients;i++)
                        cl.entities_active[i] = false;
                }
                EntityStateQW_ReadPlayerUpdate();
                break;
 
            case qw_svc_nails:
                QW_CL_ParseNails();
                break;
 
            case qw_svc_chokecount:
                (void) MSG_ReadByte(&cl_message);
                // FIXME: apply to netgraph
                //for (j = 0;j < i;j++)
                //  cl.frames[(cls.netcon->qw.incoming_acknowledged-1-j)&QW_UPDATE_MASK].receivedtime = -2;
                break;
 
            case qw_svc_modellist:
                QW_CL_ParseModelList();
                break;
 
            case qw_svc_soundlist:
                QW_CL_ParseSoundList();
                break;
 
            case qw_svc_packetentities:
                EntityFrameQW_CL_ReadFrame(false);
                // first update is the final signon stage
                if (cls.signon == SIGNONS - 1)
                    CL_SignonReply(SIGNONS);
                break;
 
            case qw_svc_deltapacketentities:
                EntityFrameQW_CL_ReadFrame(true);
                // first update is the final signon stage
                if (cls.signon == SIGNONS - 1)
                    CL_SignonReply(SIGNONS);
                break;
 
            case qw_svc_maxspeed:
                cl.movevars_maxspeed = MSG_ReadFloat(&cl_message);
                break;
 
            case qw_svc_entgravity:
                cl.movevars_entgravity = MSG_ReadFloat(&cl_message);
                if (!cl.movevars_entgravity)
                    cl.movevars_entgravity = 1.0f;
                break;
 
            case qw_svc_setpause:
                cl.paused = MSG_ReadByte(&cl_message) != 0;
                if (cl.paused && snd_cdautopause.integer)
                    CDAudio_Pause ();
                else if (bgmvolume.value > 0.0f)
                    CDAudio_Resume ();
                S_PauseGameSounds (cl.paused);
                break;
            }
        }
 
        if (qwplayerupdatereceived)
        {
            // fully kill any player entities that were not updated this frame
            for (i = 1;i <= cl.maxclients;i++)
                if (!cl.entities_active[i])
                    cl.entities[i].state_current.active = false;
        }
    }
    else
    {
        while (1)
        {
            if (cl_message.badread)
                Host_Error ("CL_ParseServerMessage: Bad server message");
 
            cmd = MSG_ReadByte(&cl_message);
 
            if (cmd == -1)
            {
//              R_TimeReport("END OF MESSAGE");
                SHOWNET("END OF MESSAGE");
                break;      // end of message
            }
 
            cmdindex = cmdcount & 31;
            cmdcount++;
            cmdlog[cmdindex] = cmd;
 
            // if the high bit of the command byte is set, it is a fast update
            if (cmd & 128)
            {
                // LadyHavoc: fix for bizarre problem in MSVC that I do not understand (if I assign the string pointer directly it ends up storing a NULL pointer)
                temp = "entity";
                cmdlogname[cmdindex] = temp;
                SHOWNET("fast update");
                if (cls.signon == SIGNONS - 1)
                    // first update is the final signon stage
                    CL_SignonReply(SIGNONS);
                EntityFrameQuake_ReadEntity (cmd&127);
                continue;
            }
 
            SHOWNET(svc_strings[cmd]);
            cmdlogname[cmdindex] = svc_strings[cmd];
            if (!cmdlogname[cmdindex])
            {
                // LadyHavoc: fix for bizarre problem in MSVC that I do not understand (if I assign the string pointer directly it ends up storing a NULL pointer)
                const char *d = "<unknown>";
                cmdlogname[cmdindex] = d;
            }
 
            // other commands
            switch (cmd)
            {
            default:
                {
                    char description[32*64], tempdesc[64];
                    int count;
                    dp_strlcpy (description, "packet dump: ", sizeof(description));
                    i = cmdcount - 32;
                    if (i < 0)
                        i = 0;
                    count = cmdcount - i;
                    i &= 31;
                    while(count > 0)
                    {
                        dpsnprintf (tempdesc, sizeof (tempdesc), "%3i:%s ", cmdlog[i], cmdlogname[i]);
                        dp_strlcat (description, tempdesc, sizeof (description));
                        count--;
                        i++;
                        i &= 31;
                    }
                    description[strlen(description)-1] = '\n'; // replace the last space with a newline
                    Con_Print(description);
                    Host_Error ("CL_ParseServerMessage: Illegible server message");
                }
                break;
 
            case svc_nop:
                if (cls.signon < SIGNONS)
                    Con_Print("<-- server to client keepalive\n");
                break;
 
            case svc_time:
                CL_NetworkTimeReceived(MSG_ReadFloat(&cl_message));
                break;
 
            case svc_clientdata:
                CL_ParseClientdata();
                break;
 
            case svc_version:
                i = MSG_ReadLong(&cl_message);
                protocol = Protocol_EnumForNumber(i);
                if (protocol == PROTOCOL_UNKNOWN)
                    Host_Error("CL_ParseServerMessage: Server is unrecognized protocol number (%i)", i);
                // hack for unmarked Nehahra movie demos which had a custom protocol
                if (protocol == PROTOCOL_QUAKEDP && cls.demoplayback && gamemode == GAME_NEHAHRA)
                    protocol = PROTOCOL_NEHAHRAMOVIE;
                cls.protocol = protocol;
                break;
 
            case svc_disconnect:
                if (cls.demonum != -1)
                    CL_NextDemo();
                else
                    CL_DisconnectEx(true, cls.protocol == PROTOCOL_DARKPLACES8 ? MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)) : "Server disconnected");
                break;
 
            case svc_print:
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                temp = cl_readstring;
                if (CL_ExaminePrintString(temp)) // look for anything interesting like player IP addresses or ping reports
                    CSQC_AddPrintText(temp, cl_readstring_len); //[515]: csqc
                break;
 
            case svc_centerprint:
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                CL_VM_Parse_CenterPrint(cl_readstring, cl_readstring_len);  //[515]: csqc
                break;
 
            case svc_stufftext:
                cl_readstring_len = MSG_ReadString_len(&cl_message, cl_readstring, sizeof(cl_readstring));
                temp = cl_readstring;
                /* if(utf8_enable.integer)
                {
                    strip_pqc = true;
                    // we can safely strip and even
                    // interpret these in utf8 mode
                }
                else */ switch(cls.protocol)
                {
                    case PROTOCOL_QUAKE:
                    case PROTOCOL_QUAKEDP:
                        // maybe add other protocols if
                        // so desired, but not DP7
                        strip_pqc = true;
                        break;
                    case PROTOCOL_DARKPLACES7:
                    default:
                        // ProQuake does not support
                        // these protocols
                        strip_pqc = false;
                        break;
                }
                if(strip_pqc)
                {
                    // skip over ProQuake messages,
                    // TODO actually interpret them
                    // (they are sbar team score
                    // updates), see proquake cl_parse.c
                    if(*temp == 0x01)
                    {
                        ++temp;
                        --cl_readstring_len;
                        while(*temp >= 0x01 && *temp <= 0x1F)
                        {
                            ++temp;
                            --cl_readstring_len;
                        }
                    }
                }
                CL_VM_Parse_StuffCmd(temp, cl_readstring_len);  //[515]: csqc
                break;
 
            case svc_damage:
                V_ParseDamage ();
                break;
 
            case svc_serverinfo:
                CL_ParseServerInfo ();
                break;
 
            case svc_setangle:
                for (i=0 ; i<3 ; i++)
                    cl.viewangles[i] = MSG_ReadAngle(&cl_message, cls.protocol);
                if (!cls.demoplayback)
                {
                    cl.fixangle[0] = true;
                    VectorCopy(cl.viewangles, cl.mviewangles[0]);
                    // disable interpolation if this is new
                    if (!cl.fixangle[1])
                        VectorCopy(cl.viewangles, cl.mviewangles[1]);
                }
                break;
 
            case svc_setview:
                cl.viewentity = (unsigned short)MSG_ReadShort(&cl_message);
                if (cl.viewentity >= MAX_EDICTS)
                    Host_Error("svc_setview >= MAX_EDICTS");
                if (cl.viewentity >= cl.max_entities)
                    CL_ExpandEntities(cl.viewentity);
                // LadyHavoc: assume first setview recieved is the real player entity
                if (!cl.realplayerentity)
                    cl.realplayerentity = cl.viewentity;
                // update cl.playerentity to this one if it is a valid player
                if (cl.viewentity >= 1 && cl.viewentity <= cl.maxclients)
                    cl.playerentity = cl.viewentity;
                break;
 
            case svc_lightstyle:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.max_lightstyle)
                {
                    Con_Printf ("svc_lightstyle >= MAX_LIGHTSTYLES");
                    break;
                }
                dp_strlcpy (cl.lightstyle[i].map,  MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.lightstyle[i].map));
                cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
                cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
                break;
 
            case svc_sound:
                CL_ParseStartSoundPacket(cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 ? true : false);
                break;
 
            case svc_precache:
                if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
                {
                    // was svc_sound2 in protocols 1, 2, 3, removed in 4, 5, changed to svc_precache in 6
                    CL_ParseStartSoundPacket(true);
                }
                else
                {
                    char *s;
                    i = (unsigned short)MSG_ReadShort(&cl_message);
                    s = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                    if (i < 32768)
                    {
                        if (i >= 1 && i < MAX_MODELS)
                        {
                            model_t *model = Mod_ForName(s, false, false, s[0] == '*' ? cl.model_name[1] : NULL);
                            if (!model)
                                Con_DPrintf("svc_precache: Mod_ForName(\"%s\") failed\n", s);
                            cl.model_precache[i] = model;
                        }
                        else
                            Con_Printf("svc_precache: index %i outside range %i...%i\n", i, 1, MAX_MODELS);
                    }
                    else
                    {
                        i -= 32768;
                        if (i >= 1 && i < MAX_SOUNDS)
                        {
                            sfx_t *sfx = S_PrecacheSound (s, true, true);
                            if (!sfx && snd_initialized.integer)
                                Con_DPrintf("svc_precache: S_PrecacheSound(\"%s\") failed\n", s);
                            cl.sound_precache[i] = sfx;
                        }
                        else
                            Con_Printf("svc_precache: index %i outside range %i...%i\n", i, 1, MAX_SOUNDS);
                    }
                }
                break;
 
            case svc_stopsound:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                S_StopSound(i>>3, i&7);
                break;
 
            case svc_updatename:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error ("CL_ParseServerMessage: svc_updatename >= cl.maxclients");
                dp_strlcpy (cl.scores[i].name, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (cl.scores[i].name));
                break;
 
            case svc_updatefrags:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error ("CL_ParseServerMessage: svc_updatefrags >= cl.maxclients");
                cl.scores[i].frags = (signed short) MSG_ReadShort(&cl_message);
                break;
 
            case svc_updatecolors:
                i = MSG_ReadByte(&cl_message);
                if (i >= cl.maxclients)
                    Host_Error ("CL_ParseServerMessage: svc_updatecolors >= cl.maxclients");
                cl.scores[i].colors = MSG_ReadByte(&cl_message);
                break;
 
            case svc_particle:
                CL_ParseParticleEffect ();
                break;
 
            case svc_effect:
                CL_ParseEffect ();
                break;
 
            case svc_effect2:
                CL_ParseEffect2 ();
                break;
 
            case svc_spawnbaseline:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                if (i < 0 || i >= MAX_EDICTS)
                    Host_Error ("CL_ParseServerMessage: svc_spawnbaseline: invalid entity number %i", i);
                if (i >= cl.max_entities)
                    CL_ExpandEntities(i);
                CL_ParseBaseline (cl.entities + i, false);
                break;
            case svc_spawnbaseline2:
                i = (unsigned short) MSG_ReadShort(&cl_message);
                if (i < 0 || i >= MAX_EDICTS)
                    Host_Error ("CL_ParseServerMessage: svc_spawnbaseline2: invalid entity number %i", i);
                if (i >= cl.max_entities)
                    CL_ExpandEntities(i);
                CL_ParseBaseline (cl.entities + i, true);
                break;
            case svc_spawnstatic:
                CL_ParseStatic (false);
                break;
            case svc_spawnstatic2:
                CL_ParseStatic (true);
                break;
            case svc_temp_entity:
                if(!CL_VM_Parse_TempEntity())
                    CL_ParseTempEntity ();
                break;
 
            case svc_setpause:
                cl.paused = MSG_ReadByte(&cl_message) != 0;
                if (cl.paused && snd_cdautopause.integer)
                    CDAudio_Pause ();
                else if (bgmvolume.value > 0.0f)
                    CDAudio_Resume ();
                S_PauseGameSounds (cl.paused);
                break;
 
            case svc_signonnum:
                i = MSG_ReadByte(&cl_message);
                // LadyHavoc: it's rude to kick off the client if they missed the
                // reconnect somehow, so allow signon 1 even if at signon 1
                if (i <= cls.signon && i != 1)
                    Host_Error ("Received signon %i when at %i", i, cls.signon);
                CL_SignonReply(i);
                break;
 
            case svc_killedmonster:
                cl.stats[STAT_MONSTERS]++;
                break;
 
            case svc_foundsecret:
                cl.stats[STAT_SECRETS]++;
                break;
 
            case svc_updatestat:
                i = MSG_ReadByte(&cl_message);
                if (i < 0 || i >= MAX_CL_STATS)
                    Host_Error ("svc_updatestat: %i is invalid", i);
                cl.stats[i] = MSG_ReadLong(&cl_message);
                break;
 
            case svc_updatestatubyte:
                i = MSG_ReadByte(&cl_message);
                if (i < 0 || i >= MAX_CL_STATS)
                    Host_Error ("svc_updatestat: %i is invalid", i);
                cl.stats[i] = MSG_ReadByte(&cl_message);
                break;
 
            case svc_spawnstaticsound:
                CL_ParseStaticSound (cls.protocol == PROTOCOL_NEHAHRABJP2 || cls.protocol == PROTOCOL_NEHAHRABJP3 ? true : false);
                break;
 
            case svc_spawnstaticsound2:
                CL_ParseStaticSound (true);
                break;
 
            case svc_cdtrack:
                cl.cdtrack = MSG_ReadByte(&cl_message);
                cl.looptrack = MSG_ReadByte(&cl_message);
                if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
                    CDAudio_Play ((unsigned char)cls.forcetrack, true);
                else
                    CDAudio_Play ((unsigned char)cl.cdtrack, true);
                break;
 
            case svc_intermission:
                if(!cl.intermission)
                    cl.completed_time = cl.time;
                cl.intermission = 1;
                CL_VM_UpdateIntermissionState(cl.intermission);
                break;
 
            case svc_finale:
                if(!cl.intermission)
                    cl.completed_time = cl.time;
                cl.intermission = 2;
                CL_VM_UpdateIntermissionState(cl.intermission);
                SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                break;
 
            case svc_cutscene:
                if(!cl.intermission)
                    cl.completed_time = cl.time;
                cl.intermission = 3;
                CL_VM_UpdateIntermissionState(cl.intermission);
                SCR_CenterPrint(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                break;
 
            case svc_sellscreen:
                Cmd_ExecuteString(cmd_local, "help", 4, src_local, true);
                break;
            case svc_hidelmp:
                if (gamemode == GAME_TENEBRAE)
                {
                    // repeating particle effect
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    (void) MSG_ReadByte(&cl_message);
                    MSG_ReadLong(&cl_message);
                    MSG_ReadLong(&cl_message);
                    MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                }
                else
                    SHOWLMP_decodehide();
                break;
            case svc_showlmp:
                if (gamemode == GAME_TENEBRAE)
                {
                    // particle effect
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    MSG_ReadCoord(&cl_message, cls.protocol);
                    (void) MSG_ReadByte(&cl_message);
                    MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
                }
                else
                    SHOWLMP_decodeshow();
                break;
            case svc_skybox:
                R_SetSkyBox(MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
                break;
            case svc_entities:
                if (cls.signon == SIGNONS - 1)
                    // first update is the final signon stage
                    CL_SignonReply(SIGNONS);
                if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
                    EntityFrame_CL_ReadFrame();
                else if (cls.protocol == PROTOCOL_DARKPLACES4)
                    EntityFrame4_CL_ReadFrame();
                else
                    EntityFrame5_CL_ReadFrame();
                break;
            case svc_csqcentities:
                CSQC_ReadEntities();
                break;
            case svc_downloaddata:
                CL_ParseDownload();
                break;
            case svc_trailparticles:
                CL_ParseTrailParticles();
                break;
            case svc_pointparticles:
                CL_ParsePointParticles();
                break;
            case svc_pointparticles1:
                CL_ParsePointParticles1();
                break;
            }
//          R_TimeReport(svc_strings[cmd]);
        }
    }
 
    if (cls.signon == SIGNONS)
        CL_UpdateItemsAndWeapon();
//  R_TimeReport("UpdateItems");
 
    EntityFrameQuake_ISeeDeadEntities();
//  R_TimeReport("ISeeDeadEntities");
 
    CL_UpdateMoveVars();
//  R_TimeReport("UpdateMoveVars");
 
    parsingerror = false;
 
    // LadyHavoc: this was at the start of the function before cl_autodemo was
    // implemented
    if (cls.demorecording)
    {
        CL_WriteDemoMessage (&cl_message);
//      R_TimeReport("WriteDemo");
    }
}

References entity_state_t::active, sizebuf_t::badread, bgmvolume, bound, CDAudio_Pause(), CDAudio_Play(), CDAudio_Resume(), client_state_t::cdtrack, cl, CL_DisconnectEx(), CL_ExaminePrintString(), CL_ExpandEntities(), CL_KeepaliveMessage(), cl_message, CL_NetworkTimeReceived(), CL_NextDemo(), CL_ParseBaseline(), CL_ParseClientdata(), CL_ParseDownload(), CL_ParseEffect(), CL_ParseEffect2(), CL_ParseParticleEffect(), CL_ParsePointParticles(), CL_ParsePointParticles1(), CL_ParseServerInfo(), CL_ParseStartSoundPacket(), CL_ParseStatic(), CL_ParseStaticSound(), CL_ParseTempEntity(), CL_ParseTrailParticles(), cl_readstring, cl_shownet, CL_SignonReply(), CL_UpdateItemsAndWeapon(), CL_UpdateMoveVars(), CL_VM_Parse_CenterPrint(), CL_VM_Parse_StuffCmd(), CL_VM_Parse_TempEntity(), CL_VM_UpdateIntermissionState(), CL_WriteDemoMessage(), cls, cmd(), Cmd_ExecuteString(), cmd_local, scoreboard_t::colors, client_state_t::completed_time, Con_DPrintf(), Con_Print(), Con_Printf(), count, CSQC_AddPrintText(), CSQC_ReadEntities(), sizebuf_t::cursize, client_static_t::demonum, client_static_t::demoplayback, client_static_t::demorecording, dp_strlcat, dp_strlcpy, dpsnprintf(), client_state_t::entities, client_state_t::entities_active, EntityFrame4_CL_ReadFrame(), EntityFrame5_CL_ReadFrame(), EntityFrame_CL_ReadFrame(), EntityFrameQuake_ISeeDeadEntities(), EntityFrameQuake_ReadEntity(), EntityFrameQW_CL_ReadFrame(), EntityStateQW_ReadPlayerUpdate(), client_state_t::fixangle, client_static_t::forcetrack, scoreboard_t::frags, GAME_NEHAHRA, GAME_TENEBRAE, gamemode, host, Host_Error(), i, netconn_t::netconn_qw_s::incoming_sequence, int(), cvar_t::integer, client_state_t::intermission, client_state_t::last_received_message, lightstyle_t::length, client_state_t::lightstyle, client_state_t::looptrack, lightstyle_t::map, MAX_CL_STATS, MAX_EDICTS, client_state_t::max_entities, client_state_t::max_lightstyle, MAX_MODELS, MAX_SOUNDS, MAX_STYLESTRING, client_state_t::maxclients, min, Mod_ForName(), model, client_state_t::model_name, client_state_t::model_precache, client_state_t::movevars_entgravity, client_state_t::movevars_maxspeed, MSG_ReadAngle(), MSG_ReadByte, MSG_ReadCoord(), MSG_ReadFloat, MSG_ReadLong, MSG_ReadShort, MSG_ReadString(), MSG_ReadString_len(), MSG_ReadVector(), entity_persistent_t::muzzleflash, client_state_t::mviewangles, scoreboard_t::name, client_static_t::netcon, NULL, client_state_t::oldtime, parsingerror, client_state_t::paused, entity_t::persistent, client_state_t::playerentity, client_static_t::protocol, PROTOCOL_DARKPLACES1, PROTOCOL_DARKPLACES2, PROTOCOL_DARKPLACES3, PROTOCOL_DARKPLACES4, PROTOCOL_DARKPLACES7, PROTOCOL_DARKPLACES8, Protocol_EnumForNumber(), PROTOCOL_NEHAHRABJP2, PROTOCOL_NEHAHRABJP3, PROTOCOL_NEHAHRAMOVIE, PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PROTOCOL_QUAKEWORLD, PROTOCOL_UNKNOWN, netconn_t::qw, QW_CL_ParseDownload(), QW_CL_ParseModelList(), QW_CL_ParseNails(), QW_CL_ParseSoundList(), QW_CL_ServerInfo(), QW_CL_SetInfo(), QW_CL_UpdateUserInfo(), scoreboard_t::qw_entertime, client_state_t::qw_intermission_angles, client_state_t::qw_intermission_origin, client_state_t::qw_num_nails, scoreboard_t::qw_packetloss, scoreboard_t::qw_ping, qw_svc_bigkick, qw_svc_cdtrack, qw_svc_centerprint, qw_svc_chokecount, qw_svc_damage, qw_svc_deltapacketentities, qw_svc_disconnect, qw_svc_download, qw_svc_entgravity, qw_svc_finale, qw_svc_foundsecret, qw_svc_intermission, qw_svc_killedmonster, qw_svc_lightstyle, qw_svc_maxspeed, qw_svc_modellist, qw_svc_muzzleflash, qw_svc_nails, qw_svc_nop, qw_svc_packetentities, qw_svc_playerinfo, qw_svc_print, qw_svc_sellscreen, qw_svc_serverdata, qw_svc_serverinfo, qw_svc_setangle, qw_svc_setinfo, qw_svc_setpause, qw_svc_smallkick, qw_svc_sound, qw_svc_soundlist, qw_svc_spawnbaseline, qw_svc_spawnstatic, qw_svc_spawnstaticsound, qw_svc_stopsound, qw_svc_strings, qw_svc_stufftext, qw_svc_temp_entity, qw_svc_updateentertime, qw_svc_updatefrags, qw_svc_updateping, qw_svc_updatepl, qw_svc_updatestat, qw_svc_updatestatlong, qw_svc_updateuserinfo, client_state_t::qw_weaponkick, R_SetSkyBox(), client_state_t::realplayerentity, host_static_t::realtime, S_PauseGameSounds(), S_PrecacheSound(), S_StopSound(), client_state_t::scores, SCR_CenterPrint(), client_static_t::servermovesequence, SHOWLMP_decodehide(), SHOWLMP_decodeshow(), SHOWNET, client_static_t::signon, SIGNONS, snd_cdautopause, snd_initialized, client_state_t::sound_precache, src_local, STAT_MONSTERS, STAT_SECRETS, entity_t::state_current, client_state_t::stats, strlen(), svc_cdtrack, svc_centerprint, svc_clientdata, svc_csqcentities, svc_cutscene, svc_damage, svc_disconnect, svc_downloaddata, svc_effect, svc_effect2, svc_entities, svc_finale, svc_foundsecret, svc_hidelmp, svc_intermission, svc_killedmonster, svc_lightstyle, svc_nop, svc_particle, svc_pointparticles, svc_pointparticles1, svc_precache, svc_print, svc_sellscreen, svc_serverinfo, svc_setangle, svc_setpause, svc_setview, svc_showlmp, svc_signonnum, svc_skybox, svc_sound, svc_spawnbaseline, svc_spawnbaseline2, svc_spawnstatic, svc_spawnstatic2, svc_spawnstaticsound, svc_spawnstaticsound2, svc_stopsound, svc_strings, svc_stufftext, svc_temp_entity, svc_time, svc_trailparticles, svc_updatecolors, svc_updatefrags, svc_updatename, svc_updatestat, svc_updatestatubyte, svc_version, client_state_t::time, V_ParseDamage(), cvar_t::value, VectorCopy, client_state_t::viewangles, client_state_t::viewentity, and void().

Referenced by CL_ReadDemoMessage(), and NetConn_ClientParsePacket().

QW_CL_StartUpload()

void QW_CL_StartUpload	(	unsigned char *	data,
		int	size )

Definition at line 942 of file cl_parse.c.

{
    // do nothing in demos or if not connected
    if (!cls.netcon)
        return;
 
    // abort existing upload if in progress
    QW_CL_StopUpload_f(cmd_local);
 
    Con_DPrintf("Starting upload of %d bytes...\n", size);
 
    cls.qw_uploaddata = (unsigned char *)Mem_Alloc(cls.permanentmempool, size);
    memcpy(cls.qw_uploaddata, data, size);
    cls.qw_uploadsize = size;
    cls.qw_uploadpos = 0;
 
    QW_CL_NextUpload_f(cmd_local);
}

Variable Documentation

qport

cvar_t qport

extern

Definition at line 90 of file cl_main.c.

{CF_CLIENT, "qport", "0", "identification key for playing on qw servers (allows you to maintain a connection to a quakeworld server even if your port changes)"};

Referenced by CL_Init(), and NetConn_ClientParsePacket().