Changed() public static method

public static Changed ( ) : void
return void
Esempio n. 1
0
        /// <summary>
        /// CL_ParseClientdata
        /// Server information pertaining to this client only
        /// </summary>
        private static void ParseClientData(int bits)
        {
            if ((bits & Protocol.SU_VIEWHEIGHT) != 0)
            {
                cl.viewheight = Net.Reader.ReadChar();
            }
            else
            {
                cl.viewheight = Protocol.DEFAULT_VIEWHEIGHT;
            }

            if ((bits & Protocol.SU_IDEALPITCH) != 0)
            {
                cl.idealpitch = Net.Reader.ReadChar();
            }
            else
            {
                cl.idealpitch = 0;
            }

            cl.mvelocity[1] = cl.mvelocity[0];
            for (int i = 0; i < 3; i++)
            {
                if ((bits & (Protocol.SU_PUNCH1 << i)) != 0)
                {
                    Mathlib.SetComp(ref cl.punchangle, i, Net.Reader.ReadChar());
                }
                else
                {
                    Mathlib.SetComp(ref cl.punchangle, i, 0);
                }
                if ((bits & (Protocol.SU_VELOCITY1 << i)) != 0)
                {
                    Mathlib.SetComp(ref cl.mvelocity[0], i, Net.Reader.ReadChar() * 16);
                }
                else
                {
                    Mathlib.SetComp(ref cl.mvelocity[0], i, 0);
                }
            }

            // [always sent]	if (bits & SU_ITEMS)
            int i2 = Net.Reader.ReadLong();

            if (cl.items != i2)
            {   // set flash times
                Sbar.Changed();
                for (int j = 0; j < 32; j++)
                {
                    if ((i2 & (1 << j)) != 0 && (cl.items & (1 << j)) == 0)
                    {
                        cl.item_gettime[j] = (float)cl.time;
                    }
                }
                cl.items = i2;
            }

            cl.onground = (bits & Protocol.SU_ONGROUND) != 0;
            cl.inwater  = (bits & Protocol.SU_INWATER) != 0;

            if ((bits & Protocol.SU_WEAPONFRAME) != 0)
            {
                cl.stats[QStats.STAT_WEAPONFRAME] = Net.Reader.ReadByte();
            }
            else
            {
                cl.stats[QStats.STAT_WEAPONFRAME] = 0;
            }

            if ((bits & Protocol.SU_ARMOR) != 0)
            {
                i2 = Net.Reader.ReadByte();
            }
            else
            {
                i2 = 0;
            }
            if (cl.stats[QStats.STAT_ARMOR] != i2)
            {
                cl.stats[QStats.STAT_ARMOR] = i2;
                Sbar.Changed();
            }

            if ((bits & Protocol.SU_WEAPON) != 0)
            {
                i2 = Net.Reader.ReadByte();
            }
            else
            {
                i2 = 0;
            }
            if (cl.stats[QStats.STAT_WEAPON] != i2)
            {
                cl.stats[QStats.STAT_WEAPON] = i2;
                Sbar.Changed();
            }

            i2 = Net.Reader.ReadShort();
            if (cl.stats[QStats.STAT_HEALTH] != i2)
            {
                cl.stats[QStats.STAT_HEALTH] = i2;
                Sbar.Changed();
            }

            i2 = Net.Reader.ReadByte();
            if (cl.stats[QStats.STAT_AMMO] != i2)
            {
                cl.stats[QStats.STAT_AMMO] = i2;
                Sbar.Changed();
            }

            for (i2 = 0; i2 < 4; i2++)
            {
                int j = Net.Reader.ReadByte();
                if (cl.stats[QStats.STAT_SHELLS + i2] != j)
                {
                    cl.stats[QStats.STAT_SHELLS + i2] = j;
                    Sbar.Changed();
                }
            }

            i2 = Net.Reader.ReadByte();

            if (Common.GameKind == GameKind.StandardQuake)
            {
                if (cl.stats[QStats.STAT_ACTIVEWEAPON] != i2)
                {
                    cl.stats[QStats.STAT_ACTIVEWEAPON] = i2;
                    Sbar.Changed();
                }
            }
            else
            {
                if (cl.stats[QStats.STAT_ACTIVEWEAPON] != (1 << i2))
                {
                    cl.stats[QStats.STAT_ACTIVEWEAPON] = (1 << i2);
                    Sbar.Changed();
                }
            }
        }
