示例#1
0
        public static void ParseConfigString( )
        {
            Int32 i = MSG.ReadShort(Globals.net_message);

            if (i < 0 || i >= Defines.MAX_CONFIGSTRINGS)
            {
                Com.Error(Defines.ERR_DROP, "configstring > MAX_CONFIGSTRINGS");
            }
            var s    = MSG.ReadString(Globals.net_message);
            var olds = Globals.cl.configstrings[i];

            Globals.cl.configstrings[i] = s;
            if (i >= Defines.CS_LIGHTS && i < Defines.CS_LIGHTS + Defines.MAX_LIGHTSTYLES)
            {
                CL_fx.SetLightstyle(i - Defines.CS_LIGHTS);
            }
            else if (i >= Defines.CS_MODELS && i < Defines.CS_MODELS + Defines.MAX_MODELS)
            {
                if (Globals.cl.refresh_prepped)
                {
                    Globals.cl.model_draw[i - Defines.CS_MODELS] = Globals.re.RegisterModel(Globals.cl.configstrings[i]);
                    if (Globals.cl.configstrings[i].StartsWith("*"))
                    {
                        Globals.cl.model_clip[i - Defines.CS_MODELS] = CM.InlineModel(Globals.cl.configstrings[i]);
                    }
                    else
                    {
                        Globals.cl.model_clip[i - Defines.CS_MODELS] = null;
                    }
                }
            }
            else if (i >= Defines.CS_SOUNDS && i < Defines.CS_SOUNDS + Defines.MAX_MODELS)
            {
                if (Globals.cl.refresh_prepped)
                {
                    Globals.cl.sound_precache[i - Defines.CS_SOUNDS] = S.RegisterSound(Globals.cl.configstrings[i]);
                }
            }
            else if (i >= Defines.CS_IMAGES && i < Defines.CS_IMAGES + Defines.MAX_MODELS)
            {
                if (Globals.cl.refresh_prepped)
                {
                    Globals.cl.image_precache[i - Defines.CS_IMAGES] = Globals.re.RegisterPic(Globals.cl.configstrings[i]);
                }
            }
            else if (i >= Defines.CS_PLAYERSKINS && i < Defines.CS_PLAYERSKINS + Defines.MAX_CLIENTS)
            {
                if (Globals.cl.refresh_prepped && !olds.Equals(s))
                {
                    ParseClientinfo(i - Defines.CS_PLAYERSKINS);
                }
            }
        }
示例#2
0
        public static void ParseServerData( )
        {
            Com.DPrintf("ParseServerData():Serverdata packet received.\\n");
            CL.ClearState();
            Globals.cls.state = Defines.ca_connected;
            var i = MSG.ReadLong(Globals.net_message);

            Globals.cls.serverProtocol = i;
            if (Globals.server_state != 0 && Defines.PROTOCOL_VERSION == 34)
            {
            }
            else if (i != Defines.PROTOCOL_VERSION)
            {
                Com.Error(Defines.ERR_DROP, "Server returned version " + i + ", not " + Defines.PROTOCOL_VERSION);
            }
            Globals.cl.servercount = MSG.ReadLong(Globals.net_message);
            Globals.cl.attractloop = MSG.ReadByte(Globals.net_message) != 0;
            var str = MSG.ReadString(Globals.net_message);

            Globals.cl.gamedir = str;
            Com.Dprintln("gamedir=" + str);
            if (str.Length > 0 && (FS.fs_gamedirvar.string_renamed == null || FS.fs_gamedirvar.string_renamed.Length == 0 || FS.fs_gamedirvar.string_renamed.Equals(str)) || (str.Length == 0 && (FS.fs_gamedirvar.string_renamed != null || FS.fs_gamedirvar.string_renamed.Length == 0)))
            {
                Cvar.Set("game", str);
            }
            Globals.cl.playernum = MSG.ReadShort(Globals.net_message);
            Com.Dprintln("numplayers=" + Globals.cl.playernum);
            str = MSG.ReadString(Globals.net_message);
            Com.Dprintln("levelname=" + str);
            if (Globals.cl.playernum == -1)
            {
                SCR.PlayCinematic(str);
            }
            else
            {
                Com.Printf("Levelname:" + str + "\\n");
                Globals.cl.refresh_prepped = false;
            }
        }
