예제 #1
0
        public static Int32 SV_FindIndex(String name, Int32 start, Int32 max, Boolean create)
        {
            Int32 i;

            if (name == null || name.Length == 0)
            {
                return(0);
            }
            for (i = 1; i < max && sv.configstrings[start + i] != null; i++)
            {
                if (0 == Lib.Strcmp(sv.configstrings[start + i], name))
                {
                    return(i);
                }
            }
            if (!create)
            {
                return(0);
            }
            if (i == max)
            {
                Com.Error(Defines.ERR_DROP, "*Index: overflow");
            }
            sv.configstrings[start + i] = name;
            if (sv.state != Defines.ss_loading)
            {
                SZ.Clear(sv.multicast);
                MSG.WriteChar(sv.multicast, Defines.svc_configstring);
                MSG.WriteShort(sv.multicast, start + i);
                MSG.WriteString(sv.multicast, name);
                SV_SEND.SV_Multicast(Globals.vec3_origin, Defines.MULTICAST_ALL_R);
            }

            return(i);
        }
예제 #2
0
        /**
         *  PF_Configstring
         */
        public static void PF_Configstring(int index, string val)
        {
            if (index < 0 || index >= Defines.MAX_CONFIGSTRINGS)
            {
                Com.Error(Defines.ERR_DROP, "configstring: bad index " + index + "\n");
            }

            if (val == null)
            {
                val = "";
            }

            // change the string in sv
            SV_INIT.sv.configstrings[index] = val;

            if (SV_INIT.sv.state != Defines.ss_loading)
            {
                // send the update to
                // everyone
                SZ.Clear(SV_INIT.sv.multicast);
                MSG.WriteChar(SV_INIT.sv.multicast, Defines.svc_configstring);
                MSG.WriteShort(SV_INIT.sv.multicast, index);
                MSG.WriteString(SV_INIT.sv.multicast, val);

                SV_SEND.SV_Multicast(Globals.vec3_origin, Defines.MULTICAST_ALL_R);
            }
        }
예제 #3
0
        /**
         * SV_FindIndex.
         */
        public static int SV_FindIndex(string name, int start, int max, bool create)
        {
            int i;

            if (name == null || name.Length == 0)
            {
                return(0);
            }

            for (i = 1; i < max && SV_INIT.sv.configstrings[start + i] != null; i++)
            {
                if (0 == Lib.strcmp(SV_INIT.sv.configstrings[start + i], name))
                {
                    return(i);
                }
            }

            if (!create)
            {
                return(0);
            }

            if (i == max)
            {
                Com.Error(Defines.ERR_DROP, "*Index: overflow");
            }

            SV_INIT.sv.configstrings[start + i] = name;

            if (SV_INIT.sv.state != Defines.ss_loading)
            {
                // send the update to everyone
                SZ.Clear(SV_INIT.sv.multicast);
                MSG.WriteChar(SV_INIT.sv.multicast, Defines.svc_configstring);
                MSG.WriteShort(SV_INIT.sv.multicast, start + i);
                MSG.WriteString(SV_INIT.sv.multicast, name);
                SV_SEND.SV_Multicast(Globals.vec3_origin, Defines.MULTICAST_ALL_R);
            }

            return(i);
        }
예제 #4
0
 public static void PF_WriteChar(int c)
 {
     MSG.WriteChar(SV_INIT.sv.multicast, c);
 }