Esempio n. 2
0
        private static float _LastMsg;                 // static float lastmsg from CL_KeepaliveMessage

        /// <summary>
        /// CL_ParseServerMessage
        /// </summary>
        private static void ParseServerMessage()
        {
            //
            // if recording demos, copy the message out
            //
            if (_ShowNet.Value == 1)
            {
                Con.Print("{0} ", Net.Message.Length);
            }
            else if (_ShowNet.Value == 2)
            {
                Con.Print("------------------\n");
            }

            cl.onground = false;        // unless the server says otherwise

            //
            // parse the message
            //
            Net.Reader.Reset();
            int i;

            while (true)
            {
                if (Net.Reader.IsBadRead)
                {
                    Host.Error("CL_ParseServerMessage: Bad server message");
                }

                int cmd = Net.Reader.ReadByte();
                if (cmd == -1)
                {
                    ShowNet("END OF MESSAGE");
                    return;     // end of message
                }

                // if the high bit of the command byte is set, it is a fast update
                if ((cmd & 128) != 0)
                {
                    ShowNet("fast update");
                    ParseUpdate(cmd & 127);
                    continue;
                }

                ShowNet(_SvcStrings[cmd]);

                // other commands
                switch (cmd)
                {
                default:
                    Host.Error("CL_ParseServerMessage: Illegible server message\n");
                    break;

                case Protocol.svc_nop:
                    break;

                case Protocol.svc_time:
                    cl.mtime[1] = cl.mtime[0];
                    cl.mtime[0] = Net.Reader.ReadFloat();
                    break;

                case Protocol.svc_clientdata:
                    i = Net.Reader.ReadShort();
                    ParseClientData(i);
                    break;

                case Protocol.svc_version:
                    i = Net.Reader.ReadLong();
                    if (i != Protocol.PROTOCOL_VERSION)
                    {
                        Host.Error("CL_ParseServerMessage: Server is protocol {0} instead of {1}\n", i, Protocol.PROTOCOL_VERSION);
                    }
                    break;

                case Protocol.svc_disconnect:
                    Host.EndGame("Server disconnected\n");
                    break;

                case Protocol.svc_print:
                    Con.Print(Net.Reader.ReadString());
                    break;

                case Protocol.svc_centerprint:
                    Scr.CenterPrint(Net.Reader.ReadString());
                    break;

                case Protocol.svc_stufftext:
                    Cbuf.AddText(Net.Reader.ReadString());
                    break;

                case Protocol.svc_damage:
                    View.ParseDamage();
                    break;

                case Protocol.svc_serverinfo:
                    ParseServerInfo();
                    Scr.vid.recalc_refdef = true;       // leave intermission full screen
                    break;

                case Protocol.svc_setangle:
                    cl.viewangles.X = Net.Reader.ReadAngle();
                    cl.viewangles.Y = Net.Reader.ReadAngle();
                    cl.viewangles.Z = Net.Reader.ReadAngle();
                    break;

                case Protocol.svc_setview:
                    cl.viewentity = Net.Reader.ReadShort();
                    break;

                case Protocol.svc_lightstyle:
                    i = Net.Reader.ReadByte();
                    if (i >= QDef.MAX_LIGHTSTYLES)
                    {
                        Sys.Error("svc_lightstyle > MAX_LIGHTSTYLES");
                    }
                    _LightStyle[i].map = Net.Reader.ReadString();
                    break;

                case Protocol.svc_sound:
                    ParseStartSoundPacket();
                    break;

                case Protocol.svc_stopsound:
                    i = Net.Reader.ReadShort();
                    Sound.StopSound(i >> 3, i & 7);
                    break;

                case Protocol.svc_updatename:
                    Sbar.Changed();
                    i = Net.Reader.ReadByte();
                    if (i >= cl.maxclients)
                    {
                        Host.Error("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD");
                    }
                    cl.scores[i].name = Net.Reader.ReadString();
                    break;

                case Protocol.svc_updatefrags:
                    Sbar.Changed();
                    i = Net.Reader.ReadByte();
                    if (i >= cl.maxclients)
                    {
                        Host.Error("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD");
                    }
                    cl.scores[i].frags = Net.Reader.ReadShort();
                    break;

                case Protocol.svc_updatecolors:
                    Sbar.Changed();
                    i = Net.Reader.ReadByte();
                    if (i >= cl.maxclients)
                    {
                        Host.Error("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD");
                    }
                    cl.scores[i].colors = Net.Reader.ReadByte();
                    NewTranslation(i);
                    break;

                case Protocol.svc_particle:
                    Render.ParseParticleEffect();
                    break;

                case Protocol.svc_spawnbaseline:
                    i = Net.Reader.ReadShort();
                    // must use CL_EntityNum() to force cl.num_entities up
                    ParseBaseline(EntityNum(i));
                    break;

                case Protocol.svc_spawnstatic:
                    ParseStatic();
                    break;

                case Protocol.svc_temp_entity:
                    ParseTempEntity();
                    break;

                case Protocol.svc_setpause:
                {
                    cl.paused = Net.Reader.ReadByte() != 0;

                    if (cl.paused)
                    {
                        CDAudio.Pause();
                    }
                    else
                    {
                        CDAudio.Resume();
                    }
                }
                break;

                case Protocol.svc_signonnum:
                    i = Net.Reader.ReadByte();
                    if (i <= cls.signon)
                    {
                        Host.Error("Received signon {0} when at {1}", i, cls.signon);
                    }
                    cls.signon = i;
                    SignonReply();
                    break;

                case Protocol.svc_killedmonster:
                    cl.stats[QStats.STAT_MONSTERS]++;
                    break;

                case Protocol.svc_foundsecret:
                    cl.stats[QStats.STAT_SECRETS]++;
                    break;

                case Protocol.svc_updatestat:
                    i = Net.Reader.ReadByte();
                    if (i < 0 || i >= QStats.MAX_CL_STATS)
                    {
                        Sys.Error("svc_updatestat: {0} is invalid", i);
                    }
                    cl.stats[i] = Net.Reader.ReadLong();
                    break;

                case Protocol.svc_spawnstaticsound:
                    ParseStaticSound();
                    break;

                case Protocol.svc_cdtrack:
                    cl.cdtrack   = Net.Reader.ReadByte();
                    cl.looptrack = Net.Reader.ReadByte();
                    if ((cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1))
                    {
                        CDAudio.Play((byte)cls.forcetrack, true);
                    }
                    else
                    {
                        CDAudio.Play((byte)cl.cdtrack, true);
                    }
                    break;

                case Protocol.svc_intermission:
                    cl.intermission       = 1;
                    cl.completed_time     = (int)cl.time;
                    Scr.vid.recalc_refdef = true;       // go to full screen
                    break;

                case Protocol.svc_finale:
                    cl.intermission       = 2;
                    cl.completed_time     = (int)cl.time;
                    Scr.vid.recalc_refdef = true;       // go to full screen
                    Scr.CenterPrint(Net.Reader.ReadString());
                    break;

                case Protocol.svc_cutscene:
                    cl.intermission       = 3;
                    cl.completed_time     = (int)cl.time;
                    Scr.vid.recalc_refdef = true;       // go to full screen
                    Scr.CenterPrint(Net.Reader.ReadString());
                    break;

                case Protocol.svc_sellscreen:
                    Cmd.ExecuteString("help", cmd_source_t.src_command);
                    break;
                }
            }
        }