示例#3
0
        public static void ParseServerMessage( )
        {
            while (true)
            {
                if (Globals.net_message.readcount > Globals.net_message.cursize)
                {
                    Com.Error(Defines.ERR_FATAL, "CL_ParseServerMessage: Bad server message:");
                    break;
                }

                var cmd = MSG.ReadByte(Globals.net_message);
                if (cmd == -1)
                {
                    SHOWNET("END OF MESSAGE");
                    break;
                }

                if (Globals.cl_shownet.value >= 2)
                {
                    if (null == svc_strings[cmd])
                    {
                        Com.Printf(Globals.net_message.readcount - 1 + ":BAD CMD " + cmd + "\\n");
                    }
                    else
                    {
                        SHOWNET(svc_strings[cmd]);
                    }
                }

                switch (cmd)

                {
                default:
                    Com.Error(Defines.ERR_DROP, "CL_ParseServerMessage: Illegible server message\\n");
                    break;

                case Defines.svc_nop:
                    break;

                case Defines.svc_disconnect:
                    Com.Error(Defines.ERR_DISCONNECT, "Server disconnected\\n");
                    break;

                case Defines.svc_reconnect:
                    Com.Printf("Server disconnected, reconnecting\\n");
                    if (Globals.cls.download != null)
                    {
                        try
                        {
                            Globals.cls.download.Close();
                        }
                        catch (IOException e)
                        {
                        }

                        Globals.cls.download = null;
                    }

                    Globals.cls.state        = Defines.ca_connecting;
                    Globals.cls.connect_time = -99999;
                    break;

                case Defines.svc_print:
                    var i = MSG.ReadByte(Globals.net_message);
                    if (i == Defines.PRINT_CHAT)
                    {
                        S.StartLocalSound("misc/talk.wav");
                        Globals.con.ormask = 128;
                    }

                    Com.Printf(MSG.ReadString(Globals.net_message));
                    Globals.con.ormask = 0;
                    break;

                case Defines.svc_centerprint:
                    SCR.CenterPrint(MSG.ReadString(Globals.net_message));
                    break;

                case Defines.svc_stufftext:
                    var s = MSG.ReadString(Globals.net_message);
                    Com.DPrintf("stufftext: " + s + "\\n");
                    Cbuf.AddText(s);
                    break;

                case Defines.svc_serverdata:
                    Cbuf.Execute();
                    ParseServerData();
                    break;

                case Defines.svc_configstring:
                    ParseConfigString();
                    break;

                case Defines.svc_sound:
                    ParseStartSoundPacket();
                    break;

                case Defines.svc_spawnbaseline:
                    ParseBaseline();
                    break;

                case Defines.svc_temp_entity:
                    CL_tent.ParseTEnt();
                    break;

                case Defines.svc_muzzleflash:
                    CL_fx.ParseMuzzleFlash();
                    break;

                case Defines.svc_muzzleflash2:
                    CL_fx.ParseMuzzleFlash2();
                    break;

                case Defines.svc_download:
                    ParseDownload();
                    break;

                case Defines.svc_frame:
                    CL_ents.ParseFrame();
                    break;

                case Defines.svc_inventory:
                    CL_inv.ParseInventory();
                    break;

                case Defines.svc_layout:
                    Globals.cl.layout = MSG.ReadString(Globals.net_message);
                    break;

                case Defines.svc_playerinfo:
                case Defines.svc_packetentities:
                case Defines.svc_deltapacketentities:
                    Com.Error(Defines.ERR_DROP, "Out of place frame data");
                    break;
                }
            }

            CL_view.AddNetgraph();
            if (Globals.cls.demorecording && !Globals.cls.demowaiting)
            {
                CL.WriteDemoMessage();
            }
        }
示例#4
0
        /*
         * =====================================================================
         *
         * SERVER CONNECTING MESSAGES
         *
         * =====================================================================
         */

        /*
         * ================== CL_ParseServerData ==================
         */
        //checked once, was ok.
        public static void ParseServerData()
        {
            Com.DPrintf("ParseServerData():Serverdata packet received.\n");

            //
            //	   wipe the client_state_t struct
            //
            Cl.ClearState();
            Globals.cls.state = Defines.ca_connected;

            //	   parse protocol version number
            var i = MSG.ReadLong(Globals.net_message);

            Globals.cls.serverProtocol = i;

            // BIG HACK to let demos from release work with the 3.0x patch!!!
            if (Globals.server_state != 0 && Defines.PROTOCOL_VERSION == 34)
            {
            }
            else if (i != Defines.PROTOCOL_VERSION)
            {
                Com.Error(Defines.ERR_DROP, "Server returned version " + i + ", not " + Defines.PROTOCOL_VERSION);
            }

            Globals.cl.servercount = MSG.ReadLong(Globals.net_message);
            Globals.cl.attractloop = MSG.ReadByte(Globals.net_message) != 0;

            // game directory
            var str = MSG.ReadString(Globals.net_message);

            Globals.cl.gamedir = str;
            Com.dprintln("gamedir=" + str);

            // set gamedir
            if ((str.Length > 0 && (FS.fs_gamedirvar.@string == null || [email protected] == 0 || [email protected](str))) ||
                (str.Length == 0 && (FS.fs_gamedirvar.@string != null || [email protected] == 0)))
            {
                Cvar.Set("game", str);
            }

            // parse player entity number
            Globals.cl.playernum = MSG.ReadShort(Globals.net_message);
            Com.dprintln("numplayers=" + Globals.cl.playernum);

            // get the full level name
            str = MSG.ReadString(Globals.net_message);
            Com.dprintln("levelname=" + str);

            if (Globals.cl.playernum == -1)
            {
                // playing a cinematic or showing a
                // pic, not a level
                SCR.PlayCinematic(str);
            }
            else
            {
                // seperate the printfs so the server message can have a color
                //			Com.Printf(
                //				"\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
                //			Com.Printf('\02' + str + "\n");
                Com.Printf("Levelname:" + str + "\n");

                // need to prep refresh at next oportunity
                Globals.cl.refresh_prepped = false;
            }
        }