예제 #5
0
        static void SV_WritePlayerstateToClient(client_frame_t from, client_frame_t to, sizebuf_t msg)
        {
            player_state_t ps, ops;
            player_state_t dummy;

            ps = to.ps;
            if (from == null)
            {
                dummy = new player_state_t();
                ops   = dummy;
            }
            else
            {
                ops = from.ps;
            }

            var pflags = 0;

            if (ps.pmove.pm_type != ops.pmove.pm_type)
            {
                pflags |= Defines.PS_M_TYPE;
            }
            if (ps.pmove.origin[0] != ops.pmove.origin[0] || ps.pmove.origin[1] != ops.pmove.origin[1] || ps.pmove.origin[2] != ops.pmove.origin[2])
            {
                pflags |= Defines.PS_M_ORIGIN;
            }
            if (ps.pmove.velocity[0] != ops.pmove.velocity[0] || ps.pmove.velocity[1] != ops.pmove.velocity[1] || ps.pmove.velocity[2] != ops.pmove.velocity[2])
            {
                pflags |= Defines.PS_M_VELOCITY;
            }
            if (ps.pmove.pm_time != ops.pmove.pm_time)
            {
                pflags |= Defines.PS_M_TIME;
            }
            if (ps.pmove.pm_flags != ops.pmove.pm_flags)
            {
                pflags |= Defines.PS_M_FLAGS;
            }
            if (ps.pmove.gravity != ops.pmove.gravity)
            {
                pflags |= Defines.PS_M_GRAVITY;
            }
            if (ps.pmove.delta_angles[0] != ops.pmove.delta_angles[0] || ps.pmove.delta_angles[1] != ops.pmove.delta_angles[1] || ps.pmove.delta_angles[2] != ops.pmove.delta_angles[2])
            {
                pflags |= Defines.PS_M_DELTA_ANGLES;
            }
            if (ps.viewoffset[0] != ops.viewoffset[0] || ps.viewoffset[1] != ops.viewoffset[1] || ps.viewoffset[2] != ops.viewoffset[2])
            {
                pflags |= Defines.PS_VIEWOFFSET;
            }
            if (ps.viewangles[0] != ops.viewangles[0] || ps.viewangles[1] != ops.viewangles[1] || ps.viewangles[2] != ops.viewangles[2])
            {
                pflags |= Defines.PS_VIEWANGLES;
            }
            if (ps.kick_angles[0] != ops.kick_angles[0] || ps.kick_angles[1] != ops.kick_angles[1] || ps.kick_angles[2] != ops.kick_angles[2])
            {
                pflags |= Defines.PS_KICKANGLES;
            }
            if (ps.blend[0] != ops.blend[0] || ps.blend[1] != ops.blend[1] || ps.blend[2] != ops.blend[2] || ps.blend[3] != ops.blend[3])
            {
                pflags |= Defines.PS_BLEND;
            }
            if (ps.fov != ops.fov)
            {
                pflags |= Defines.PS_FOV;
            }
            if (ps.rdflags != ops.rdflags)
            {
                pflags |= Defines.PS_RDFLAGS;
            }
            if (ps.gunframe != ops.gunframe)
            {
                pflags |= Defines.PS_WEAPONFRAME;
            }
            pflags |= Defines.PS_WEAPONINDEX;
            MSG.WriteByte(msg, Defines.svc_playerinfo);
            MSG.WriteShort(msg, pflags);
            if ((pflags & Defines.PS_M_TYPE) != 0)
            {
                MSG.WriteByte(msg, ps.pmove.pm_type);
            }
            if ((pflags & Defines.PS_M_ORIGIN) != 0)
            {
                MSG.WriteShort(msg, ps.pmove.origin[0]);
                MSG.WriteShort(msg, ps.pmove.origin[1]);
                MSG.WriteShort(msg, ps.pmove.origin[2]);
            }

            if ((pflags & Defines.PS_M_VELOCITY) != 0)
            {
                MSG.WriteShort(msg, ps.pmove.velocity[0]);
                MSG.WriteShort(msg, ps.pmove.velocity[1]);
                MSG.WriteShort(msg, ps.pmove.velocity[2]);
            }

            if ((pflags & Defines.PS_M_TIME) != 0)
            {
                MSG.WriteByte(msg, ps.pmove.pm_time);
            }
            if ((pflags & Defines.PS_M_FLAGS) != 0)
            {
                MSG.WriteByte(msg, ps.pmove.pm_flags);
            }
            if ((pflags & Defines.PS_M_GRAVITY) != 0)
            {
                MSG.WriteShort(msg, ps.pmove.gravity);
            }
            if ((pflags & Defines.PS_M_DELTA_ANGLES) != 0)
            {
                MSG.WriteShort(msg, ps.pmove.delta_angles[0]);
                MSG.WriteShort(msg, ps.pmove.delta_angles[1]);
                MSG.WriteShort(msg, ps.pmove.delta_angles[2]);
            }

            if ((pflags & Defines.PS_VIEWOFFSET) != 0)
            {
                MSG.WriteChar(msg, ps.viewoffset[0] * 4);
                MSG.WriteChar(msg, ps.viewoffset[1] * 4);
                MSG.WriteChar(msg, ps.viewoffset[2] * 4);
            }

            if ((pflags & Defines.PS_VIEWANGLES) != 0)
            {
                MSG.WriteAngle16(msg, ps.viewangles[0]);
                MSG.WriteAngle16(msg, ps.viewangles[1]);
                MSG.WriteAngle16(msg, ps.viewangles[2]);
            }

            if ((pflags & Defines.PS_KICKANGLES) != 0)
            {
                MSG.WriteChar(msg, ps.kick_angles[0] * 4);
                MSG.WriteChar(msg, ps.kick_angles[1] * 4);
                MSG.WriteChar(msg, ps.kick_angles[2] * 4);
            }

            if ((pflags & Defines.PS_WEAPONINDEX) != 0)
            {
                MSG.WriteByte(msg, ps.gunindex);
            }

            if ((pflags & Defines.PS_WEAPONFRAME) != 0)
            {
                MSG.WriteByte(msg, ps.gunframe);
                MSG.WriteChar(msg, ps.gunoffset[0] * 4);
                MSG.WriteChar(msg, ps.gunoffset[1] * 4);
                MSG.WriteChar(msg, ps.gunoffset[2] * 4);
                MSG.WriteChar(msg, ps.gunangles[0] * 4);
                MSG.WriteChar(msg, ps.gunangles[1] * 4);
                MSG.WriteChar(msg, ps.gunangles[2] * 4);
            }

            if ((pflags & Defines.PS_BLEND) != 0)
            {
                MSG.WriteByte(msg, ps.blend[0] * 255);
                MSG.WriteByte(msg, ps.blend[1] * 255);
                MSG.WriteByte(msg, ps.blend[2] * 255);
                MSG.WriteByte(msg, ps.blend[3] * 255);
            }

            if ((pflags & Defines.PS_FOV) != 0)
            {
                MSG.WriteByte(msg, ps.fov);
            }
            if ((pflags & Defines.PS_RDFLAGS) != 0)
            {
                MSG.WriteByte(msg, ps.rdflags);
            }
            var statbits = 0;

            for (var i = 0; i < Defines.MAX_STATS; i++)
            {
                if (ps.stats[i] != ops.stats[i])
                {
                    statbits |= 1 << i;
                }
            }
            MSG.WriteLong(msg, statbits);
            for (var i = 0; i < Defines.MAX_STATS; i++)
            {
                if ((statbits & (1 << i)) != 0)
                {
                    MSG.WriteShort(msg, ps.stats[i]);
                }
            }
        }