Esempio n. 3
0
        // SCR_CalcRefdef
        //
        // Must be called whenever vid changes
        // Internal use only
        static void CalcRefdef()
        {
            Scr.FullUpdate        = 0; // force a background redraw
            _VidDef.recalc_refdef = false;

            // force the status bar to redraw
            Sbar.Changed();

            // bound viewsize
            if (_ViewSize.Value < 30)
            {
                Cvar.Set("viewsize", "30");
            }

            if (_ViewSize.Value > 120)
            {
                Cvar.Set("viewsize", "120");
            }

            // bound field of view
            if (_Fov.Value < 10)
            {
                Cvar.Set("fov", "10");
            }

            if (_Fov.Value > 170)
            {
                Cvar.Set("fov", "170");
            }

            // intermission is always full screen
            float size;

            if (Client.Cl.intermission > 0)
            {
                size = 120;
            }
            else
            {
                size = _ViewSize.Value;
            }

            if (size >= 120)
            {
                Sbar.Lines = 0; // no status bar at all
            }
            else if (size >= 110)
            {
                Sbar.Lines = 24; // no inventory
            }
            else
            {
                Sbar.Lines = 24 + 16 + 8;
            }

            bool full = false;

            if (_ViewSize.Value >= 100.0)
            {
                full = true;
                size = 100.0f;
            }
            else
            {
                size = _ViewSize.Value;
            }

            if (Client.Cl.intermission > 0)
            {
                full       = true;
                size       = 100;
                Sbar.Lines = 0;
            }
            size /= 100.0f;

            int h = _VidDef.height - Sbar.Lines;

            Refdef_t rdef = Render.RefDef;

            rdef.vrect.width = (int)(_VidDef.width * size);
            if (rdef.vrect.width < 96)
            {
                size             = 96.0f / rdef.vrect.width;
                rdef.vrect.width = 96;          // min for icons
            }

            rdef.vrect.height = (int)(_VidDef.height * size);
            if (rdef.vrect.height > _VidDef.height - Sbar.Lines)
            {
                rdef.vrect.height = _VidDef.height - Sbar.Lines;
            }

            if (rdef.vrect.height > _VidDef.height)
            {
                rdef.vrect.height = _VidDef.height;
            }

            rdef.vrect.x = (_VidDef.width - rdef.vrect.width) / 2;
            if (full)
            {
                rdef.vrect.y = 0;
            }
            else
            {
                rdef.vrect.y = (h - rdef.vrect.height) / 2;
            }

            rdef.fov_x = _Fov.Value;
            rdef.fov_y = CalcFov(rdef.fov_x, rdef.vrect.width, rdef.vrect.height);

            _VRect = rdef.vrect;
        }