示例#5
0
        public static void SV_ExecuteClientMessage(client_t cl)
        {
            Int32     c;
            String    s;
            usercmd_t nullcmd = new usercmd_t();
            usercmd_t oldest = new usercmd_t(), oldcmd = new usercmd_t(), newcmd = new usercmd_t();
            Int32     net_drop;
            Int32     stringCmdCount;
            Int32     checksum, calculatedChecksum;
            Int32     checksumIndex;
            Boolean   move_issued;
            Int32     lastframe;

            SV_MAIN.sv_client = cl;
            SV_USER.sv_player = SV_MAIN.sv_client.edict;
            move_issued       = false;
            stringCmdCount    = 0;
            while (true)
            {
                if (Globals.net_message.readcount > Globals.net_message.cursize)
                {
                    Com.Printf("SV_ReadClientMessage: bad read:\\n");
                    Com.Printf(Lib.HexDump(Globals.net_message.data, 32, false));
                    SV_MAIN.SV_DropClient(cl);
                    return;
                }

                c = MSG.ReadByte(Globals.net_message);
                if (c == -1)
                {
                    break;
                }
                switch (c)

                {
                default:
                    Com.Printf("SV_ReadClientMessage: unknown command char\\n");
                    SV_MAIN.SV_DropClient(cl);
                    return;

                case Defines.clc_nop:
                    break;

                case Defines.clc_userinfo:
                    cl.userinfo = MSG.ReadString(Globals.net_message);
                    SV_MAIN.SV_UserinfoChanged(cl);
                    break;

                case Defines.clc_move:
                    if (move_issued)
                    {
                        return;
                    }
                    move_issued   = true;
                    checksumIndex = Globals.net_message.readcount;
                    checksum      = MSG.ReadByte(Globals.net_message);
                    lastframe     = MSG.ReadLong(Globals.net_message);
                    if (lastframe != cl.lastframe)
                    {
                        cl.lastframe = lastframe;
                        if (cl.lastframe > 0)
                        {
                            cl.frame_latency[cl.lastframe & (Defines.LATENCY_COUNTS - 1)] = SV_INIT.svs.realtime - cl.frames[cl.lastframe & Defines.UPDATE_MASK].senttime;
                        }
                    }

                    nullcmd = new usercmd_t();
                    MSG.ReadDeltaUsercmd(Globals.net_message, nullcmd, oldest);
                    MSG.ReadDeltaUsercmd(Globals.net_message, oldest, oldcmd);
                    MSG.ReadDeltaUsercmd(Globals.net_message, oldcmd, newcmd);
                    if (cl.state != Defines.cs_spawned)
                    {
                        cl.lastframe = -1;
                        break;
                    }

                    calculatedChecksum = Com.BlockSequenceCRCByte(Globals.net_message.data, checksumIndex + 1, Globals.net_message.readcount - checksumIndex - 1, cl.netchan.incoming_sequence);
                    if ((calculatedChecksum & 0xff) != checksum)
                    {
                        Com.DPrintf("Failed command checksum for " + cl.name + " (" + calculatedChecksum + " != " + checksum + ")/" + cl.netchan.incoming_sequence + "\\n");
                        return;
                    }

                    if (0 == SV_MAIN.sv_paused.value)
                    {
                        net_drop = cl.netchan.dropped;
                        if (net_drop < 20)
                        {
                            while (net_drop > 2)
                            {
                                SV_ClientThink(cl, cl.lastcmd);
                                net_drop--;
                            }

                            if (net_drop > 1)
                            {
                                SV_ClientThink(cl, oldest);
                            }
                            if (net_drop > 0)
                            {
                                SV_ClientThink(cl, oldcmd);
                            }
                        }

                        SV_ClientThink(cl, newcmd);
                    }

                    cl.lastcmd.Set(newcmd);
                    break;

                case Defines.clc_stringcmd:
                    s = MSG.ReadString(Globals.net_message);
                    if (++stringCmdCount < SV_USER.MAX_STRINGCMDS)
                    {
                        SV_ExecuteUserCommand(s);
                    }
                    if (cl.state == Defines.cs_zombie)
                    {
                        return;
                    }
                    break;
                }
            }
        }