reworked PRVM_EDICTFIELD* and PRVM_GLOBALFIELD* usage to have more

specific naming of the macros, and allow code analysis to audit the used
fields/globals for better maintenance

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@11144 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/cl_collision.c b/cl_collision.c
index 79989532a39727173a44ff71218a44b180f30ec3..0f8ab408ae2af3f1bac59fe661469fc8a878b5a0 100644 (file)
--- a/cl_collision.c
+++ b/cl_collision.c
@@ -199,7 +199,7 @@ int CL_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
 {
        if (passedict)
        {
 {
        if (passedict)
        {

-               int dphitcontentsmask = (int)PRVM_EDICTFIELDFLOAT(passedict, prog->fieldoffsets.dphitcontentsmask);
+               int dphitcontentsmask = (int)PRVM_clientedictfloat(passedict, dphitcontentsmask);

                if (dphitcontentsmask)
                        return dphitcontentsmask;
                else if (passedict->fields.client->solid == SOLID_SLIDEBOX)
                if (dphitcontentsmask)
                        return dphitcontentsmask;
                else if (passedict->fields.client->solid == SOLID_SLIDEBOX)

diff --git a/clvm_cmds.c b/clvm_cmds.c
index 87ee706a4c3376e0e7547a231736b4e495ebe240..ea5ea17042a1b4f850580627e2abc7410d9a072d 100644 (file)
--- a/clvm_cmds.c
+++ b/clvm_cmds.c
@@ -235,7 +235,7 @@ static void VM_CL_spawn (void)
 void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
 {
        VM_SetTraceGlobals(trace);
 void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
 {
        VM_SetTraceGlobals(trace);

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_networkentity) = svent;
+       PRVM_clientglobalfloat(trace_networkentity) = svent;

 }
 
 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)
 }
 
 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)


@@ -325,7 +325,7 @@ trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
        VectorCopy(tossent->fields.client->angles   , original_angles   );
        VectorCopy(tossent->fields.client->avelocity, original_avelocity);
 
        VectorCopy(tossent->fields.client->angles   , original_angles   );
        VectorCopy(tossent->fields.client->avelocity, original_avelocity);
 

-       gravity = PRVM_EDICTFIELDFLOAT(tossent, prog->fieldoffsets.gravity);
+       gravity = PRVM_clientedictfloat(tossent, gravity);

        if (!gravity)
                gravity = 1.0f;
        gravity *= cl.movevars_gravity * 0.05;
        if (!gravity)
                gravity = 1.0f;
        gravity *= cl.movevars_gravity * 0.05;


@@ -529,7 +529,7 @@ static void VM_CL_droptofloor (void)
        {
                VectorCopy (trace.endpos, ent->fields.client->origin);
                ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
        {
                VectorCopy (trace.endpos, ent->fields.client->origin);
                ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;

-               PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+               PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);

                PRVM_G_FLOAT(OFS_RETURN) = 1;
                // if support is destroyed, keep suspended (gross hack for floating items in various maps)
 //             ent->priv.server->suspendedinairflag = true;
                PRVM_G_FLOAT(OFS_RETURN) = 1;
                // if support is destroyed, keep suspended (gross hack for floating items in various maps)
 //             ent->priv.server->suspendedinairflag = true;


@@ -1276,13 +1276,13 @@ static void VM_CL_boxparticles (void)
        Vector4Set(tintmaxs, 1, 1, 1, 1);
        if(flags & 1) // read alpha
        {
        Vector4Set(tintmaxs, 1, 1, 1, 1);
        if(flags & 1) // read alpha
        {

-               tintmins[3] = PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.particles_alphamin);
-               tintmaxs[3] = PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.particles_alphamax);
+               tintmins[3] = PRVM_clientglobalfloat(particles_alphamin);
+               tintmaxs[3] = PRVM_clientglobalfloat(particles_alphamax);

        }
        if(flags & 2) // read color
        {
        }
        if(flags & 2) // read color
        {

-               VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.particles_colormin), tintmins);
-               VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.particles_colormax), tintmaxs);
+               VectorCopy(PRVM_clientglobalvector(particles_colormin), tintmins);
+               VectorCopy(PRVM_clientglobalvector(particles_colormax), tintmaxs);

        }
        if (effectnum < 0)
                return;
        }
        if (effectnum < 0)
                return;


@@ -1585,10 +1585,10 @@ static void VM_CL_makestatic (void)
                staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
                staticent->render.skinnum = (int)ent->fields.client->skin;
                staticent->render.effects = (int)ent->fields.client->effects;
                staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
                staticent->render.skinnum = (int)ent->fields.client->skin;
                staticent->render.effects = (int)ent->fields.client->effects;

-               staticent->render.alpha = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.alpha);
-               staticent->render.scale = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.scale);
-               VectorCopy(PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.colormod), staticent->render.colormod);
-               VectorCopy(PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.glowmod), staticent->render.glowmod);
+               staticent->render.alpha = PRVM_clientedictfloat(ent, alpha);
+               staticent->render.scale = PRVM_clientedictfloat(ent, scale);
+               VectorCopy(PRVM_clientedictvector(ent, colormod), staticent->render.colormod);
+               VectorCopy(PRVM_clientedictvector(ent, glowmod), staticent->render.glowmod);

 
                // sanitize values
                if (!staticent->render.alpha)
 
                // sanitize values
                if (!staticent->render.alpha)


@@ -1600,7 +1600,7 @@ static void VM_CL_makestatic (void)
                if (!VectorLength2(staticent->render.glowmod))
                        VectorSet(staticent->render.glowmod, 1, 1, 1);
 
                if (!VectorLength2(staticent->render.glowmod))
                        VectorSet(staticent->render.glowmod, 1, 1, 1);
 

-               renderflags = (int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.renderflags);
+               renderflags = (int)PRVM_clientedictfloat(ent, renderflags);

                if (renderflags & RF_USEAXIS)
                {
                        vec3_t left;
                if (renderflags & RF_USEAXIS)
                {
                        vec3_t left;


@@ -2128,8 +2128,8 @@ void VM_CL_setattachment (void)
                        Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 
                        Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 

-       PRVM_EDICTFIELDEDICT(e, prog->fieldoffsets.tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
-       PRVM_EDICTFIELDFLOAT(e, prog->fieldoffsets.tag_index) = tagindex;
+       PRVM_clientedictedict(e, tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
+       PRVM_clientedictfloat(e, tag_index) = tagindex;

 }
 
 /////////////////////////////////////////
 }
 
 /////////////////////////////////////////


@@ -2181,13 +2181,13 @@ void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatri
        float scale;
        float pitchsign = 1;
 
        float scale;
        float pitchsign = 1;
 

-       scale = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.scale);
+       scale = PRVM_clientedictfloat(ent, scale);

        if (!scale)
                scale = 1.0f;
 
        if(viewmatrix)
                *out = r_refdef.view.matrix;
        if (!scale)
                scale = 1.0f;
 
        if(viewmatrix)
                *out = r_refdef.view.matrix;

-       else if ((int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.renderflags) & RF_USEAXIS)
+       else if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_USEAXIS)

        {
                vec3_t forward;
                vec3_t left;
        {
                vec3_t forward;
                vec3_t left;


@@ -2265,10 +2265,10 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
                Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                // next iteration we process the parent entity
                Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                // next iteration we process the parent entity

-               if (PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.tag_entity))
+               if (PRVM_clientedictedict(ent, tag_entity))

                {
                {

-                       tagindex = (int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.tag_index);
-                       ent = PRVM_EDICT_NUM(PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.tag_entity));
+                       tagindex = (int)PRVM_clientedictfloat(ent, tag_index);
+                       ent = PRVM_EDICT_NUM(PRVM_clientedictedict(ent, tag_entity));

                }
                else
                        break;
                }
                else
                        break;


@@ -2276,7 +2276,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
        }
 
        // RENDER_VIEWMODEL magic
        }
 
        // RENDER_VIEWMODEL magic

-       if ((int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.renderflags) & RF_VIEWMODEL)
+       if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_VIEWMODEL)

        {
                Matrix4x4_Copy(&tagmatrix, out);
 
        {
                Matrix4x4_Copy(&tagmatrix, out);
 


@@ -2370,12 +2370,12 @@ void VM_CL_gettaginfo (void)
        CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
        Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 
        CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
        Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.gettaginfo_parent) = parentindex;
-       PRVM_GLOBALFIELDSTRING(prog->globaloffsets.gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
-       VectorCopy(trans, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_offset));
-       VectorCopy(fo, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_forward));
-       VectorScale(le, -1, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_right));
-       VectorCopy(up, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_up));
+       PRVM_clientglobalfloat(gettaginfo_parent) = parentindex;
+       PRVM_clientglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
+       VectorCopy(trans, PRVM_clientglobalvector(gettaginfo_offset));
+       VectorCopy(fo, PRVM_clientglobalvector(gettaginfo_forward));
+       VectorScale(le, -1, PRVM_clientglobalvector(gettaginfo_right));
+       VectorCopy(up, PRVM_clientglobalvector(gettaginfo_up));

 
        switch(returncode)
        {
 
        switch(returncode)
        {


@@ -2499,37 +2499,35 @@ static void VM_InitParticleSpawner (int maxthemes)
        vmpartspawner.initialized = true;
        vmpartspawner.verified = true;
        // get field addresses for fast querying (we can do 1000 calls of spawnparticle in a frame)
        vmpartspawner.initialized = true;
        vmpartspawner.verified = true;
        // get field addresses for fast querying (we can do 1000 calls of spawnparticle in a frame)

-       #define getglobal(v,s) vmpartspawner.v = &PRVM_GLOBALFIELDFLOAT(PRVM_ED_FindGlobalOffset(s))
-       #define getglobalvector(v,s) vmpartspawner.v = PRVM_GLOBALFIELDVECTOR(PRVM_ED_FindGlobalOffset(s))
-       getglobal(particle_type, "particle_type");
-       getglobal(particle_blendmode, "particle_blendmode");
-       getglobal(particle_orientation, "particle_orientation");
-       getglobalvector(particle_color1, "particle_color1");
-       getglobalvector(particle_color2, "particle_color2");
-       getglobal(particle_tex, "particle_tex");
-       getglobal(particle_size, "particle_size");
-       getglobal(particle_sizeincrease, "particle_sizeincrease");
-       getglobal(particle_alpha, "particle_alpha");
-       getglobal(particle_alphafade, "particle_alphafade");
-       getglobal(particle_time, "particle_time");
-       getglobal(particle_gravity, "particle_gravity");
-       getglobal(particle_bounce, "particle_bounce");
-       getglobal(particle_airfriction, "particle_airfriction");
-       getglobal(particle_liquidfriction, "particle_liquidfriction");
-       getglobal(particle_originjitter, "particle_originjitter");
-       getglobal(particle_velocityjitter, "particle_velocityjitter");
-       getglobal(particle_qualityreduction, "particle_qualityreduction");
-       getglobal(particle_stretch, "particle_stretch");
-       getglobalvector(particle_staincolor1, "particle_staincolor1");
-       getglobalvector(particle_staincolor2, "particle_staincolor2");
-       getglobal(particle_stainalpha, "particle_stainalpha");
-       getglobal(particle_stainsize, "particle_stainsize");
-       getglobal(particle_staintex, "particle_staintex");
-       getglobal(particle_staintex, "particle_staintex");
-       getglobal(particle_delayspawn, "particle_delayspawn");
-       getglobal(particle_delaycollision, "particle_delaycollision");
-       getglobal(particle_angle, "particle_angle");
-       getglobal(particle_spin, "particle_spin");
+       vmpartspawner.particle_type = &PRVM_clientglobalfloat(particle_type);
+       vmpartspawner.particle_blendmode = &PRVM_clientglobalfloat(particle_blendmode);
+       vmpartspawner.particle_orientation = &PRVM_clientglobalfloat(particle_orientation);
+       vmpartspawner.particle_color1 = PRVM_clientglobalvector(particle_color1);
+       vmpartspawner.particle_color2 = PRVM_clientglobalvector(particle_color2);
+       vmpartspawner.particle_tex = &PRVM_clientglobalfloat(particle_tex);
+       vmpartspawner.particle_size = &PRVM_clientglobalfloat(particle_size);
+       vmpartspawner.particle_sizeincrease = &PRVM_clientglobalfloat(particle_sizeincrease);
+       vmpartspawner.particle_alpha = &PRVM_clientglobalfloat(particle_alpha);
+       vmpartspawner.particle_alphafade = &PRVM_clientglobalfloat(particle_alphafade);
+       vmpartspawner.particle_time = &PRVM_clientglobalfloat(particle_time);
+       vmpartspawner.particle_gravity = &PRVM_clientglobalfloat(particle_gravity);
+       vmpartspawner.particle_bounce = &PRVM_clientglobalfloat(particle_bounce);
+       vmpartspawner.particle_airfriction = &PRVM_clientglobalfloat(particle_airfriction);
+       vmpartspawner.particle_liquidfriction = &PRVM_clientglobalfloat(particle_liquidfriction);
+       vmpartspawner.particle_originjitter = &PRVM_clientglobalfloat(particle_originjitter);
+       vmpartspawner.particle_velocityjitter = &PRVM_clientglobalfloat(particle_velocityjitter);
+       vmpartspawner.particle_qualityreduction = &PRVM_clientglobalfloat(particle_qualityreduction);
+       vmpartspawner.particle_stretch = &PRVM_clientglobalfloat(particle_stretch);
+       vmpartspawner.particle_staincolor1 = PRVM_clientglobalvector(particle_staincolor1);
+       vmpartspawner.particle_staincolor2 = PRVM_clientglobalvector(particle_staincolor2);
+       vmpartspawner.particle_stainalpha = &PRVM_clientglobalfloat(particle_stainalpha);
+       vmpartspawner.particle_stainsize = &PRVM_clientglobalfloat(particle_stainsize);
+       vmpartspawner.particle_staintex = &PRVM_clientglobalfloat(particle_staintex);
+       vmpartspawner.particle_staintex = &PRVM_clientglobalfloat(particle_staintex);
+       vmpartspawner.particle_delayspawn = &PRVM_clientglobalfloat(particle_delayspawn);
+       vmpartspawner.particle_delaycollision = &PRVM_clientglobalfloat(particle_delaycollision);
+       vmpartspawner.particle_angle = &PRVM_clientglobalfloat(particle_angle);
+       vmpartspawner.particle_spin = &PRVM_clientglobalfloat(particle_spin);

        #undef getglobal
        #undef getglobalvector
 }
        #undef getglobal
        #undef getglobalvector
 }


@@ -3516,7 +3514,7 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
                ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
 
        if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
                ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
 

-       PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+       PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);

 
 // the move is ok
        if (relink)
 
 // the move is ok
        if (relink)

diff --git a/csprogs.c b/csprogs.c
index ea2471e4415929d6785345c70d7ea16b8e5c2e62..7dd08c49996a44ee55c7952638e3dc5e4169378f 100644 (file)
--- a/csprogs.c
+++ b/csprogs.c
@@ -23,7 +23,7 @@ void CL_VM_PreventInformationLeaks(void)
                return;
        CSQC_BEGIN
                VM_ClearTraceGlobals();
                return;
        CSQC_BEGIN
                VM_ClearTraceGlobals();

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_networkentity) = 0;
+               PRVM_clientglobalfloat(trace_networkentity) = 0;

        CSQC_END
 }
 
        CSQC_END
 }
 


@@ -38,6 +38,146 @@ static const char *cl_required_func[] =
 
 static int cl_numrequiredfunc = sizeof(cl_required_func) / sizeof(char*);
 
 
 static int cl_numrequiredfunc = sizeof(cl_required_func) / sizeof(char*);
 

+#define CL_REQFIELDS (sizeof(cl_reqfields) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t cl_reqfields[] =
+{
+       {ev_entity, "aiment"}, // client field
+       {ev_entity, "enemy"}, // client field
+       {ev_entity, "groundentity"}, // client field
+       {ev_entity, "tag_entity"}, // client field
+       {ev_float, "alpha"}, // client field
+       {ev_float, "bouncefactor"}, // client field
+       {ev_float, "bouncestop"}, // client field
+       {ev_float, "dphitcontentsmask"}, // client field
+       {ev_float, "frame1time"}, // client field
+       {ev_float, "frame2time"}, // client field
+       {ev_float, "frame2"}, // client field
+       {ev_float, "frame3time"}, // client field
+       {ev_float, "frame3"}, // client field
+       {ev_float, "frame4time"}, // client field
+       {ev_float, "frame4"}, // client field
+       {ev_float, "frame"}, // client field
+       {ev_float, "gravity"}, // client field
+       {ev_float, "gravity"}, // client field
+       {ev_float, "ideal_yaw"}, // client field
+       {ev_float, "idealpitch"}, // client field
+       {ev_float, "jointtype"}, // client field
+       {ev_float, "lerpfrac3"}, // client field
+       {ev_float, "lerpfrac4"}, // client field
+       {ev_float, "lerpfrac"}, // client field
+       {ev_float, "mass"}, // client field
+       {ev_float, "modelindex"}, // client field
+       {ev_float, "movetype"}, // client field
+       {ev_float, "pitch_speed"}, // client field
+       {ev_float, "renderflags"}, // client field
+       {ev_float, "scale"}, // client field
+       {ev_float, "scale"}, // client field
+       {ev_float, "shadertime"}, // client field
+       {ev_float, "skeletonindex"}, // client field
+       {ev_float, "solid"}, // client field
+       {ev_float, "tag_index"}, // client field
+       {ev_float, "userwavefunc_param0"}, // client field
+       {ev_float, "userwavefunc_param1"}, // client field
+       {ev_float, "userwavefunc_param2"}, // client field
+       {ev_float, "userwavefunc_param3"}, // client field
+       {ev_float, "yaw_speed"}, // client field
+       {ev_function, "camera_transform"}, // client field
+       {ev_string, "classname"}, // client field
+       {ev_string, "message"}, // client field
+       {ev_vector, "angles"}, // client field
+       {ev_vector, "avelocity"}, // client field
+       {ev_vector, "colormod"}, // client field
+       {ev_vector, "glowmod"}, // client field
+       {ev_vector, "maxs"}, // client field
+       {ev_vector, "mins"}, // client field
+       {ev_vector, "movedir"}, // client field
+       {ev_vector, "origin"}, // client field
+       {ev_vector, "velocity"}, // client field
+};
+
+#define CL_REQGLOBALS (sizeof(cl_reqglobals) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t cl_reqglobals[] =
+{
+       {ev_entity, "self"}, // client global
+       {ev_entity, "trace_ent"}, // client global
+       {ev_float, "coop"}, // client global
+       {ev_float, "deathmatch"}, // client global
+       {ev_float, "dmg_save"}, // client global
+       {ev_float, "dmg_take"}, // client global
+       {ev_float, "drawfont"}, // client global
+       {ev_float, "gettaginfo_parent"}, // client global
+       {ev_float, "intermission"}, // client global
+       {ev_float, "particle_airfriction"}, // client global
+       {ev_float, "particle_alpha"}, // client global
+       {ev_float, "particle_alphafade"}, // client global
+       {ev_float, "particle_angle"}, // client global
+       {ev_float, "particle_blendmode"}, // client global
+       {ev_float, "particle_bounce"}, // client global
+       {ev_float, "particle_delaycollision"}, // client global
+       {ev_float, "particle_delayspawn"}, // client global
+       {ev_float, "particle_gravity"}, // client global
+       {ev_float, "particle_liquidfriction"}, // client global
+       {ev_float, "particle_orientation"}, // client global
+       {ev_float, "particle_originjitter"}, // client global
+       {ev_float, "particle_qualityreduction"}, // client global
+       {ev_float, "particle_size"}, // client global
+       {ev_float, "particle_sizeincrease"}, // client global
+       {ev_float, "particle_spin"}, // client global
+       {ev_float, "particle_stainalpha"}, // client global
+       {ev_float, "particle_stainsize"}, // client global
+       {ev_float, "particle_staintex"}, // client global
+       {ev_float, "particle_staintex"}, // client global
+       {ev_float, "particle_stretch"}, // client global
+       {ev_float, "particle_tex"}, // client global
+       {ev_float, "particle_time"}, // client global
+       {ev_float, "particle_type"}, // client global
+       {ev_float, "particle_velocityjitter"}, // client global
+       {ev_float, "particles_alphamax"}, // client global
+       {ev_float, "particles_alphamin"}, // client global
+       {ev_float, "require_spawnfunc_prefix"}, // client global
+       {ev_float, "sb_showscores"}, // client global
+       {ev_float, "serverdeltatime"}, // client global
+       {ev_float, "serverprevtime"}, // client global
+       {ev_float, "servertime"}, // client global
+       {ev_float, "trace_allsolid"}, // client global
+       {ev_float, "trace_dphitcontents"}, // client global
+       {ev_float, "trace_dphitq3surfaceflags"}, // client global
+       {ev_float, "trace_dpstartcontents"}, // client global
+       {ev_float, "trace_fraction"}, // client global
+       {ev_float, "trace_inopen"}, // client global
+       {ev_float, "trace_inwater"}, // client global
+       {ev_float, "trace_networkentity"}, // client global
+       {ev_float, "trace_plane_dist"}, // client global
+       {ev_float, "trace_startsolid"}, // client global
+       {ev_float, "transparent_offset"}, // client global
+       {ev_string, "gettaginfo_name"}, // client global
+       {ev_string, "trace_dphittexturename"}, // client global
+       {ev_vector, "dmg_origin"}, // client global
+       {ev_vector, "drawfontscale"}, // client global
+       {ev_vector, "gettaginfo_forward"}, // client global
+       {ev_vector, "gettaginfo_offset"}, // client global
+       {ev_vector, "gettaginfo_right"}, // client global
+       {ev_vector, "gettaginfo_up"}, // client global
+       {ev_vector, "particle_color1"}, // client global
+       {ev_vector, "particle_color2"}, // client global
+       {ev_vector, "particle_staincolor1"}, // client global
+       {ev_vector, "particle_staincolor2"}, // client global
+       {ev_vector, "particles_colormax"}, // client global
+       {ev_vector, "particles_colormin"}, // client global
+       {ev_vector, "pmove_inwater"}, // client global
+       {ev_vector, "pmove_onground"}, // client global
+       {ev_vector, "trace_endpos"}, // client global
+       {ev_vector, "trace_plane_normal"}, // client global
+       {ev_vector, "v_forward"}, // client global
+       {ev_vector, "v_right"}, // client global
+       {ev_vector, "v_up"}, // client global
+       {ev_vector, "view_angles"}, // client global
+       {ev_vector, "view_punchangle"}, // client global
+       {ev_vector, "view_punchvector"}, // client global
+};
+

 void CL_VM_Error (const char *format, ...) DP_FUNC_PRINTF(1);
 void CL_VM_Error (const char *format, ...)     //[515]: hope it will be never executed =)
 {
 void CL_VM_Error (const char *format, ...) DP_FUNC_PRINTF(1);
 void CL_VM_Error (const char *format, ...)     //[515]: hope it will be never executed =)
 {


@@ -63,9 +203,9 @@ void CL_VM_UpdateDmgGlobals (int dmg_take, int dmg_save, vec3_t dmg_origin)
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.dmg_take) = dmg_take;
-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.dmg_save) = dmg_save;
-               VectorCopy(dmg_origin, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.dmg_origin));
+               PRVM_clientglobalfloat(dmg_take) = dmg_take;
+               PRVM_clientglobalfloat(dmg_save) = dmg_save;
+               VectorCopy(dmg_origin, PRVM_clientglobalvector(dmg_origin));

                CSQC_END
        }
 }
                CSQC_END
        }
 }


@@ -75,9 +215,9 @@ void CSQC_UpdateNetworkTimes(double newtime, double oldtime)
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.servertime) = newtime;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.serverprevtime) = oldtime;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.serverdeltatime) = newtime - oldtime;
+       PRVM_clientglobalfloat(servertime) = newtime;
+       PRVM_clientglobalfloat(serverprevtime) = oldtime;
+       PRVM_clientglobalfloat(serverdeltatime) = newtime - oldtime;

        CSQC_END
 }
 
        CSQC_END
 }
 


@@ -101,12 +241,12 @@ static void CSQC_SetGlobals (void)
                // completely replacing it
                Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, prog->globals.client->pmove_org);
                VectorCopy(cl.movement_velocity, prog->globals.client->pmove_vel);
                // completely replacing it
                Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, prog->globals.client->pmove_org);
                VectorCopy(cl.movement_velocity, prog->globals.client->pmove_vel);

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.pmove_onground) = cl.onground;
-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.pmove_inwater) = cl.inwater;
+               PRVM_clientglobalfloat(pmove_onground) = cl.onground;
+               PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;

 
 

-               VectorCopy(cl.viewangles, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_angles));
-               VectorCopy(cl.punchangle, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_punchangle));
-               VectorCopy(cl.punchvector, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_punchvector));
+               VectorCopy(cl.viewangles, PRVM_clientglobalvector(view_angles));
+               VectorCopy(cl.punchangle, PRVM_clientglobalvector(view_punchangle));
+               VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));

                prog->globals.client->maxclients = cl.maxclients;
        CSQC_END
 }
                prog->globals.client->maxclients = cl.maxclients;
        CSQC_END
 }


@@ -172,19 +312,19 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
                        return false;
        }
 
                        return false;
        }
 

-       entrender->userwavefunc_param[0] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param0);
-       entrender->userwavefunc_param[1] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param1);
-       entrender->userwavefunc_param[2] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param2);
-       entrender->userwavefunc_param[3] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param3);
+       entrender->userwavefunc_param[0] = PRVM_clientedictfloat(ed, userwavefunc_param0);
+       entrender->userwavefunc_param[1] = PRVM_clientedictfloat(ed, userwavefunc_param1);
+       entrender->userwavefunc_param[2] = PRVM_clientedictfloat(ed, userwavefunc_param2);
+       entrender->userwavefunc_param[3] = PRVM_clientedictfloat(ed, userwavefunc_param3);

 
        entrender->model = model;
        entrender->skinnum = (int)ed->fields.client->skin;
        entrender->effects |= entrender->model->effects;
 
        entrender->model = model;
        entrender->skinnum = (int)ed->fields.client->skin;
        entrender->effects |= entrender->model->effects;

-       renderflags = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.renderflags);
-       entrender->alpha = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.alpha);
-       entrender->scale = scale = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.scale);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.colormod), entrender->colormod);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.glowmod), entrender->glowmod);
+       renderflags = (int)PRVM_clientedictfloat(ed, renderflags);
+       entrender->alpha = PRVM_clientedictfloat(ed, alpha);
+       entrender->scale = scale = PRVM_clientedictfloat(ed, scale);
+       VectorCopy(PRVM_clientedictvector(ed, colormod), entrender->colormod);
+       VectorCopy(PRVM_clientedictvector(ed, glowmod), entrender->glowmod);

        if(ed->fields.client->effects)  entrender->effects |= (int)ed->fields.client->effects;
        if (!entrender->alpha)
                entrender->alpha = 1.0f;
        if(ed->fields.client->effects)  entrender->effects |= (int)ed->fields.client->effects;
        if (!entrender->alpha)
                entrender->alpha = 1.0f;


@@ -202,11 +342,11 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
        VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
        VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
        VM_UpdateEdictSkeleton(ed, model, ed->priv.server->frameblend);
        VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
        VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
        VM_UpdateEdictSkeleton(ed, model, ed->priv.server->frameblend);

-       entrender->shadertime = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.shadertime);
+       entrender->shadertime = PRVM_clientedictfloat(ed, shadertime);

 
        // transparent offset
        if (renderflags & RF_USETRANSPARENTOFFSET)
 
        // transparent offset
        if (renderflags & RF_USETRANSPARENTOFFSET)

-               entrender->transparent_offset = PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.transparent_offset);
+               entrender->transparent_offset = PRVM_clientglobalfloat(transparent_offset);

 
        if(renderflags)
        {
 
        if(renderflags)
        {


@@ -518,7 +658,7 @@ void CL_VM_UpdateIntermissionState (int intermission)
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.intermission) = intermission;
+               PRVM_clientglobalfloat(intermission) = intermission;

                CSQC_END
        }
 }
                CSQC_END
        }
 }


@@ -527,7 +667,7 @@ void CL_VM_UpdateShowingScoresState (int showingscores)
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN
        if(cl.csqc_loaded)
        {
                CSQC_BEGIN

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.sb_showscores) = showingscores;
+               PRVM_clientglobalfloat(sb_showscores) = showingscores;

                CSQC_END
        }
 }
                CSQC_END
        }
 }


@@ -582,8 +722,8 @@ void CL_VM_UpdateCoopDeathmatchGlobals (int gametype)
                        localdeathmatch = 0;
                }
                CSQC_BEGIN
                        localdeathmatch = 0;
                }
                CSQC_BEGIN

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.coop) = localcoop;
-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.deathmatch) = localdeathmatch;
+               PRVM_clientglobalfloat(coop) = localcoop;
+               PRVM_clientglobalfloat(deathmatch) = localdeathmatch;

                CSQC_END
        }
 }
                CSQC_END
        }
 }


@@ -787,149 +927,6 @@ qboolean MakeDownloadPacket(const char *filename, unsigned char *data, size_t le
        return false;
 }
 
        return false;
 }
 

-#define CL_REQFIELDS (sizeof(cl_reqfields) / sizeof(prvm_required_field_t))
-
-prvm_required_field_t cl_reqfields[] =
-{
-       {ev_entity, "groundentity"},
-       {ev_entity, "tag_entity"},
-       {ev_float, "alpha"},
-       {ev_float, "dimension_hit"},
-       {ev_float, "dimension_solid"},
-       {ev_float, "dphitcontentsmask"},
-       {ev_float, "frame"},
-       {ev_float, "frame1time"},
-       {ev_float, "frame2"},
-       {ev_float, "frame2time"},
-       {ev_float, "frame3"},
-       {ev_float, "frame3time"},
-       {ev_float, "frame4"},
-       {ev_float, "frame4time"},
-       {ev_float, "gravity"},
-       {ev_float, "idealpitch"},
-       {ev_float, "lerpfrac"},
-       {ev_float, "lerpfrac3"},
-       {ev_float, "lerpfrac4"},
-       {ev_float, "movetype"}, // used by ODE code
-       {ev_float, "nextthink"},
-       {ev_float, "pitch_speed"},
-       {ev_float, "renderflags"},
-       {ev_float, "scale"},
-       {ev_float, "shadertime"},
-       {ev_float, "skeletonindex"},
-       {ev_float, "solid"}, // used by ODE code
-       {ev_float, "tag_index"},
-       {ev_float, "userwavefunc_param0"},
-       {ev_float, "userwavefunc_param1"},
-       {ev_float, "userwavefunc_param2"},
-       {ev_float, "userwavefunc_param3"},
-       {ev_function, "camera_transform"},
-       {ev_function, "think"},
-       {ev_string, "classname"},
-       {ev_vector, "colormod"},
-       {ev_vector, "glowmod"},
-
-       // physics
-       //{ev_float, "solid"},
-       //{ev_float, "movetype"},
-       //{ev_float, "modelindex"},
-       {ev_vector, "mass"},
-       //{ev_vector, "origin"},
-       //{ev_vector, "velocity"},
-       //{ev_vector, "axis_forward"},
-       //{ev_vector, "axis_left"},
-       //{ev_vector, "axis_up"},
-       //{ev_vector, "spinvelocity"},
-       //{ev_vector, "angles"},
-       //{ev_vector, "avelocity"},
-};
-
-#define CL_REQGLOBALS (sizeof(cl_reqglobals) / sizeof(prvm_required_field_t))
-
-prvm_required_field_t cl_reqglobals[] =
-{
-       {ev_entity, "self"},
-       {ev_entity, "trace_ent"},
-       {ev_entity, "trace_networkentity"},
-       {ev_float, "coop"},
-       {ev_float, "deathmatch"},
-       {ev_float, "dmg_save"},
-       {ev_float, "dmg_take"},
-       {ev_float, "drawfont"},
-       {ev_float, "drawfontscale"},
-       {ev_float, "gettaginfo_parent"},
-       {ev_float, "intermission"},
-       {ev_float, "particle_airfriction"},
-       {ev_float, "particle_alpha"},
-       {ev_float, "particle_alphafade"},
-       {ev_float, "particle_angle"},
-       {ev_float, "particle_blendmode"},
-       {ev_float, "particle_bounce"},
-       {ev_float, "particle_delaycollision"},
-       {ev_float, "particle_delayspawn"},
-       {ev_float, "particle_gravity"},
-       {ev_float, "particle_liquidfriction"},
-       {ev_float, "particle_orientation"},
-       {ev_float, "particle_originjitter"},
-       {ev_float, "particle_qualityreduction"},
-       {ev_float, "particle_size"},
-       {ev_float, "particle_sizeincrease"},
-       {ev_float, "particle_spin"},
-       {ev_float, "particle_stainalpha"},
-       {ev_float, "particle_stainsize"},
-       {ev_float, "particle_staintex"},
-       {ev_float, "particle_staintex"},
-       {ev_float, "particle_stretch"},
-       {ev_float, "particle_tex"},
-       {ev_float, "particle_time"},
-       {ev_float, "particle_type"},
-       {ev_float, "particle_velocityjitter"},
-       {ev_float, "particles_alphamax"},
-       {ev_float, "particles_alphamin"},
-       {ev_float, "pmove_onground"},
-       {ev_float, "pmove_inwater"},
-       {ev_float, "require_spawnfunc_prefix"},
-       {ev_float, "sb_showscores"},
-       {ev_float, "serverdeltatime"},
-       {ev_float, "serverprevtime"},
-       {ev_float, "servertime"},
-       {ev_float, "time"},
-       {ev_float, "trace_allsolid"},
-       {ev_float, "trace_dphitcontents"},
-       {ev_float, "trace_dphitq3surfaceflags"},
-       {ev_float, "trace_dpstartcontents"},
-       {ev_float, "trace_fraction"},
-       {ev_float, "trace_inopen"},
-       {ev_float, "trace_inwater"},
-       {ev_float, "trace_plane_dist"},
-       {ev_float, "trace_startsolid"},
-       {ev_float, "transparent_offset"},
-       {ev_string, "SV_InitCmd"},
-       {ev_string, "gettaginfo_name"},
-       {ev_string, "trace_dphittexturename"},
-       {ev_string, "worldstatus"},
-       {ev_string, "message"},
-       {ev_vector, "dmg_origin"},
-       {ev_vector, "gettaginfo_forward"},
-       {ev_vector, "gettaginfo_offset"},
-       {ev_vector, "gettaginfo_right"},
-       {ev_vector, "gettaginfo_up"},
-       {ev_vector, "particle_color1"},
-       {ev_vector, "particle_color2"},
-       {ev_vector, "particle_staincolor1"},
-       {ev_vector, "particle_staincolor2"},
-       {ev_vector, "particles_colormax"},
-       {ev_vector, "particles_colormin"},
-       {ev_vector, "trace_endpos"},
-       {ev_vector, "trace_plane_normal"},
-       {ev_vector, "v_forward"},
-       {ev_vector, "v_right"},
-       {ev_vector, "v_up"},
-       {ev_vector, "view_angles"},
-       {ev_vector, "view_punchangle"},
-       {ev_vector, "view_punchvector"},
-};
-

 void CL_VM_Init (void)
 {
        const char* csprogsfn;
 void CL_VM_Init (void)
 {
        const char* csprogsfn;


@@ -1070,7 +1067,7 @@ void CL_VM_Init (void)
        prog->globals.client->player_localentnum = cl.playerentity;
 
        // set map description (use world entity 0)
        prog->globals.client->player_localentnum = cl.playerentity;
 
        // set map description (use world entity 0)

-       PRVM_EDICTFIELDSTRING(prog->edicts, prog->fieldoffsets.message) = PRVM_SetEngineString(cl.worldmessage);
+       PRVM_clientedictstring(prog->edicts, message) = PRVM_SetEngineString(cl.worldmessage);

        VectorCopy(cl.world.mins, prog->edicts->fields.client->mins);
        VectorCopy(cl.world.maxs, prog->edicts->fields.client->maxs);
 
        VectorCopy(cl.world.mins, prog->edicts->fields.client->mins);
        VectorCopy(cl.world.maxs, prog->edicts->fields.client->maxs);
 


@@ -1145,7 +1142,7 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                ed = PRVM_EDICT_NUM(entnum);
                // camera:
                //   camera_transform
                ed = PRVM_EDICT_NUM(entnum);
                // camera:
                //   camera_transform

-               if(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform))
+               if(PRVM_clientedictfunction(ed, camera_transform))

                {
                        ret = true;
                        if(viewmatrix || clipplane || visorigin)
                {
                        ret = true;
                        if(viewmatrix || clipplane || visorigin)


@@ -1156,16 +1153,16 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                                prog->globals.client->self = entnum;
                                VectorCopy(origin, PRVM_G_VECTOR(OFS_PARM0));
                                VectorCopy(ang, PRVM_G_VECTOR(OFS_PARM1));
                                prog->globals.client->self = entnum;
                                VectorCopy(origin, PRVM_G_VECTOR(OFS_PARM0));
                                VectorCopy(ang, PRVM_G_VECTOR(OFS_PARM1));

-                               VectorCopy(forward, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward));
-                               VectorScale(left, -1, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right));
-                               VectorCopy(up, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up));
-                               VectorCopy(origin, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos));
-                               PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform), "QC function e.camera_transform is missing");
+                               VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+                               VectorScale(left, -1, PRVM_clientglobalvector(v_right));
+                               VectorCopy(up, PRVM_clientglobalvector(v_up));
+                               VectorCopy(origin, PRVM_clientglobalvector(trace_endpos));
+                               PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, camera_transform), "QC function e.camera_transform is missing");

                                VectorCopy(PRVM_G_VECTOR(OFS_RETURN), origin);
                                VectorCopy(PRVM_G_VECTOR(OFS_RETURN), origin);

-                               VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward), forward);
-                               VectorScale(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right), -1, left);
-                               VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up), up);
-                               VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos), visorigin);
+                               VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+                               VectorScale(PRVM_clientglobalvector(v_right), -1, left);
+                               VectorCopy(PRVM_clientglobalvector(v_up), up);
+                               VectorCopy(PRVM_clientglobalvector(trace_endpos), visorigin);

                                Matrix4x4_Invert_Full(&mat, viewmatrix);
                                Matrix4x4_FromVectors(viewmatrix, forward, left, up, origin);
                                Matrix4x4_Concat(&matq, viewmatrix, &mat);
                                Matrix4x4_Invert_Full(&mat, viewmatrix);
                                Matrix4x4_FromVectors(viewmatrix, forward, left, up, origin);
                                Matrix4x4_Concat(&matq, viewmatrix, &mat);

diff --git a/gl_rmain.c b/gl_rmain.c
index eee8a48f8c05ddd6a4d5d3dcffaf8add82d37ac7..020fa1e8ab9db3fbbebf3b4232c122ad7606dacd 100644 (file)
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -7038,9 +7038,9 @@ static void R_DrawEntityBBoxes(void)
                if (edict->priv.server->free)
                        continue;
                // exclude the following for now, as they don't live in world coordinate space and can't be solid:
                if (edict->priv.server->free)
                        continue;
                // exclude the following for now, as they don't live in world coordinate space and can't be solid:

-               if(PRVM_EDICTFIELDEDICT(edict, prog->fieldoffsets.tag_entity) != 0)
+               if(PRVM_serveredictedict(edict, tag_entity) != 0)

                        continue;
                        continue;

-               if(PRVM_EDICTFIELDEDICT(edict, prog->fieldoffsets.viewmodelforclient) != 0)
+               if(PRVM_serveredictedict(edict, viewmodelforclient) != 0)

                        continue;
                VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
                R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);
                        continue;
                VectorLerp(edict->priv.server->areamins, 0.5f, edict->priv.server->areamaxs, center);
                R_MeshQueue_AddTransparent(center, R_DrawEntityBBoxes_Callback, (entity_render_t *)NULL, i, (rtlight_t *)NULL);

diff --git a/host_cmd.c b/host_cmd.c
index bf003e5f24c30f658026a962f2488a3a02084e98..9278b7aa9493453b872e1a528d7d9cf87d640f6b 100644 (file)
--- a/host_cmd.c
+++ b/host_cmd.c
@@ -155,9 +155,10 @@ void Host_Status_f (void)
 
                frags = client->frags;
 
 
                frags = client->frags;
 

-               if(sv_status_show_qcstatus.integer && prog->fieldoffsets.clientstatus >= 0)
+               if(sv_status_show_qcstatus.integer)

                {
                {

-                       const char *str = PRVM_E_STRING(PRVM_EDICT_NUM(i + 1), prog->fieldoffsets.clientstatus);
+                       prvm_edict_t *ed = PRVM_EDICT_NUM(i + 1);
+                       const char *str = PRVM_GetString(PRVM_serveredictstring(ed, clientstatus));

                        if(str && *str)
                        {
                                char *p;
                        if(str && *str)
                        {
                                char *p;


@@ -1254,8 +1255,7 @@ void Host_Playermodel_f (void)
 
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playermodel, newPath, sizeof (host_client->playermodel));
 
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playermodel, newPath, sizeof (host_client->playermodel));

-       if (prog->fieldoffsets.playermodel >= 0)
-               PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playermodel) = PRVM_SetEngineString(host_client->playermodel);
+       PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(host_client->playermodel);

        if (strcmp(host_client->old_model, host_client->playermodel))
        {
                strlcpy(host_client->old_model, host_client->playermodel, sizeof(host_client->old_model));
        if (strcmp(host_client->old_model, host_client->playermodel))
        {
                strlcpy(host_client->old_model, host_client->playermodel, sizeof(host_client->old_model));


@@ -1311,8 +1311,7 @@ void Host_Playerskin_f (void)
 
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playerskin, newPath, sizeof (host_client->playerskin));
 
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playerskin, newPath, sizeof (host_client->playerskin));

-       if (prog->fieldoffsets.playerskin >= 0)
-               PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playerskin) = PRVM_SetEngineString(host_client->playerskin);
+       PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(host_client->playerskin);

        if (strcmp(host_client->old_skin, host_client->playerskin))
        {
                //if (host_client->spawned)
        if (strcmp(host_client->old_skin, host_client->playerskin))
        {
                //if (host_client->spawned)


@@ -1585,7 +1584,7 @@ void Host_Color(int changetop, int changebottom)
        {
                if (host_client->edict)
                {
        {
                if (host_client->edict)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.clientcolors) = playercolor;
+                       PRVM_serveredictfloat(host_client->edict, clientcolors) = playercolor;

                        host_client->edict->fields.server->team = bottom + 1;
                }
                host_client->colors = playercolor;
                        host_client->edict->fields.server->team = bottom + 1;
                }
                host_client->colors = playercolor;


@@ -1735,7 +1734,7 @@ static void Host_PModel_f (void)
                return;
        }
 
                return;
        }
 

-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.pmodel) = i;
+       PRVM_serveredictfloat(host_client->edict, pmodel) = i;

 }
 
 //===========================================================================
 }
 
 //===========================================================================


@@ -2073,14 +2072,14 @@ void Host_Give_f (void)
 
        case 's':
                if (gamemode == GAME_ROGUE)
 
        case 's':
                if (gamemode == GAME_ROGUE)

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_shells1) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_shells1) = v;

 
                host_client->edict->fields.server->ammo_shells = v;
                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {
 
                host_client->edict->fields.server->ammo_shells = v;
                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_nails1) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_nails1) = v;

                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_nails = v;
                }
                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_nails = v;
                }


@@ -2092,7 +2091,7 @@ void Host_Give_f (void)
        case 'l':
                if (gamemode == GAME_ROGUE)
                {
        case 'l':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_lava_nails) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_lava_nails) = v;

                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_nails = v;
                }
                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_nails = v;
                }


@@ -2100,7 +2099,7 @@ void Host_Give_f (void)
        case 'r':
                if (gamemode == GAME_ROGUE)
                {
        case 'r':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_rockets1) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_rockets1) = v;

                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_rockets = v;
                }
                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_rockets = v;
                }


@@ -2112,7 +2111,7 @@ void Host_Give_f (void)
        case 'm':
                if (gamemode == GAME_ROGUE)
                {
        case 'm':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_multi_rockets) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_multi_rockets) = v;

                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_rockets = v;
                }
                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_rockets = v;
                }


@@ -2123,7 +2122,7 @@ void Host_Give_f (void)
        case 'c':
                if (gamemode == GAME_ROGUE)
                {
        case 'c':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_cells1) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_cells1) = v;

                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_cells = v;
                }
                        if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_cells = v;
                }


@@ -2135,7 +2134,7 @@ void Host_Give_f (void)
        case 'p':
                if (gamemode == GAME_ROGUE)
                {
        case 'p':
                if (gamemode == GAME_ROGUE)
                {

-                       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ammo_plasma) = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_plasma) = v;

                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_cells = v;
                }
                        if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
                                host_client->edict->fields.server->ammo_cells = v;
                }

diff --git a/menu.c b/menu.c
index bb82b8d487529ebe96f703f4e929c7aa821ed1c7..5d726dfc0879a505f3c4b5dbdbe4f130c4040282 100644 (file)
--- a/menu.c
+++ b/menu.c
@@ -5015,6 +5015,23 @@ static const char *m_required_func[] = {
 
 static int m_numrequiredfunc = sizeof(m_required_func) / sizeof(char*);
 
 
 static int m_numrequiredfunc = sizeof(m_required_func) / sizeof(char*);
 

+static prvm_required_field_t m_required_fields[] =
+{
+       {ev_string, "classname"}, // menu field
+};
+
+static int m_numrequiredfields = sizeof(m_required_fields) / sizeof(m_required_fields[0]);
+
+static prvm_required_field_t m_required_globals[] =
+{
+       {ev_entity, "self"}, // menu global
+       {ev_float, "drawfont"}, // menu global
+       {ev_float, "require_spawnfunc_prefix"}, // menu global
+       {ev_vector, "drawfontscale"}, // menu global
+};
+
+static int m_numrequiredglobals = sizeof(m_required_globals) / sizeof(m_required_globals[0]);
+

 void MR_SetRouting (qboolean forceold);
 
 void MP_Error(const char *format, ...) DP_FUNC_PRINTF(1);
 void MR_SetRouting (qboolean forceold);
 
 void MP_Error(const char *format, ...) DP_FUNC_PRINTF(1);


@@ -5158,7 +5175,7 @@ void MP_Init (void)
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(M_PROG_FILENAME, 0, NULL);
 
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(M_PROG_FILENAME, 0, NULL);
 

-       PRVM_LoadProgs(M_PROG_FILENAME, m_numrequiredfunc, m_required_func, 0, NULL, 0, NULL);
+       PRVM_LoadProgs(M_PROG_FILENAME, m_numrequiredfunc, m_required_func, m_numrequiredfields, m_required_fields, m_numrequiredglobals, m_required_globals);

 
        // note: OP_STATE is not supported by menu qc, we don't even try to detect
        // it here
 
        // note: OP_STATE is not supported by menu qc, we don't even try to detect
        // it here

diff --git a/netconn.c b/netconn.c
index e2095d9197bc82c13ca13c6f2d7a9da77ba5e6b5..65b64830067da60339105a1a36e91d4cacd5cd98 100755 (executable)
--- a/netconn.c
+++ b/netconn.c
@@ -2287,6 +2287,7 @@ static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg
        int length;
        char teambuf[3];
        const char *crypto_idstring;
        int length;
        char teambuf[3];
        const char *crypto_idstring;

+       const char *str;

 
        SV_VM_Begin();
 
 
        SV_VM_Begin();
 


@@ -2302,19 +2303,16 @@ static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg
        }
 
        *qcstatus = 0;
        }
 
        *qcstatus = 0;

-       if(prog->globaloffsets.worldstatus >= 0)
+       str = PRVM_GetString(PRVM_serverglobalstring(worldstatus));
+       if(str && *str)

        {
        {

-               const char *str = PRVM_G_STRING(prog->globaloffsets.worldstatus);
-               if(str && *str)
-               {
-                       char *p;
-                       const char *q;
-                       p = qcstatus;
-                       for(q = str; *q && p - qcstatus < (ptrdiff_t)(sizeof(qcstatus)) - 1; ++q)
-                               if(*q != '\\' && *q != '\n')
-                                       *p++ = *q;
-                       *p = 0;
-               }
+               char *p;
+               const char *q;
+               p = qcstatus;
+               for(q = str; *q && p - qcstatus < (ptrdiff_t)(sizeof(qcstatus)) - 1; ++q)
+                       if(*q != '\\' && *q != '\n')
+                               *p++ = *q;
+               *p = 0;

        }
 
        /// \TODO: we should add more information for the full status string
        }
 
        /// \TODO: we should add more information for the full status string


@@ -2358,6 +2356,8 @@ static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg
                                int nameind, cleanind, pingvalue;
                                char curchar;
                                char cleanname [sizeof(cl->name)];
                                int nameind, cleanind, pingvalue;
                                char curchar;
                                char cleanname [sizeof(cl->name)];

+                               const char *str;
+                               prvm_edict_t *ed;

 
                                // Remove all characters '"' and '\' in the player name
                                nameind = 0;
 
                                // Remove all characters '"' and '\' in the player name
                                nameind = 0;


@@ -2381,19 +2381,17 @@ static qboolean NetConn_BuildStatusResponse(const char* challenge, char* out_msg
                                        pingvalue = 0;
 
                                *qcstatus = 0;
                                        pingvalue = 0;
 
                                *qcstatus = 0;

-                               if(prog->fieldoffsets.clientstatus >= 0)
+                               ed = PRVM_EDICT_NUM(i + 1);
+                               str = PRVM_GetString(PRVM_serveredictstring(ed, clientstatus));
+                               if(str && *str)

                                {
                                {

-                                       const char *str = PRVM_E_STRING(PRVM_EDICT_NUM(i + 1), prog->fieldoffsets.clientstatus);
-                                       if(str && *str)
-                                       {
-                                               char *p;
-                                               const char *q;
-                                               p = qcstatus;
-                                               for(q = str; *q && p != qcstatus + sizeof(qcstatus) - 1; ++q)
-                                                       if(*q != '\\' && *q != '"' && !ISWHITESPACE(*q))
-                                                               *p++ = *q;
-                                               *p = 0;
-                                       }
+                                       char *p;
+                                       const char *q;
+                                       p = qcstatus;
+                                       for(q = str; *q && p != qcstatus + sizeof(qcstatus) - 1; ++q)
+                                               if(*q != '\\' && *q != '"' && !ISWHITESPACE(*q))
+                                                       *p++ = *q;
+                                       *p = 0;

                                }
 
                                if ((gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) && (teamplay.integer > 0))
                                }
 
                                if ((gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC) && (teamplay.integer > 0))

diff --git a/progsvm.h b/progsvm.h
index 0f81f292b1fa033be2a0fe266f2ccd2148b260b7..de85a66ddc5b2686603a561b194ec7b13eea913b 100644 (file)
--- a/progsvm.h
+++ b/progsvm.h
@@ -117,6 +117,62 @@ typedef struct prvm_edict_s
 
 extern prvm_eval_t prvm_badvalue;
 
 
 extern prvm_eval_t prvm_badvalue;
 

+#define PRVM_alledictfloat(ed, fieldname)    (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_alledictvector(ed, fieldname)   (PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.fieldname))
+#define PRVM_alledictstring(ed, fieldname)   (PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.fieldname))
+#define PRVM_alledictedict(ed, fieldname)    (PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_alledictfunction(ed, fieldname) (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.fieldname))
+#define PRVM_allglobalfloat(fieldname)       (PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.fieldname))
+#define PRVM_allglobalvector(fieldname)      (PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.fieldname))
+#define PRVM_allglobalstring(fieldname)      (PRVM_GLOBALFIELDSTRING(prog->globaloffsets.fieldname))
+#define PRVM_allglobaledict(fieldname)       (PRVM_GLOBALFIELDEDICT(prog->globaloffsets.fieldname))
+#define PRVM_allglobalfunction(fieldname)    (PRVM_GLOBALFIELDFUNCTION(prog->globaloffsets.fieldname))
+
+#define PRVM_drawedictfloat(ed, fieldname)    (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_drawedictvector(ed, fieldname)   (PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.fieldname))
+#define PRVM_drawedictstring(ed, fieldname)   (PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.fieldname))
+#define PRVM_drawedictedict(ed, fieldname)    (PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_drawedictfunction(ed, fieldname) (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.fieldname))
+#define PRVM_drawglobalfloat(fieldname)       (PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.fieldname))
+#define PRVM_drawglobalvector(fieldname)      (PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.fieldname))
+#define PRVM_drawglobalstring(fieldname)      (PRVM_GLOBALFIELDSTRING(prog->globaloffsets.fieldname))
+#define PRVM_drawglobaledict(fieldname)       (PRVM_GLOBALFIELDEDICT(prog->globaloffsets.fieldname))
+#define PRVM_drawglobalfunction(fieldname)    (PRVM_GLOBALFIELDFUNCTION(prog->globaloffsets.fieldname))
+
+#define PRVM_gameedictfloat(ed, fieldname)    (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_gameedictvector(ed, fieldname)   (PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.fieldname))
+#define PRVM_gameedictstring(ed, fieldname)   (PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.fieldname))
+#define PRVM_gameedictedict(ed, fieldname)    (PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_gameedictfunction(ed, fieldname) (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.fieldname))
+#define PRVM_gameglobalfloat(fieldname)       (PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.fieldname))
+#define PRVM_gameglobalvector(fieldname)      (PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.fieldname))
+#define PRVM_gameglobalstring(fieldname)      (PRVM_GLOBALFIELDSTRING(prog->globaloffsets.fieldname))
+#define PRVM_gameglobaledict(fieldname)       (PRVM_GLOBALFIELDEDICT(prog->globaloffsets.fieldname))
+#define PRVM_gameglobalfunction(fieldname)    (PRVM_GLOBALFIELDFUNCTION(prog->globaloffsets.fieldname))
+
+#define PRVM_serveredictfloat(ed, fieldname)    (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_serveredictvector(ed, fieldname)   (PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.fieldname))
+#define PRVM_serveredictstring(ed, fieldname)   (PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.fieldname))
+#define PRVM_serveredictedict(ed, fieldname)    (PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_serveredictfunction(ed, fieldname) (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.fieldname))
+#define PRVM_serverglobalfloat(fieldname)       (PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.fieldname))
+#define PRVM_serverglobalvector(fieldname)      (PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.fieldname))
+#define PRVM_serverglobalstring(fieldname)      (PRVM_GLOBALFIELDSTRING(prog->globaloffsets.fieldname))
+#define PRVM_serverglobaledict(fieldname)       (PRVM_GLOBALFIELDEDICT(prog->globaloffsets.fieldname))
+#define PRVM_serverglobalfunction(fieldname)    (PRVM_GLOBALFIELDFUNCTION(prog->globaloffsets.fieldname))
+
+#define PRVM_clientedictfloat(ed, fieldname)    (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_clientedictvector(ed, fieldname)   (PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.fieldname))
+#define PRVM_clientedictstring(ed, fieldname)   (PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.fieldname))
+#define PRVM_clientedictedict(ed, fieldname)    (PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.fieldname))
+#define PRVM_clientedictfunction(ed, fieldname) (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.fieldname))
+#define PRVM_clientglobalfloat(fieldname)       (PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.fieldname))
+#define PRVM_clientglobalvector(fieldname)      (PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.fieldname))
+#define PRVM_clientglobalstring(fieldname)      (PRVM_GLOBALFIELDSTRING(prog->globaloffsets.fieldname))
+#define PRVM_clientglobaledict(fieldname)       (PRVM_GLOBALFIELDEDICT(prog->globaloffsets.fieldname))
+#define PRVM_clientglobalfunction(fieldname)    (PRVM_GLOBALFIELDFUNCTION(prog->globaloffsets.fieldname))
+
+

 #if 1
 #define PRVM_EDICTFIELDVALUE(ed, fieldoffset)    (fieldoffset < 0 ? Con_Printf("Invalid fieldoffset at %s:%i\n", __FILE__, __LINE__), &prvm_badvalue : (prvm_eval_t *)((int *)ed->fields.vp + fieldoffset))
 #define PRVM_EDICTFIELDFLOAT(ed, fieldoffset)    (PRVM_EDICTFIELDVALUE(ed, fieldoffset)->_float)
 #if 1
 #define PRVM_EDICTFIELDVALUE(ed, fieldoffset)    (fieldoffset < 0 ? Con_Printf("Invalid fieldoffset at %s:%i\n", __FILE__, __LINE__), &prvm_badvalue : (prvm_eval_t *)((int *)ed->fields.vp + fieldoffset))
 #define PRVM_EDICTFIELDFLOAT(ed, fieldoffset)    (PRVM_EDICTFIELDVALUE(ed, fieldoffset)->_float)


@@ -366,6 +422,35 @@ typedef struct prvm_prog_globaloffsets_s
        int particles_alphamax; // csqc
        int particles_colormin; // csqc
        int particles_colormax; // csqc
        int particles_alphamax; // csqc
        int particles_colormin; // csqc
        int particles_colormax; // csqc

+
+       int particle_type; // csqc
+       int particle_blendmode; // csqc
+       int particle_orientation; // csqc
+       int particle_color1; // csqc
+       int particle_color2; // csqc
+       int particle_tex; // csqc
+       int particle_size; // csqc
+       int particle_sizeincrease; // csqc
+       int particle_alpha; // csqc
+       int particle_alphafade; // csqc
+       int particle_time; // csqc
+       int particle_gravity; // csqc
+       int particle_bounce; // csqc
+       int particle_airfriction; // csqc
+       int particle_liquidfriction; // csqc
+       int particle_originjitter; // csqc
+       int particle_velocityjitter; // csqc
+       int particle_qualityreduction; // csqc
+       int particle_stretch; // csqc
+       int particle_staincolor1; // csqc
+       int particle_staincolor2; // csqc
+       int particle_stainalpha; // csqc
+       int particle_stainsize; // csqc
+       int particle_staintex; // csqc
+       int particle_delayspawn; // csqc
+       int particle_delaycollision; // csqc
+       int particle_angle; // csqc
+       int particle_spin; // csqc

 }
 prvm_prog_globaloffsets_t;
 
 }
 prvm_prog_globaloffsets_t;
 

diff --git a/protocol.c b/protocol.c
index 3a5d54009b262658064abc4c3bc4192d303b0c90..3ae47c56564cdb05b709a3a80b31d68f56db520f 100644 (file)
--- a/protocol.c
+++ b/protocol.c
@@ -7,14 +7,7 @@
        if(developer_networkentities.integer >= 2) \
        { \
                prvm_edict_t *ed = prog->edicts + num; \
        if(developer_networkentities.integer >= 2) \
        { \
                prvm_edict_t *ed = prog->edicts + num; \

-               const char *cname = "(no classname)"; \
-               if(prog->fieldoffsets.classname >= 0) \
-               { \
-                       string_t handle =  PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname); \
-                       if (handle) \
-                               cname = PRVM_GetString(handle); \
-               } \
-               Con_Printf("sent entity update of size %d for a %s\n", (msg->cursize - entityprofiling_startsize), cname); \
+               Con_Printf("sent entity update of size %d for a %s\n", (msg->cursize - entityprofiling_startsize), PRVM_serveredictstring(ed, classname) ? PRVM_GetString(PRVM_serveredictstring(ed, classname)) : "(no classname)"); \

        }
 
 // this is 88 bytes (must match entity_state_t in protocol.h)
        }
 
 // this is 88 bytes (must match entity_state_t in protocol.h)


@@ -281,16 +274,13 @@ static void EntityFrameCSQC_LostAllFrames(client_t *client)
        int i, n;
        prvm_edict_t *ed;
 
        int i, n;
        prvm_edict_t *ed;
 

-       if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
-               return;
-

        n = client->csqcnumedicts;
        for(i = 0; i < n; ++i)
        {
                if(client->csqcentityglobalhistory[i])
                {
                        ed = prog->edicts + i;
        n = client->csqcnumedicts;
        for(i = 0; i < n; ++i)
        {
                if(client->csqcentityglobalhistory[i])
                {
                        ed = prog->edicts + i;

-                       if (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.SendEntity))
+                       if (PRVM_serveredictfunction(ed, SendEntity))

                                client->csqcentitysendflags[i] |= 0xFFFFFF; // FULL RESEND
                        else // if it was ever sent to that client as a CSQC entity
                        {
                                client->csqcentitysendflags[i] |= 0xFFFFFF; // FULL RESEND
                        else // if it was ever sent to that client as a CSQC entity
                        {


@@ -454,10 +444,6 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
 
        maxsize -= 24; // always fit in an empty svc_entities message (for packet loss detection!)
 
 
        maxsize -= 24; // always fit in an empty svc_entities message (for packet loss detection!)
 

-       // if this server progs is not CSQC-aware, return early
-       if(prog->fieldoffsets.SendEntity < 0 || prog->fieldoffsets.Version < 0)
-               return false;
-

        // make sure there is enough room to store the svc_csqcentities byte,
        // the terminator (0x0000) and at least one entity update
        if (msg->cursize + 32 >= maxsize)
        // make sure there is enough room to store the svc_csqcentities byte,
        // the terminator (0x0000) and at least one entity update
        if (msg->cursize + 32 >= maxsize)


@@ -479,7 +465,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
                        }
                }
                ed = prog->edicts + number;
                        }
                }
                ed = prog->edicts + number;

-               if (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.SendEntity))
+               if (PRVM_serveredictfunction(ed, SendEntity))

                        client->csqcentityscope[number] = 2;
                else if (client->csqcentityscope[number])
                {
                        client->csqcentityscope[number] = 2;
                else if (client->csqcentityscope[number])
                {


@@ -508,7 +494,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
        {
                number = *n;
                ed = prog->edicts + number;
        {
                number = *n;
                ed = prog->edicts + number;

-               if (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.SendEntity))
+               if (PRVM_serveredictfunction(ed, SendEntity))

                        client->csqcentityscope[number] = 2;
        }
        */
                        client->csqcentityscope[number] = 2;
        }
        */


@@ -557,7 +543,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
                        // save the cursize value in case we overflow and have to rollback
                        int oldcursize = msg->cursize;
                        client->csqcentityscope[number] = 1;
                        // save the cursize value in case we overflow and have to rollback
                        int oldcursize = msg->cursize;
                        client->csqcentityscope[number] = 1;

-                       if (PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.SendEntity))
+                       if (PRVM_serveredictfunction(ed, SendEntity))

                        {
                                if(!sectionstarted)
                                        MSG_WriteByte(msg, svc_csqcentities);
                        {
                                if(!sectionstarted)
                                        MSG_WriteByte(msg, svc_csqcentities);


@@ -568,7 +554,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
                                        PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
                                        PRVM_G_FLOAT(OFS_PARM1) = sendflags;
                                        prog->globals.server->self = number;
                                        PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
                                        PRVM_G_FLOAT(OFS_PARM1) = sendflags;
                                        prog->globals.server->self = number;

-                                       PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.SendEntity), "Null SendEntity\n");
+                                       PRVM_ExecuteProgram(PRVM_serveredictfunction(ed, SendEntity), "Null SendEntity\n");

                                        msg->allowoverflow = false;
                                        if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
                                        {
                                        msg->allowoverflow = false;
                                        if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
                                        {


@@ -706,7 +692,7 @@ qboolean EntityFrameQuake_WriteFrame(sizebuf_t *msg, int maxsize, int numstates,
        {
                ENTITYSIZEPROFILING_START(msg, states[i]->number);
                s = states[i];
        {
                ENTITYSIZEPROFILING_START(msg, states[i]->number);
                s = states[i];

-               if(PRVM_EDICTFIELDFUNCTION((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity))
+               if(PRVM_serveredictfunction((&prog->edicts[s->number]), SendEntity))

                        continue;
 
                // prepare the buffer
                        continue;
 
                // prepare the buffer


@@ -1432,7 +1418,7 @@ qboolean EntityFrame_WriteFrame(sizebuf_t *msg, int maxsize, entityframe_databas
                ent = states[i];
                number = ent->number;
 
                ent = states[i];
                number = ent->number;
 

-               if (PRVM_EDICTFIELDFUNCTION((&prog->edicts[number]), prog->fieldoffsets.SendEntity))
+               if (PRVM_serveredictfunction((&prog->edicts[number]), SendEntity))

                        continue;
                for (;onum < o->numentities && o->entitydata[onum].number < number;onum++)
                {
                        continue;
                for (;onum < o->numentities && o->entitydata[onum].number < number;onum++)
                {


@@ -1921,7 +1907,7 @@ qboolean EntityFrame4_WriteFrame(sizebuf_t *msg, int maxsize, entityframe4_datab
        d->currententitynumber = 1;
        for (i = 0, n = startnumber;n < prog->max_edicts;n++)
        {
        d->currententitynumber = 1;
        for (i = 0, n = startnumber;n < prog->max_edicts;n++)
        {

-               if (PRVM_EDICTFIELDFUNCTION((&prog->edicts[n]), prog->fieldoffsets.SendEntity))
+               if (PRVM_serveredictfunction((&prog->edicts[n]), SendEntity))

                        continue;
                // find the old state to delta from
                e = EntityFrame4_GetReferenceEntity(d, n);
                        continue;
                // find the old state to delta from
                e = EntityFrame4_GetReferenceEntity(d, n);


@@ -2077,7 +2063,7 @@ void EntityState5_WriteUpdate(int number, const entity_state_t *s, int changedbi
        //dp_model_t *model;
        ENTITYSIZEPROFILING_START(msg, s->number);
 
        //dp_model_t *model;
        ENTITYSIZEPROFILING_START(msg, s->number);
 

-       if (PRVM_EDICTFIELDFUNCTION((&prog->edicts[s->number]), prog->fieldoffsets.SendEntity))
+       if (PRVM_serveredictfunction((&prog->edicts[s->number]), SendEntity))

                return;
 
        if (s->active != ACTIVE_NETWORK)
                return;
 
        if (s->active != ACTIVE_NETWORK)

diff --git a/prvm_cmds.c b/prvm_cmds.c
index 5222146df7ff612babc06f94cbbb41d717d88f43..5acc3eb2fb2d0631296de2de4fb182e70bab17ad 100644 (file)
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -64,17 +64,17 @@ void VM_GenerateFrameGroupBlend(framegroupblend_t *framegroupblend, const prvm_e
        // self.lerpfrac4 is the interpolation strength for self.frame4
        // pitch angle on a player model where the animator set up 5 sets of
        // animations and the csqc simply lerps between sets)
        // self.lerpfrac4 is the interpolation strength for self.frame4
        // pitch angle on a player model where the animator set up 5 sets of
        // animations and the csqc simply lerps between sets)

-       framegroupblend[0].frame = (int) PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame     );
-       framegroupblend[1].frame = (int) PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame2    );
-       framegroupblend[2].frame = (int) PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame3    );
-       framegroupblend[3].frame = (int) PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame4    );
-       framegroupblend[0].start =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame1time);
-       framegroupblend[1].start =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame2time);
-       framegroupblend[2].start =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame3time);
-       framegroupblend[3].start =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.frame4time);
-       framegroupblend[1].lerp  =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.lerpfrac  );
-       framegroupblend[2].lerp  =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.lerpfrac3 );
-       framegroupblend[3].lerp  =       PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.lerpfrac4 );
+       framegroupblend[0].frame = (int) PRVM_gameedictfloat(ed, frame     );
+       framegroupblend[1].frame = (int) PRVM_gameedictfloat(ed, frame2    );
+       framegroupblend[2].frame = (int) PRVM_gameedictfloat(ed, frame3    );
+       framegroupblend[3].frame = (int) PRVM_gameedictfloat(ed, frame4    );
+       framegroupblend[0].start =       PRVM_gameedictfloat(ed, frame1time);
+       framegroupblend[1].start =       PRVM_gameedictfloat(ed, frame2time);
+       framegroupblend[2].start =       PRVM_gameedictfloat(ed, frame3time);
+       framegroupblend[3].start =       PRVM_gameedictfloat(ed, frame4time);
+       framegroupblend[1].lerp  =       PRVM_gameedictfloat(ed, lerpfrac  );
+       framegroupblend[2].lerp  =       PRVM_gameedictfloat(ed, lerpfrac3 );
+       framegroupblend[3].lerp  =       PRVM_gameedictfloat(ed, lerpfrac4 );

        // assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed
        framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp;
 }
        // assume that the (missing) lerpfrac1 is whatever remains after lerpfrac2+lerpfrac3+lerpfrac4 are summed
        framegroupblend[0].lerp = 1 - framegroupblend[1].lerp - framegroupblend[2].lerp - framegroupblend[3].lerp;
 }


@@ -197,7 +197,7 @@ void VM_UpdateEdictSkeleton(prvm_edict_t *ed, const dp_model_t *edmodel, const f
        {
                int skeletonindex = -1;
                skeleton_t *skeleton;
        {
                int skeletonindex = -1;
                skeleton_t *skeleton;

-               skeletonindex = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.skeletonindex) - 1;
+               skeletonindex = (int)PRVM_gameedictfloat(ed, skeletonindex) - 1;

                if (skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)
                {
                        // custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS)
                if (skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones)
                {
                        // custom skeleton controlled by the game (FTE_CSQC_SKELETONOBJECTS)


@@ -310,11 +310,8 @@ void VM_error (void)
 
        VM_VarString(0, string, sizeof(string));
        Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 
        VM_VarString(0, string, sizeof(string));
        Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);

-       if (prog->globaloffsets.self >= 0)
-       {
-               ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self));
-               PRVM_ED_Print(ed, NULL);
-       }
+       ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
+       PRVM_ED_Print(ed, NULL);

 
        PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }
 
        PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }


@@ -336,16 +333,9 @@ void VM_objerror (void)
 
        VM_VarString(0, string, sizeof(string));
        Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
 
        VM_VarString(0, string, sizeof(string));
        Con_Printf("======OBJECT ERROR======\n"); // , PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME

-       if (prog->globaloffsets.self >= 0)
-       {
-               ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self));
-               PRVM_ED_Print(ed, NULL);
-
-               PRVM_ED_Free (ed);
-       }
-       else
-               // objerror has to display the object fields -> else call
-               PRVM_ERROR ("VM_objecterror: self not defined !");
+       ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
+       PRVM_ED_Print(ed, NULL);
+       PRVM_ED_Free (ed);

        Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }
 
        Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
 }
 


@@ -3294,28 +3284,20 @@ void getdrawfontscale(float *sx, float *sy)
 {
        vec3_t v;
        *sx = *sy = 1;
 {
        vec3_t v;
        *sx = *sy = 1;

-       if(prog->globaloffsets.drawfontscale >= 0)
+       VectorCopy(PRVM_drawglobalvector(drawfontscale), v);
+       if(VectorLength2(v) > 0)

        {
        {

-               VectorCopy(PRVM_G_VECTOR(prog->globaloffsets.drawfontscale), v);
-               if(VectorLength2(v) > 0)
-               {
-                       *sx = v[0];
-                       *sy = v[1];
-               }
+               *sx = v[0];
+               *sy = v[1];

        }
 }
 
 dp_font_t *getdrawfont(void)
 {
        }
 }
 
 dp_font_t *getdrawfont(void)
 {

-       if(prog->globaloffsets.drawfont >= 0)
-       {
-               int f = (int) PRVM_G_FLOAT(prog->globaloffsets.drawfont);
-               if(f < 0 || f >= dp_fonts.maxsize)
-                       return FONT_DEFAULT;
-               return &dp_fonts.f[f];
-       }
-       else
+       int f = (int) PRVM_drawglobalfloat(drawfont);
+       if(f < 0 || f >= dp_fonts.maxsize)

                return FONT_DEFAULT;
                return FONT_DEFAULT;

+       return &dp_fonts.f[f];

 }
 
 /*
 }
 
 /*


@@ -4448,7 +4430,7 @@ void makevectors(vector angle)
 void VM_makevectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_makevectors);
 void VM_makevectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_makevectors);

-       AngleVectors(PRVM_G_VECTOR(OFS_PARM0), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up));
+       AngleVectors(PRVM_G_VECTOR(OFS_PARM0), PRVM_gameglobalvector(v_forward), PRVM_gameglobalvector(v_right), PRVM_gameglobalvector(v_up));

 }
 
 /*
 }
 
 /*


@@ -4462,8 +4444,8 @@ vectorvectors(vector)
 void VM_vectorvectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_vectorvectors);
 void VM_vectorvectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_vectorvectors);

-       VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward));
-       VectorVectors(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right), PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up));
+       VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), PRVM_gameglobalvector(v_forward));
+       VectorVectors(PRVM_gameglobalvector(v_forward), PRVM_gameglobalvector(v_right), PRVM_gameglobalvector(v_up));

 }
 
 /*
 }
 
 /*


@@ -5243,7 +5225,7 @@ void VM_changeyaw (void)
        // parameters because they are the parameters to SV_MoveToGoal, not this
        //VM_SAFEPARMCOUNT(0, VM_changeyaw);
 
        // parameters because they are the parameters to SV_MoveToGoal, not this
        //VM_SAFEPARMCOUNT(0, VM_changeyaw);
 

-       ent = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self));
+       ent = PRVM_PROG_TO_EDICT(PRVM_gameglobaledict(self));

        if (ent == prog->edicts)
        {
                VM_Warning("changeyaw: can not modify world entity\n");
        if (ent == prog->edicts)
        {
                VM_Warning("changeyaw: can not modify world entity\n");


@@ -5254,15 +5236,10 @@ void VM_changeyaw (void)
                VM_Warning("changeyaw: can not modify free entity\n");
                return;
        }
                VM_Warning("changeyaw: can not modify free entity\n");
                return;
        }

-       if (prog->fieldoffsets.angles < 0 || prog->fieldoffsets.ideal_yaw < 0 || prog->fieldoffsets.yaw_speed < 0)
-       {
-               VM_Warning("changeyaw: angles, ideal_yaw, or yaw_speed field(s) not found\n");
-               return;
-       }
-       current = PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.angles)[1];
+       current = PRVM_gameedictvector(ent, angles)[1];

        current = ANGLEMOD(current);
        current = ANGLEMOD(current);

-       ideal = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.ideal_yaw);
-       speed = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.yaw_speed);
+       ideal = PRVM_gameedictfloat(ent, ideal_yaw);
+       speed = PRVM_gameedictfloat(ent, yaw_speed);

 
        if (current == ideal)
                return;
 
        if (current == ideal)
                return;


@@ -5289,7 +5266,7 @@ void VM_changeyaw (void)
        }
 
        current += move;
        }
 
        current += move;

-       PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.angles)[1] = ANGLEMOD(current);
+       PRVM_gameedictvector(ent, angles)[1] = ANGLEMOD(current);

 }
 
 /*
 }
 
 /*


@@ -5315,15 +5292,10 @@ void VM_changepitch (void)
                VM_Warning("changepitch: can not modify free entity\n");
                return;
        }
                VM_Warning("changepitch: can not modify free entity\n");
                return;
        }

-       if (prog->fieldoffsets.angles < 0 || prog->fieldoffsets.idealpitch < 0 || prog->fieldoffsets.pitch_speed < 0)
-       {
-               VM_Warning("changepitch: angles, idealpitch, or pitch_speed field(s) not found\n");
-               return;
-       }
-       current = PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.angles)[0];
+       current = PRVM_gameedictvector(ent, angles)[0];

        current = ANGLEMOD(current);
        current = ANGLEMOD(current);

-       ideal = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.idealpitch);
-       speed = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.pitch_speed);
+       ideal = PRVM_gameedictfloat(ent, idealpitch);
+       speed = PRVM_gameedictfloat(ent, pitch_speed);

 
        if (current == ideal)
                return;
 
        if (current == ideal)
                return;


@@ -5350,7 +5322,7 @@ void VM_changepitch (void)
        }
 
        current += move;
        }
 
        current += move;

-       PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.angles)[0] = ANGLEMOD(current);
+       PRVM_gameedictvector(ent, angles)[0] = ANGLEMOD(current);

 }
 
 
 }
 
 


@@ -5673,37 +5645,37 @@ void VM_wasfreed (void)
 
 void VM_SetTraceGlobals(const trace_t *trace)
 {
 
 void VM_SetTraceGlobals(const trace_t *trace)
 {

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_allsolid) = trace->allsolid;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_startsolid) = trace->startsolid;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_fraction) = trace->fraction;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_inwater) = trace->inwater;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_inopen) = trace->inopen;
-       VectorCopy(trace->endpos, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos));
-       VectorCopy(trace->plane.normal, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_plane_normal));
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_plane_dist) = trace->plane.dist;
-       PRVM_GLOBALFIELDEDICT(prog->globaloffsets.trace_ent) = PRVM_EDICT_TO_PROG(trace->ent ? trace->ent : prog->edicts);
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dpstartcontents) = trace->startsupercontents;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitcontents) = trace->hitsupercontents;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitq3surfaceflags) = trace->hitq3surfaceflags;
-       PRVM_GLOBALFIELDSTRING(prog->globaloffsets.trace_dphittexturename) = trace->hittexture ? PRVM_SetTempString(trace->hittexture->name) : 0;
+       PRVM_gameglobalfloat(trace_allsolid) = trace->allsolid;
+       PRVM_gameglobalfloat(trace_startsolid) = trace->startsolid;
+       PRVM_gameglobalfloat(trace_fraction) = trace->fraction;
+       PRVM_gameglobalfloat(trace_inwater) = trace->inwater;
+       PRVM_gameglobalfloat(trace_inopen) = trace->inopen;
+       VectorCopy(trace->endpos, PRVM_gameglobalvector(trace_endpos));
+       VectorCopy(trace->plane.normal, PRVM_gameglobalvector(trace_plane_normal));
+       PRVM_gameglobalfloat(trace_plane_dist) = trace->plane.dist;
+       PRVM_gameglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(trace->ent ? trace->ent : prog->edicts);
+       PRVM_gameglobalfloat(trace_dpstartcontents) = trace->startsupercontents;
+       PRVM_gameglobalfloat(trace_dphitcontents) = trace->hitsupercontents;
+       PRVM_gameglobalfloat(trace_dphitq3surfaceflags) = trace->hitq3surfaceflags;
+       PRVM_gameglobalstring(trace_dphittexturename) = trace->hittexture ? PRVM_SetTempString(trace->hittexture->name) : 0;

 }
 
 void VM_ClearTraceGlobals(void)
 {
        // clean up all trace globals when leaving the VM (anti-triggerbot safeguard)
 }
 
 void VM_ClearTraceGlobals(void)
 {
        // clean up all trace globals when leaving the VM (anti-triggerbot safeguard)

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_allsolid) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_startsolid) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_fraction) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_inwater) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_inopen) = 0;
-       VectorClear(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos));
-       VectorClear(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_plane_normal));
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_plane_dist) = 0;
-       PRVM_GLOBALFIELDEDICT(prog->globaloffsets.trace_ent) = PRVM_EDICT_TO_PROG(prog->edicts);
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dpstartcontents) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitcontents) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitq3surfaceflags) = 0;
-       PRVM_GLOBALFIELDSTRING(prog->globaloffsets.trace_dphittexturename) = 0;
+       PRVM_gameglobalfloat(trace_allsolid) = 0;
+       PRVM_gameglobalfloat(trace_startsolid) = 0;
+       PRVM_gameglobalfloat(trace_fraction) = 0;
+       PRVM_gameglobalfloat(trace_inwater) = 0;
+       PRVM_gameglobalfloat(trace_inopen) = 0;
+       VectorClear(PRVM_gameglobalvector(trace_endpos));
+       VectorClear(PRVM_gameglobalvector(trace_plane_normal));
+       PRVM_gameglobalfloat(trace_plane_dist) = 0;
+       PRVM_gameglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(prog->edicts);
+       PRVM_gameglobalfloat(trace_dpstartcontents) = 0;
+       PRVM_gameglobalfloat(trace_dphitcontents) = 0;
+       PRVM_gameglobalfloat(trace_dphitq3surfaceflags) = 0;
+       PRVM_gameglobalstring(trace_dphittexturename) = 0;

 }
 
 //=============
 }
 
 //=============


@@ -6546,7 +6518,7 @@ void animatemodel(dp_model_t *model, prvm_edict_t *ed)
        VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
        VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
        need |= (memcmp(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend))) != 0;
        VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
        VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
        need |= (memcmp(&animatemodel_cache.frameblend, &ed->priv.server->frameblend, sizeof(ed->priv.server->frameblend))) != 0;

-       skeletonindex = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.skeletonindex) - 1;
+       skeletonindex = (int)PRVM_gameedictfloat(ed, skeletonindex) - 1;

        if (!(skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones))
                skeleton = NULL;
        need |= (animatemodel_cache.skeleton_p != skeleton);
        if (!(skeletonindex >= 0 && skeletonindex < MAX_EDICTS && (skeleton = prog->skeletons[skeletonindex]) && skeleton->model->num_bones == ed->priv.server->skeleton.model->num_bones))
                skeleton = NULL;
        need |= (animatemodel_cache.skeleton_p != skeleton);

diff --git a/prvm_edict.c b/prvm_edict.c
index 7aa2dae0b2e493c7ef7b2eb4f6cc0692d976a230..85f8badf3d4ad116fd5647ba216d0fc38e741373 100644 (file)
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -1448,7 +1448,7 @@ void PRVM_ED_LoadFromFile (const char *data)
                if (prog->funcoffsets.SV_OnEntityPreSpawnFunction)
                {
                        // self = ent
                if (prog->funcoffsets.SV_OnEntityPreSpawnFunction)
                {
                        // self = ent

-                       PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self) = PRVM_EDICT_TO_PROG(ent);
+                       PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPreSpawnFunction, "QC function SV_OnEntityPreSpawnFunction is missing");
                }
 
                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPreSpawnFunction, "QC function SV_OnEntityPreSpawnFunction is missing");
                }
 


@@ -1462,10 +1462,8 @@ void PRVM_ED_LoadFromFile (const char *data)
 // immediately call spawn function, but only if there is a self global and a classname
 //
                if(!ent->priv.required->free)
 // immediately call spawn function, but only if there is a self global and a classname
 //
                if(!ent->priv.required->free)

-               if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0)

                {
                {

-                       string_t handle =  PRVM_EDICTFIELDSTRING(ent, prog->fieldoffsets.classname);
-                       if (!handle)
+                       if (!PRVM_alledictstring(ent, classname))

                        {
                                Con_Print("No classname for:\n");
                                PRVM_ED_Print(ent, NULL);
                        {
                                Con_Print("No classname for:\n");
                                PRVM_ED_Print(ent, NULL);


@@ -1474,10 +1472,10 @@ void PRVM_ED_LoadFromFile (const char *data)
                        }
 
                        // look for the spawn function
                        }
 
                        // look for the spawn function

-                       funcname = PRVM_GetString(handle);
+                       funcname = PRVM_GetString(PRVM_alledictstring(ent, classname));

                        func = PRVM_ED_FindFunction (va("spawnfunc_%s", funcname));
                        if(!func)
                        func = PRVM_ED_FindFunction (va("spawnfunc_%s", funcname));
                        if(!func)

-                               if(!PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.require_spawnfunc_prefix))
+                               if(!PRVM_allglobalfloat(require_spawnfunc_prefix))

                                        func = PRVM_ED_FindFunction (funcname);
 
                        if (!func)
                                        func = PRVM_ED_FindFunction (funcname);
 
                        if (!func)


@@ -1486,7 +1484,7 @@ void PRVM_ED_LoadFromFile (const char *data)
                                if (prog->funcoffsets.SV_OnEntityNoSpawnFunction)
                                {
                                        // self = ent
                                if (prog->funcoffsets.SV_OnEntityNoSpawnFunction)
                                {
                                        // self = ent

-                                       PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self) = PRVM_EDICT_TO_PROG(ent);
+                                       PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing");
                                }
                                else
                                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing");
                                }
                                else


@@ -1503,7 +1501,7 @@ void PRVM_ED_LoadFromFile (const char *data)
                        else
                        {
                                // self = ent
                        else
                        {
                                // self = ent

-                               PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self) = PRVM_EDICT_TO_PROG(ent);
+                               PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                                PRVM_ExecuteProgram (func - prog->functions, "");
                        }
                }
                                PRVM_ExecuteProgram (func - prog->functions, "");
                        }
                }


@@ -1512,7 +1510,7 @@ void PRVM_ED_LoadFromFile (const char *data)
                if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
                {
                        // self = ent
                if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
                {
                        // self = ent

-                       PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self) = PRVM_EDICT_TO_PROG(ent);
+                       PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
                }
 
                        PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
                }
 


@@ -1751,6 +1749,36 @@ void PRVM_FindOffsets(void)
        prog->globaloffsets.pmove_onground                = PRVM_ED_FindGlobalOffset("pmove_onground");
        prog->globaloffsets.pmove_inwater                 = PRVM_ED_FindGlobalOffset("pmove_inwater");
 
        prog->globaloffsets.pmove_onground                = PRVM_ED_FindGlobalOffset("pmove_onground");
        prog->globaloffsets.pmove_inwater                 = PRVM_ED_FindGlobalOffset("pmove_inwater");
 

+       prog->globaloffsets.particle_type                 = PRVM_ED_FindGlobalOffset("particle_type");
+       prog->globaloffsets.particle_blendmode            = PRVM_ED_FindGlobalOffset("particle_blendmode");
+       prog->globaloffsets.particle_orientation          = PRVM_ED_FindGlobalOffset("particle_orientation");
+       prog->globaloffsets.particle_color1               = PRVM_ED_FindGlobalOffset("particle_color1");
+       prog->globaloffsets.particle_color2               = PRVM_ED_FindGlobalOffset("particle_color2");
+       prog->globaloffsets.particle_tex                  = PRVM_ED_FindGlobalOffset("particle_tex");
+       prog->globaloffsets.particle_size                 = PRVM_ED_FindGlobalOffset("particle_size");
+       prog->globaloffsets.particle_sizeincrease         = PRVM_ED_FindGlobalOffset("particle_sizeincrease");
+       prog->globaloffsets.particle_alpha                = PRVM_ED_FindGlobalOffset("particle_alpha");
+       prog->globaloffsets.particle_alphafade            = PRVM_ED_FindGlobalOffset("particle_alphafade");
+       prog->globaloffsets.particle_time                 = PRVM_ED_FindGlobalOffset("particle_time");
+       prog->globaloffsets.particle_gravity              = PRVM_ED_FindGlobalOffset("particle_gravity");
+       prog->globaloffsets.particle_bounce               = PRVM_ED_FindGlobalOffset("particle_bounce");
+       prog->globaloffsets.particle_airfriction          = PRVM_ED_FindGlobalOffset("particle_airfriction");
+       prog->globaloffsets.particle_liquidfriction       = PRVM_ED_FindGlobalOffset("particle_liquidfriction");
+       prog->globaloffsets.particle_originjitter         = PRVM_ED_FindGlobalOffset("particle_originjitter");
+       prog->globaloffsets.particle_velocityjitter       = PRVM_ED_FindGlobalOffset("particle_velocityjitter");
+       prog->globaloffsets.particle_qualityreduction     = PRVM_ED_FindGlobalOffset("particle_qualityreduction");
+       prog->globaloffsets.particle_stretch              = PRVM_ED_FindGlobalOffset("particle_stretch");
+       prog->globaloffsets.particle_staincolor1          = PRVM_ED_FindGlobalOffset("particle_staincolor1");
+       prog->globaloffsets.particle_staincolor2          = PRVM_ED_FindGlobalOffset("particle_staincolor2");
+       prog->globaloffsets.particle_stainalpha           = PRVM_ED_FindGlobalOffset("particle_stainalpha");
+       prog->globaloffsets.particle_stainsize            = PRVM_ED_FindGlobalOffset("particle_stainsize");
+       prog->globaloffsets.particle_staintex             = PRVM_ED_FindGlobalOffset("particle_staintex");
+       prog->globaloffsets.particle_staintex             = PRVM_ED_FindGlobalOffset("particle_staintex");
+       prog->globaloffsets.particle_delayspawn           = PRVM_ED_FindGlobalOffset("particle_delayspawn");
+       prog->globaloffsets.particle_delaycollision       = PRVM_ED_FindGlobalOffset("particle_delaycollision");
+       prog->globaloffsets.particle_angle                = PRVM_ED_FindGlobalOffset("particle_angle");
+       prog->globaloffsets.particle_spin                 = PRVM_ED_FindGlobalOffset("particle_spin");
+

        // menu qc only uses some functions, nothing else
        prog->funcoffsets.m_draw                          = PRVM_ED_FindFunctionOffset("m_draw");
        prog->funcoffsets.m_init                          = PRVM_ED_FindFunctionOffset("m_init");
        // menu qc only uses some functions, nothing else
        prog->funcoffsets.m_draw                          = PRVM_ED_FindFunctionOffset("m_draw");
        prog->funcoffsets.m_init                          = PRVM_ED_FindFunctionOffset("m_init");

diff --git a/prvm_exec.c b/prvm_exec.c
index d53b2139f3162fd6af983daa8779445ad04538b7..c958a31175e4f2c48f2f65174f239aca0689b03c 100644 (file)
--- a/prvm_exec.c
+++ b/prvm_exec.c
@@ -694,8 +694,8 @@ void MVM_ExecuteProgram (func_t fnum, const char *errormessage)
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {

-               if (prog->globaloffsets.self >= 0 && PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self))
-                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self)), NULL);
+               if (PRVM_allglobaledict(self))
+                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self)), NULL);

                PRVM_ERROR ("MVM_ExecuteProgram: %s", errormessage);
        }
 
                PRVM_ERROR ("MVM_ExecuteProgram: %s", errormessage);
        }
 


@@ -783,8 +783,8 @@ void CLVM_ExecuteProgram (func_t fnum, const char *errormessage)
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {

-               if (prog->globaloffsets.self >= 0 && PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self))
-                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self)), NULL);
+               if (PRVM_allglobaledict(self))
+                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self)), NULL);

                PRVM_ERROR ("CLVM_ExecuteProgram: %s", errormessage);
        }
 
                PRVM_ERROR ("CLVM_ExecuteProgram: %s", errormessage);
        }
 


@@ -873,8 +873,8 @@ void SVVM_ExecuteProgram (func_t fnum, const char *errormessage)
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {
 
        if (!fnum || fnum >= (unsigned int)prog->numfunctions)
        {

-               if (prog->globaloffsets.self >= 0 && PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self))
-                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self)), NULL);
+               if (PRVM_allglobaledict(self))
+                       PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self)), NULL);

                PRVM_ERROR ("SVVM_ExecuteProgram: %s", errormessage);
        }
 
                PRVM_ERROR ("SVVM_ExecuteProgram: %s", errormessage);
        }
 

diff --git a/prvm_execprogram.h b/prvm_execprogram.h
index 447ee784702642c9dd9db195370bb7e58200c92e..4d872f64bf4e72c09d0afba93c0910e6b24aa488 100644 (file)
--- a/prvm_execprogram.h
+++ b/prvm_execprogram.h
@@ -391,10 +391,10 @@
                        case OP_STATE:
                                if(prog->flag & PRVM_OP_STATE)
                                {
                        case OP_STATE:
                                if(prog->flag & PRVM_OP_STATE)
                                {

-                                       ed = PRVM_PROG_TO_EDICT(PRVM_GLOBALFIELDEDICT(prog->globaloffsets.self));
-                                       PRVM_EDICTFIELDFLOAT(ed,prog->fieldoffsets.nextthink) = PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.time) + 0.1;
-                                       PRVM_EDICTFIELDFLOAT(ed,prog->fieldoffsets.frame) = OPA->_float;
-                                       PRVM_EDICTFIELDFUNCTION(ed,prog->fieldoffsets.think) = OPB->function;
+                                       ed = PRVM_PROG_TO_EDICT(PRVM_gameglobaledict(self));
+                                       PRVM_gameedictfloat(ed,nextthink) = PRVM_gameglobalfloat(time) + 0.1;
+                                       PRVM_gameedictfloat(ed,frame) = OPA->_float;
+                                       PRVM_gameedictfunction(ed,think) = OPB->function;

                                }
                                else
                                {
                                }
                                else
                                {

diff --git a/sv_demo.c b/sv_demo.c
index 8f299395ff8a9152a7e1a8e1d8c7b2b0d46609a7..c237f2f43a4b649189779509c179fe6cca596306 100644 (file)
--- a/sv_demo.c
+++ b/sv_demo.c
@@ -16,7 +16,7 @@ void SV_StartDemoRecording(client_t *client, const char *filename, int forcetrac
        Con_Printf("Recording demo for # %d (%s) to %s\n", PRVM_NUM_FOR_EDICT(client->edict), client->netaddress, name);
 
        // Reset discardable flag for every new demo.
        Con_Printf("Recording demo for # %d (%s) to %s\n", PRVM_NUM_FOR_EDICT(client->edict), client->netaddress, name);
 
        // Reset discardable flag for every new demo.

-       PRVM_EDICTFIELDFLOAT(client->edict, prog->fieldoffsets.discardabledemo) = 0;
+       PRVM_serveredictfloat(client->edict, discardabledemo) = 0;

 
        client->sv_demo_file = FS_OpenRealFile(name, "wb", false);
        if(!client->sv_demo_file)
 
        client->sv_demo_file = FS_OpenRealFile(name, "wb", false);
        if(!client->sv_demo_file)


@@ -64,7 +64,7 @@ void SV_StopDemoRecording(client_t *client)
        MSG_WriteByte(&buf, svc_disconnect);
        SV_WriteDemoMessage(client, &buf, false);
 
        MSG_WriteByte(&buf, svc_disconnect);
        SV_WriteDemoMessage(client, &buf, false);
 

-       if (sv_autodemo_perclient_discardable.integer && PRVM_EDICTFIELDFLOAT(client->edict, prog->fieldoffsets.discardabledemo))
+       if (sv_autodemo_perclient_discardable.integer && PRVM_serveredictfloat(client->edict, discardabledemo))

        {
                FS_RemoveOnClose(client->sv_demo_file);
                Con_Printf("Stopped recording discardable demo for # %d (%s)\n", PRVM_NUM_FOR_EDICT(client->edict), client->netaddress);
        {
                FS_RemoveOnClose(client->sv_demo_file);
                Con_Printf("Stopped recording discardable demo for # %d (%s)\n", PRVM_NUM_FOR_EDICT(client->edict), client->netaddress);

diff --git a/sv_main.c b/sv_main.c
index ec93e2468c1f06ad88cd52121a010da623d7ac55..95b1559618c1fb02041d6288251026d32ca4bd00 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -249,195 +249,163 @@ static const char *standardeffectnames[EFFECT_TOTAL] =
 
 prvm_required_field_t sv_reqfields[] =
 {
 
 prvm_required_field_t sv_reqfields[] =
 {

-       {ev_entity, "aiment"},
-       {ev_entity, "chain"},
-       {ev_entity, "clientcamera"},
-       {ev_entity, "cursor_trace_ent"},
-       {ev_entity, "drawonlytoclient"},
-       {ev_entity, "enemy"},
-       {ev_entity, "exteriormodeltoclient"},
-       {ev_entity, "groundentity"},
-       {ev_entity, "nodrawtoclient"},
-       {ev_entity, "tag_entity"},
-       {ev_entity, "viewmodelforclient"},
-       {ev_float, "SendFlags"},
-       {ev_float, "Version"},
-       {ev_float, "alpha"},
-       {ev_float, "ammo_cells1"},
-       {ev_float, "ammo_lava_nails"},
-       {ev_float, "ammo_multi_rockets"},
-       {ev_float, "ammo_nails1"},
-       {ev_float, "ammo_plasma"},
-       {ev_float, "ammo_rockets1"},
-       {ev_float, "ammo_shells1"},
-       {ev_float, "bouncefactor"},
-       {ev_float, "bouncestop"},
-       {ev_float, "button3"},
-       {ev_float, "button4"},
-       {ev_float, "button5"},
-       {ev_float, "button6"},
-       {ev_float, "button7"},
-       {ev_float, "button8"},
-       {ev_float, "button9"},
-       {ev_float, "button10"},
-       {ev_float, "button11"},
-       {ev_float, "button12"},
-       {ev_float, "button13"},
-       {ev_float, "button14"},
-       {ev_float, "button15"},
-       {ev_float, "button16"},
-       {ev_float, "buttonchat"},
-       {ev_float, "buttonuse"},
-       {ev_float, "clientcolors"},
-       {ev_float, "color"},
-       {ev_float, "colormod"},
-       {ev_float, "cursor_active"},
-       {ev_float, "cursor_screen"},
-       {ev_float, "cursor_trace_endpos"},
-       {ev_float, "cursor_trace_start"},
-       {ev_float, "dimension_hit"},
-       {ev_float, "dimension_solid"},
-       {ev_float, "disableclientprediction"},
-       {ev_float, "discardabledemo"},
-       {ev_float, "dphitcontentsmask"},
-       {ev_float, "fatness"},
-       {ev_float, "forceshader"},
-       {ev_float, "frame"},
-       {ev_float, "frame1time"},
-       {ev_float, "frame2"},
-       {ev_float, "frame2time"},
-       {ev_float, "frame3"},
-       {ev_float, "frame3time"},
-       {ev_float, "frame4"},
-       {ev_float, "frame4time"},
-       {ev_float, "fullbright"},
-       {ev_float, "glow_color"},
-       {ev_float, "glow_size"},
-       {ev_float, "glow_trail"},
-       {ev_float, "gravity"},
-       {ev_float, "hull"},
-       {ev_float, "ideal_yaw"},
-       {ev_float, "idealpitch"},
-       {ev_float, "items2"},
-       {ev_float, "jointtype"},
-       {ev_float, "lerpfrac"},
-       {ev_float, "lerpfrac3"},
-       {ev_float, "lerpfrac4"},
-       {ev_float, "light_lev"},
-       {ev_float, "mass"},
-       {ev_float, "modelflags"},
-       {ev_float, "modelindex"},
-       {ev_float, "movetype"},
-       {ev_float, "nextthink"},
-       {ev_float, "packetloss"},
-       {ev_float, "pflags"},
-       {ev_float, "ping"},
-       {ev_float, "ping_packetloss"},
-       {ev_float, "ping_movementloss"},
-       {ev_float, "pitch_speed"},
-       {ev_float, "pmodel"},
-       {ev_float, "renderamt"},
-       {ev_float, "renderflags"},
-       {ev_float, "rendermode"},
-       {ev_float, "scale"},
-       {ev_float, "sendcomplexanimation"},
-       {ev_float, "shadertime"},
-       {ev_float, "skeletonindex"},
-       {ev_float, "solid"},
-       {ev_float, "style"},
-       {ev_float, "tag_index"},
-       {ev_float, "think"},
-       {ev_float, "userwavefunc_param0"},
-       {ev_float, "userwavefunc_param1"},
-       {ev_float, "userwavefunc_param2"},
-       {ev_float, "userwavefunc_param3"},
-       {ev_float, "viewzoom"},
-       {ev_float, "yaw_speed"},
-       {ev_function, "SendEntity"},
-       {ev_function, "camera_transform"},
-       {ev_function, "contentstransition"},
-       {ev_function, "customizeentityforclient"},
-       {ev_function, "movetypesteplandevent"},
-       {ev_string, "classname"},
-       {ev_string, "clientstatus"},
-       {ev_string, "crypto_encryptmethod"},
-       {ev_string, "crypto_idfp"},
-       {ev_string, "crypto_keyfp"},
-       {ev_string, "crypto_mykeyfp"},
-       {ev_string, "crypto_signmethod"},
-       {ev_string, "message"},
-       {ev_string, "netaddress"},
-       {ev_string, "playermodel"},
-       {ev_string, "playerskin"},
-       {ev_vector, "angles"},
-       {ev_vector, "angles"},
-       {ev_vector, "avelocity"},
-//     {ev_vector, "axis_forward"},
-//     {ev_vector, "axis_left"},
-//     {ev_vector, "axis_up"},
-       {ev_vector, "glowmod"},
-       {ev_vector, "maxs"},
-       {ev_vector, "mins"},
-       {ev_vector, "movedir"},
-       {ev_vector, "movement"},
-       {ev_vector, "origin"},
-       {ev_vector, "punchvector"},
-//     {ev_vector, "spinvelocity"},
-       {ev_vector, "velocity"},
+       {ev_entity, "aiment"}, // server field
+       {ev_entity, "clientcamera"}, // server field
+       {ev_entity, "cursor_trace_ent"}, // server field
+       {ev_entity, "drawonlytoclient"}, // server field
+       {ev_entity, "enemy"}, // server field
+       {ev_entity, "exteriormodeltoclient"}, // server field
+       {ev_entity, "nodrawtoclient"}, // server field
+       {ev_entity, "tag_entity"}, // server field
+       {ev_entity, "viewmodelforclient"}, // server field
+       {ev_float, "SendFlags"}, // server field
+       {ev_float, "Version"}, // server field
+       {ev_float, "alpha"}, // server field
+       {ev_float, "ammo_cells1"}, // server field
+       {ev_float, "ammo_lava_nails"}, // server field
+       {ev_float, "ammo_multi_rockets"}, // server field
+       {ev_float, "ammo_nails1"}, // server field
+       {ev_float, "ammo_plasma"}, // server field
+       {ev_float, "ammo_rockets1"}, // server field
+       {ev_float, "ammo_shells1"}, // server field
+       {ev_float, "bouncefactor"}, // server field
+       {ev_float, "bouncestop"}, // server field
+       {ev_float, "button3"}, // server field
+       {ev_float, "button4"}, // server field
+       {ev_float, "button5"}, // server field
+       {ev_float, "button6"}, // server field
+       {ev_float, "button7"}, // server field
+       {ev_float, "button8"}, // server field
+       {ev_float, "button9"}, // server field
+       {ev_float, "button10"}, // server field
+       {ev_float, "button11"}, // server field
+       {ev_float, "button12"}, // server field
+       {ev_float, "button13"}, // server field
+       {ev_float, "button14"}, // server field
+       {ev_float, "button15"}, // server field
+       {ev_float, "button16"}, // server field
+       {ev_float, "buttonchat"}, // server field
+       {ev_float, "buttonuse"}, // server field
+       {ev_float, "clientcolors"}, // server field
+       {ev_float, "cursor_active"}, // server field
+       {ev_float, "disableclientprediction"}, // server field
+       {ev_float, "discardabledemo"}, // server field
+       {ev_float, "dphitcontentsmask"}, // server field
+       {ev_float, "frame1time"}, // server field
+       {ev_float, "frame1time"}, // server field
+       {ev_float, "frame2time"}, // server field
+       {ev_float, "frame2time"}, // server field
+       {ev_float, "frame2"}, // server field
+       {ev_float, "frame2"}, // server field
+       {ev_float, "frame3time"}, // server field
+       {ev_float, "frame3time"}, // server field
+       {ev_float, "frame3"}, // server field
+       {ev_float, "frame3"}, // server field
+       {ev_float, "frame4time"}, // server field
+       {ev_float, "frame4time"}, // server field
+       {ev_float, "frame4"}, // server field
+       {ev_float, "frame4"}, // server field
+       {ev_float, "frame"}, // server field
+       {ev_float, "fullbright"}, // server field
+       {ev_float, "glow_color"}, // server field
+       {ev_float, "glow_size"}, // server field
+       {ev_float, "glow_trail"}, // server field
+       {ev_float, "gravity"}, // server field
+       {ev_float, "gravity"}, // server field
+       {ev_float, "ideal_yaw"}, // server field
+       {ev_float, "idealpitch"}, // server field
+       {ev_float, "items2"}, // server field
+       {ev_float, "jointtype"}, // server field
+       {ev_float, "lerpfrac3"}, // server field
+       {ev_float, "lerpfrac3"}, // server field
+       {ev_float, "lerpfrac4"}, // server field
+       {ev_float, "lerpfrac4"}, // server field
+       {ev_float, "lerpfrac"}, // server field
+       {ev_float, "lerpfrac"}, // server field
+       {ev_float, "light_lev"}, // server field
+       {ev_float, "mass"}, // server field
+       {ev_float, "modelflags"}, // server field
+       {ev_float, "modelindex"}, // server field
+       {ev_float, "movetype"}, // server field
+       {ev_float, "pflags"}, // server field
+       {ev_float, "ping_movementloss"}, // server field
+       {ev_float, "ping_packetloss"}, // server field
+       {ev_float, "ping"}, // server field
+       {ev_float, "pitch_speed"}, // server field
+       {ev_float, "pmodel"}, // server field
+       {ev_float, "renderamt"}, // server field
+       {ev_float, "scale"}, // server field
+       {ev_float, "scale"}, // server field
+       {ev_float, "sendcomplexanimation"}, // server field
+       {ev_float, "skeletonindex"}, // server field
+       {ev_float, "skeletonindex"}, // server field
+       {ev_float, "solid"}, // server field
+       {ev_float, "style"}, // server field
+       {ev_float, "tag_index"}, // server field
+       {ev_float, "viewzoom"}, // server field
+       {ev_float, "yaw_speed"}, // server field
+       {ev_function, "SendEntity"}, // server field
+       {ev_function, "camera_transform"}, // server field
+       {ev_function, "contentstransition"}, // server field
+       {ev_function, "customizeentityforclient"}, // server field
+       {ev_function, "movetypesteplandevent"}, // server field
+       {ev_string, "classname"}, // server field
+       {ev_string, "clientstatus"}, // server field
+       {ev_string, "crypto_encryptmethod"}, // server field
+       {ev_string, "crypto_idfp"}, // server field
+       {ev_string, "crypto_keyfp"}, // server field
+       {ev_string, "crypto_mykeyfp"}, // server field
+       {ev_string, "crypto_signmethod"}, // server field
+       {ev_string, "netaddress"}, // server field
+       {ev_string, "playermodel"}, // server field
+       {ev_string, "playerskin"}, // server field
+       {ev_vector, "angles"}, // server field
+       {ev_vector, "avelocity"}, // server field
+       {ev_vector, "colormod"}, // server field
+       {ev_vector, "color"}, // server field
+       {ev_vector, "cursor_screen"}, // server field
+       {ev_vector, "cursor_trace_endpos"}, // server field
+       {ev_vector, "cursor_trace_start"}, // server field
+       {ev_vector, "glowmod"}, // server field
+       {ev_vector, "maxs"}, // server field
+       {ev_vector, "mins"}, // server field
+       {ev_vector, "movedir"}, // server field
+       {ev_vector, "movement"}, // server field
+       {ev_vector, "origin"}, // server field
+       {ev_vector, "punchvector"}, // server field
+       {ev_vector, "velocity"}, // server field

 };
 
 #define SV_REQGLOBALS (sizeof(sv_reqglobals) / sizeof(prvm_required_field_t))
 
 prvm_required_field_t sv_reqglobals[] =
 {
 };
 
 #define SV_REQGLOBALS (sizeof(sv_reqglobals) / sizeof(prvm_required_field_t))
 
 prvm_required_field_t sv_reqglobals[] =
 {

-       {ev_entity, "self"},
-       {ev_entity, "trace_ent"},
-       {ev_entity, "trace_networkentity"},
-       {ev_float, "coop"},
-       {ev_float, "deathmatch"},
-       {ev_float, "dmg_save"},
-       {ev_float, "dmg_take"},
-       {ev_float, "drawfont"},
-       {ev_float, "drawfontscale"},
-       {ev_float, "gettaginfo_parent"},
-       {ev_float, "intermission"},
-       {ev_float, "particles_alphamax"},
-       {ev_float, "particles_alphamin"},
-       {ev_float, "require_spawnfunc_prefix"},
-       {ev_float, "sb_showscores"},
-       {ev_float, "serverdeltatime"},
-       {ev_float, "serverprevtime"},
-       {ev_float, "servertime"},
-       {ev_float, "time"},
-       {ev_float, "trace_allsolid"},
-       {ev_float, "trace_dphitcontents"},
-       {ev_float, "trace_dphitq3surfaceflags"},
-       {ev_float, "trace_dpstartcontents"},
-       {ev_float, "trace_fraction"},
-       {ev_float, "trace_inopen"},
-       {ev_float, "trace_inwater"},
-       {ev_float, "trace_plane_dist"},
-       {ev_float, "trace_startsolid"},
-       {ev_float, "transparent_offset"},
-       {ev_string, "SV_InitCmd"},
-       {ev_string, "gettaginfo_name"},
-       {ev_string, "trace_dphittexturename"},
-       {ev_string, "worldstatus"},
-       {ev_vector, "dmg_origin"},
-       {ev_vector, "gettaginfo_forward"},
-       {ev_vector, "gettaginfo_offset"},
-       {ev_vector, "gettaginfo_right"},
-       {ev_vector, "gettaginfo_up"},
-       {ev_vector, "particles_colormax"},
-       {ev_vector, "particles_colormin"},
-       {ev_vector, "trace_endpos"},
-       {ev_vector, "trace_plane_normal"},
-       {ev_vector, "v_forward"},
-       {ev_vector, "v_right"},
-       {ev_vector, "v_up"},
-       {ev_vector, "view_angles"},
-       {ev_vector, "view_punchangle"},
-       {ev_vector, "view_punchvector"},
+       {ev_entity, "self"}, // server global
+       {ev_entity, "trace_ent"}, // server global
+       {ev_float, "gettaginfo_parent"}, // server global
+       {ev_float, "require_spawnfunc_prefix"}, // server global
+       {ev_float, "trace_allsolid"}, // server global
+       {ev_float, "trace_dphitcontents"}, // server global
+       {ev_float, "trace_dphitq3surfaceflags"}, // server global
+       {ev_float, "trace_dpstartcontents"}, // server global
+       {ev_float, "trace_fraction"}, // server global
+       {ev_float, "trace_inopen"}, // server global
+       {ev_float, "trace_inwater"}, // server global
+       {ev_float, "trace_plane_dist"}, // server global
+       {ev_float, "trace_startsolid"}, // server global
+       {ev_string, "SV_InitCmd"}, // server global
+       {ev_string, "gettaginfo_name"}, // server global
+       {ev_string, "trace_dphittexturename"}, // server global
+       {ev_string, "worldstatus"}, // server global
+       {ev_vector, "gettaginfo_forward"}, // server global
+       {ev_vector, "gettaginfo_offset"}, // server global
+       {ev_vector, "gettaginfo_right"}, // server global
+       {ev_vector, "gettaginfo_up"}, // server global
+       {ev_vector, "trace_endpos"}, // server global
+       {ev_vector, "trace_plane_normal"}, // server global
+       {ev_vector, "v_forward"}, // server global
+       {ev_vector, "v_right"}, // server global
+       {ev_vector, "v_up"}, // server global

 };
 
 
 };
 
 


@@ -972,10 +940,10 @@ void SV_SendServerinfo (client_t *client)
                }
 
                //[515]: init stufftext string (it is sent before svc_serverinfo)
                }
 
                //[515]: init stufftext string (it is sent before svc_serverinfo)

-               if (PRVM_GetString(PRVM_GLOBALFIELDSTRING(prog->globaloffsets.SV_InitCmd)))
+               if (PRVM_GetString(PRVM_serverglobalstring(SV_InitCmd)))

                {
                        MSG_WriteByte (&client->netconnection->message, svc_stufftext);
                {
                        MSG_WriteByte (&client->netconnection->message, svc_stufftext);

-                       MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(PRVM_GLOBALFIELDSTRING(prog->globaloffsets.SV_InitCmd))));
+                       MSG_WriteString (&client->netconnection->message, va("%s\n", PRVM_GetString(PRVM_serverglobalstring(SV_InitCmd))));

                }
        }
 
                }
        }
 


@@ -1162,7 +1130,7 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
 
        // fast path for games that do not use legacy entity networking
        // note: still networks clients even if they are legacy
 
        // fast path for games that do not use legacy entity networking
        // note: still networks clients even if they are legacy

-       sendentity = PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.SendEntity);
+       sendentity = PRVM_serveredictfunction(ent, SendEntity);

        if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
                return false;
 
        if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
                return false;
 


@@ -1182,24 +1150,24 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model) && sv.models[i]) ? i : 0;
 
        flags = 0;
        modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model) && sv.models[i]) ? i : 0;
 
        flags = 0;

-       i = (int)(PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.glow_size) * 0.25f);
+       i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);

        glowsize = (unsigned char)bound(0, i, 255);
        glowsize = (unsigned char)bound(0, i, 255);

-       if (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.glow_trail))
+       if (PRVM_serveredictfloat(ent, glow_trail))

                flags |= RENDER_GLOWTRAIL;
                flags |= RENDER_GLOWTRAIL;

-       if (PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.viewmodelforclient))
+       if (PRVM_serveredictedict(ent, viewmodelforclient))

                flags |= RENDER_VIEWMODEL;
 
                flags |= RENDER_VIEWMODEL;
 

-       v = PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.color);
+       v = PRVM_serveredictvector(ent, color);

        f = v[0]*256;
        light[0] = (unsigned short)bound(0, f, 65535);
        f = v[1]*256;
        light[1] = (unsigned short)bound(0, f, 65535);
        f = v[2]*256;
        light[2] = (unsigned short)bound(0, f, 65535);
        f = v[0]*256;
        light[0] = (unsigned short)bound(0, f, 65535);
        f = v[1]*256;
        light[1] = (unsigned short)bound(0, f, 65535);
        f = v[2]*256;
        light[2] = (unsigned short)bound(0, f, 65535);

-       f = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.light_lev);
+       f = PRVM_serveredictfloat(ent, light_lev);

        light[3] = (unsigned short)bound(0, f, 65535);
        light[3] = (unsigned short)bound(0, f, 65535);

-       lightstyle = (unsigned char)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.style);
-       lightpflags = (unsigned char)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.pflags);
+       lightstyle = (unsigned char)PRVM_serveredictfloat(ent, style);
+       lightpflags = (unsigned char)PRVM_serveredictfloat(ent, pflags);

 
        if (gamemode == GAME_TENEBRAE)
        {
 
        if (gamemode == GAME_TENEBRAE)
        {


@@ -1250,7 +1218,7 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
 
        // early culling checks
        // (final culling is done by SV_MarkWriteEntityStateToClient)
 
        // early culling checks
        // (final culling is done by SV_MarkWriteEntityStateToClient)

-       customizeentityforclient = PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.customizeentityforclient);
+       customizeentityforclient = PRVM_serveredictfunction(ent, customizeentityforclient);

        if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
                return false;
 
        if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
                return false;
 


@@ -1265,18 +1233,18 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        cs->modelindex = modelindex;
        cs->skin = (unsigned)ent->fields.server->skin;
        cs->frame = (unsigned)ent->fields.server->frame;
        cs->modelindex = modelindex;
        cs->skin = (unsigned)ent->fields.server->skin;
        cs->frame = (unsigned)ent->fields.server->frame;

-       cs->viewmodelforclient = PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.viewmodelforclient);
-       cs->exteriormodelforclient = PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.exteriormodeltoclient);
-       cs->nodrawtoclient = PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.nodrawtoclient);
-       cs->drawonlytoclient = PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.drawonlytoclient);
+       cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
+       cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
+       cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);
+       cs->drawonlytoclient = PRVM_serveredictedict(ent, drawonlytoclient);

        cs->customizeentityforclient = customizeentityforclient;
        cs->customizeentityforclient = customizeentityforclient;

-       cs->tagentity = PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.tag_entity);
-       cs->tagindex = (unsigned char)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.tag_index);
+       cs->tagentity = PRVM_serveredictedict(ent, tag_entity);
+       cs->tagindex = (unsigned char)PRVM_serveredictfloat(ent, tag_index);

        cs->glowsize = glowsize;
 
        // don't need to init cs->colormod because the defaultstate did that for us
        //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
        cs->glowsize = glowsize;
 
        // don't need to init cs->colormod because the defaultstate did that for us
        //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;

-       v = PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.colormod);
+       v = PRVM_serveredictvector(ent, colormod);

        if (VectorLength2(v))
        {
                i = (int)(v[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
        if (VectorLength2(v))
        {
                i = (int)(v[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);


@@ -1286,7 +1254,7 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
 
        // don't need to init cs->glowmod because the defaultstate did that for us
        //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;
 
        // don't need to init cs->glowmod because the defaultstate did that for us
        //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;

-       v = PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.glowmod);
+       v = PRVM_serveredictvector(ent, glowmod);

        if (VectorLength2(v))
        {
                i = (int)(v[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
        if (VectorLength2(v))
        {
                i = (int)(v[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);


@@ -1297,14 +1265,14 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        cs->modelindex = modelindex;
 
        cs->alpha = 255;
        cs->modelindex = modelindex;
 
        cs->alpha = 255;

-       f = (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.alpha) * 255.0f);
+       f = (PRVM_serveredictfloat(ent, alpha) * 255.0f);

        if (f)
        {
                i = (int)f;
                cs->alpha = (unsigned char)bound(0, i, 255);
        }
        // halflife
        if (f)
        {
                i = (int)f;
                cs->alpha = (unsigned char)bound(0, i, 255);
        }
        // halflife

-       f = (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.renderamt));
+       f = (PRVM_serveredictfloat(ent, renderamt));

        if (f)
        {
                i = (int)f;
        if (f)
        {
                i = (int)f;


@@ -1312,7 +1280,7 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        }
 
        cs->scale = 16;
        }
 
        cs->scale = 16;

-       f = (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.scale) * 16.0f);
+       f = (PRVM_serveredictfloat(ent, scale) * 16.0f);

        if (f)
        {
                i = (int)f;
        if (f)
        {
                i = (int)f;


@@ -1320,14 +1288,14 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        }
 
        cs->glowcolor = 254;
        }
 
        cs->glowcolor = 254;

-       f = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.glow_color);
+       f = PRVM_serveredictfloat(ent, glow_color);

        if (f)
                cs->glowcolor = (int)f;
 
        if (f)
                cs->glowcolor = (int)f;
 

-       if (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.fullbright))
+       if (PRVM_serveredictfloat(ent, fullbright))

                cs->effects |= EF_FULLBRIGHT;
 
                cs->effects |= EF_FULLBRIGHT;
 

-       f = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.modelflags);
+       f = PRVM_serveredictfloat(ent, modelflags);

        if (f)
                cs->effects |= ((unsigned int)f & 0xff) << 24;
 
        if (f)
                cs->effects |= ((unsigned int)f & 0xff) << 24;
 


@@ -1340,22 +1308,22 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        if (cs->viewmodelforclient)
                cs->flags |= RENDER_VIEWMODEL; // show relative to the view
 
        if (cs->viewmodelforclient)
                cs->flags |= RENDER_VIEWMODEL; // show relative to the view
 

-       if (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.sendcomplexanimation))
+       if (PRVM_serveredictfloat(ent, sendcomplexanimation))

        {
                cs->flags |= RENDER_COMPLEXANIMATION;
        {
                cs->flags |= RENDER_COMPLEXANIMATION;

-               if (PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.skeletonindex) >= 1)
+               if (PRVM_serveredictfloat(ent, skeletonindex) >= 1)

                        cs->skeletonobject = ent->priv.server->skeleton;
                        cs->skeletonobject = ent->priv.server->skeleton;

-               cs->framegroupblend[0].frame = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame);
-               cs->framegroupblend[1].frame = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame2);
-               cs->framegroupblend[2].frame = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame3);
-               cs->framegroupblend[3].frame = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame4);
-               cs->framegroupblend[0].start = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame1time);
-               cs->framegroupblend[1].start = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame2time);
-               cs->framegroupblend[2].start = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame3time);
-               cs->framegroupblend[3].start = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.frame4time);
-               cs->framegroupblend[1].lerp = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.lerpfrac);
-               cs->framegroupblend[2].lerp = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.lerpfrac3);
-               cs->framegroupblend[3].lerp = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.lerpfrac4);
+               cs->framegroupblend[0].frame = PRVM_serveredictfloat(ent, frame);
+               cs->framegroupblend[1].frame = PRVM_serveredictfloat(ent, frame2);
+               cs->framegroupblend[2].frame = PRVM_serveredictfloat(ent, frame3);
+               cs->framegroupblend[3].frame = PRVM_serveredictfloat(ent, frame4);
+               cs->framegroupblend[0].start = PRVM_serveredictfloat(ent, frame1time);
+               cs->framegroupblend[1].start = PRVM_serveredictfloat(ent, frame2time);
+               cs->framegroupblend[2].start = PRVM_serveredictfloat(ent, frame3time);
+               cs->framegroupblend[3].start = PRVM_serveredictfloat(ent, frame4time);
+               cs->framegroupblend[1].lerp = PRVM_serveredictfloat(ent, lerpfrac);
+               cs->framegroupblend[2].lerp = PRVM_serveredictfloat(ent, lerpfrac3);
+               cs->framegroupblend[3].lerp = PRVM_serveredictfloat(ent, lerpfrac4);

                cs->framegroupblend[0].lerp = 1.0f - cs->framegroupblend[1].lerp - cs->framegroupblend[2].lerp - cs->framegroupblend[3].lerp;
        }
 
                cs->framegroupblend[0].lerp = 1.0f - cs->framegroupblend[1].lerp - cs->framegroupblend[2].lerp - cs->framegroupblend[3].lerp;
        }
 


@@ -1432,10 +1400,10 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        // (to let the QC know that they've been read)
        if (sendentity)
        {
        // (to let the QC know that they've been read)
        if (sendentity)
        {

-               sendflags = (unsigned int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.SendFlags);
-               PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.SendFlags) = 0;
+               sendflags = (unsigned int)PRVM_serveredictfloat(ent, SendFlags);
+               PRVM_serveredictfloat(ent, SendFlags) = 0;

                // legacy self.Version system
                // legacy self.Version system

-               if ((version = (unsigned int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.Version)))
+               if ((version = (unsigned int)PRVM_serveredictfloat(ent, Version)))

                {
                        if (sv.csqcentityversion[enumber] != version)
                                sendflags = 0xFFFFFF;
                {
                        if (sv.csqcentityversion[enumber] != version)
                                sendflags = 0xFFFFFF;


@@ -1538,7 +1506,7 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
                if (!model || !model->brush.TraceLineOfSight)
                        continue;
                // skip obviously transparent entities
                if (!model || !model->brush.TraceLineOfSight)
                        continue;
                // skip obviously transparent entities

-               alpha = PRVM_EDICTFIELDFLOAT(touch, prog->fieldoffsets.alpha);
+               alpha = PRVM_serveredictfloat(touch, alpha);

                if (alpha && alpha < 1)
                        continue;
                if ((int)touch->fields.server->effects & EF_ADDITIVE)
                if (alpha && alpha < 1)
                        continue;
                if ((int)touch->fields.server->effects & EF_ADDITIVE)


@@ -1725,9 +1693,6 @@ void SV_AddCameraEyes(void)
        int n_cameras = 0;
        vec3_t mi, ma;
 
        int n_cameras = 0;
        vec3_t mi, ma;
 

-       if(!prog->fieldoffsets.camera_transform)
-               return;
-

        for(i = 0; i < sv.writeentitiestoclient_numeyes; ++i)
                eye_levels[i] = 0;
 
        for(i = 0; i < sv.writeentitiestoclient_numeyes; ++i)
                eye_levels[i] = 0;
 


@@ -1736,17 +1701,17 @@ void SV_AddCameraEyes(void)
        {
                if (!ed->priv.server->free)
                {
        {
                if (!ed->priv.server->free)
                {

-                       if(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform))
+                       if(PRVM_serveredictfunction(ed, camera_transform))

                        {
                                prog->globals.server->self = e;
                                prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
                        {
                                prog->globals.server->self = e;
                                prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;

-                               VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos));
+                               VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_serverglobalvector(trace_endpos));

                                VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_G_VECTOR(OFS_PARM0));
                                VectorClear(PRVM_G_VECTOR(OFS_PARM1));
                                VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_G_VECTOR(OFS_PARM0));
                                VectorClear(PRVM_G_VECTOR(OFS_PARM1));

-                               PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform), "QC function e.camera_transform is missing");
-                               if(!VectorCompare(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos), sv.writeentitiestoclient_eyes[0]))
+                               PRVM_ExecuteProgram(PRVM_serveredictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
+                               if(!VectorCompare(PRVM_serverglobalvector(trace_endpos), sv.writeentitiestoclient_eyes[0]))

                                {
                                {

-                                       VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos), camera_origins[n_cameras]);
+                                       VectorCopy(PRVM_serverglobalvector(trace_endpos), camera_origins[n_cameras]);

                                        cameras[n_cameras] = e;
                                        ++n_cameras;
                                        if(n_cameras >= MAX_LEVELNETWORKEYES)
                                        cameras[n_cameras] = e;
                                        ++n_cameras;
                                        if(n_cameras >= MAX_LEVELNETWORKEYES)


@@ -1990,11 +1955,11 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
        // stuff the sigil bits into the high bits of items for sbar, or else
        // mix in items2
        if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
        // stuff the sigil bits into the high bits of items for sbar, or else
        // mix in items2
        if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)

-               items = (int)ent->fields.server->items | ((int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.items2) << 23);
+               items = (int)ent->fields.server->items | ((int)PRVM_serveredictfloat(ent, items2) << 23);

        else
                items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
 
        else
                items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
 

-       VectorCopy(PRVM_EDICTFIELDVECTOR(ent, prog->fieldoffsets.punchvector), punchvector);
+       VectorCopy(PRVM_serveredictvector(ent, punchvector), punchvector);

 
        // cache weapon model name and index in client struct to save time
        // (this search can be almost 1% of cpu time!)
 
        // cache weapon model name and index in client struct to save time
        // (this search can be almost 1% of cpu time!)


@@ -2005,7 +1970,7 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                client->weaponmodelindex = SV_ModelIndex(s, 1);
        }
 
                client->weaponmodelindex = SV_ModelIndex(s, 1);
        }
 

-       viewzoom = (int)(PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.viewzoom) * 255.0f);
+       viewzoom = (int)(PRVM_serveredictfloat(ent, viewzoom) * 255.0f);

        if (viewzoom == 0)
                viewzoom = 255;
 
        if (viewzoom == 0)
                viewzoom = 255;
 


@@ -2029,7 +1994,7 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                        bits |= (SU_VELOCITY1<<i);
        }
 
                        bits |= (SU_VELOCITY1<<i);
        }
 

-       gravity = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.gravity);if (!gravity) gravity = 1.0f;
+       gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;

 
        memset(stats, 0, sizeof(int[MAX_CL_STATS]));
        stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];
 
        memset(stats, 0, sizeof(int[MAX_CL_STATS]));
        stats[STAT_VIEWHEIGHT] = (int)ent->fields.server->view_ofs[2];


@@ -2450,7 +2415,7 @@ static void SV_UpdateToReliableMessages (void)
                }
 
                // DP_SV_CLIENTCOLORS
                }
 
                // DP_SV_CLIENTCOLORS

-               host_client->colors = (int)PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.clientcolors);
+               host_client->colors = (int)PRVM_serveredictfloat(host_client->edict, clientcolors);

                if (host_client->old_colors != host_client->colors)
                {
                        host_client->old_colors = host_client->colors;
                if (host_client->old_colors != host_client->colors)
                {
                        host_client->old_colors = host_client->colors;


@@ -2461,27 +2426,23 @@ static void SV_UpdateToReliableMessages (void)
                }
 
                // NEXUIZ_PLAYERMODEL
                }
 
                // NEXUIZ_PLAYERMODEL

-               if( prog->fieldoffsets.playermodel >= 0 ) {
-                       model = PRVM_GetString(PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playermodel));
-                       if (model == NULL)
-                               model = "";
-                       // always point the string back at host_client->name to keep it safe
-                       strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
-                       PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playermodel) = PRVM_SetEngineString(host_client->playermodel);
-               }
+               model = PRVM_GetString(PRVM_serveredictstring(host_client->edict, playermodel));
+               if (model == NULL)
+                       model = "";
+               // always point the string back at host_client->name to keep it safe
+               strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
+               PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(host_client->playermodel);

 
                // NEXUIZ_PLAYERSKIN
 
                // NEXUIZ_PLAYERSKIN

-               if( prog->fieldoffsets.playerskin >= 0 ) {
-                       skin = PRVM_GetString(PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playerskin));
-                       if (skin == NULL)
-                               skin = "";
-                       // always point the string back at host_client->name to keep it safe
-                       strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
-                       PRVM_EDICTFIELDSTRING(host_client->edict, prog->fieldoffsets.playerskin) = PRVM_SetEngineString(host_client->playerskin);
-               }
+               skin = PRVM_GetString(PRVM_serveredictstring(host_client->edict, playerskin));
+               if (skin == NULL)
+                       skin = "";
+               // always point the string back at host_client->name to keep it safe
+               strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
+               PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(host_client->playerskin);

 
                // TODO: add an extension name for this [1/17/2008 Black]
 
                // TODO: add an extension name for this [1/17/2008 Black]

-               clientcamera = PRVM_EDICTFIELDEDICT(host_client->edict, prog->fieldoffsets.clientcamera);
+               clientcamera = PRVM_serveredictedict(host_client->edict, clientcamera);

                if (clientcamera > 0)
                {
                        int oldclientcamera = host_client->clientcamera;
                if (clientcamera > 0)
                {
                        int oldclientcamera = host_client->clientcamera;


@@ -3508,60 +3469,39 @@ static void SV_VM_CB_InitEdict(prvm_edict_t *e)
                // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
                // reset them
                e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
                // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
                // reset them
                e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);

-               PRVM_EDICTFIELDFLOAT(e, prog->fieldoffsets.clientcolors) = svs.clients[num].colors;
+               PRVM_serveredictfloat(e, clientcolors) = svs.clients[num].colors;

                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN

-               if( prog->fieldoffsets.playermodel >= 0 )
-                       PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.playermodel) = PRVM_SetEngineString(svs.clients[num].playermodel);
-               if( prog->fieldoffsets.playerskin >= 0 )
-                       PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.playerskin) = PRVM_SetEngineString(svs.clients[num].playerskin);
+               PRVM_serveredictstring(e, playermodel) = PRVM_SetEngineString(svs.clients[num].playermodel);
+               PRVM_serveredictstring(e, playerskin) = PRVM_SetEngineString(svs.clients[num].playerskin);

                // Assign netaddress (IP Address, etc)
                // Assign netaddress (IP Address, etc)

-               if(prog->fieldoffsets.netaddress >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL)
-                       {// Valid Address; Assign
-                               // Acquire Readable Address
-                               LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.netaddress) = PRVM_SetEngineString(svs.clients[num].netaddress);
-                       }
-                       else
-                               // Invalid / Bot
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.netaddress) = PRVM_SetEngineString("null/botclient");
-               }
-               if(prog->fieldoffsets.crypto_idfp >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_idfp[0])
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_idfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.client_idfp);
-                       else
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_idfp) = 0;
-               }
-               if(prog->fieldoffsets.crypto_keyfp >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_keyfp[0])
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_keyfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.client_keyfp);
-                       else
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_keyfp) = 0;
-               }
-               if(prog->fieldoffsets.crypto_mykeyfp >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.server_keyfp[0])
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_mykeyfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.server_keyfp);
-                       else
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_mykeyfp) = 0;
-               }
-               if(prog->fieldoffsets.crypto_encryptmethod >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.use_aes)
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_encryptmethod) = PRVM_SetEngineString("AES128");
-                       else
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_encryptmethod) = 0;
-               }
-               if(prog->fieldoffsets.crypto_signmethod >= 0)
-               { // Valid Field; Process
-                       if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated)
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_signmethod) = PRVM_SetEngineString("HMAC-SHA256");
-                       else
-                               PRVM_EDICTFIELDSTRING(e, prog->fieldoffsets.crypto_signmethod) = 0;
+               if(svs.clients[num].netconnection != NULL)
+               {
+                       // Acquire Readable Address
+                       LHNETADDRESS_ToString(&svs.clients[num].netconnection->peeraddress, svs.clients[num].netaddress, sizeof(svs.clients[num].netaddress), false);
+                       PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString(svs.clients[num].netaddress);

                }
                }

+               else
+                       PRVM_serveredictstring(e, netaddress) = PRVM_SetEngineString("null/botclient");
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_idfp[0])
+                       PRVM_serveredictstring(e, crypto_idfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.client_idfp);
+               else
+                       PRVM_serveredictstring(e, crypto_idfp) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.client_keyfp[0])
+                       PRVM_serveredictstring(e, crypto_keyfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.client_keyfp);
+               else
+                       PRVM_serveredictstring(e, crypto_keyfp) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.server_keyfp[0])
+                       PRVM_serveredictstring(e, crypto_mykeyfp) = PRVM_SetEngineString(svs.clients[num].netconnection->crypto.server_keyfp);
+               else
+                       PRVM_serveredictstring(e, crypto_mykeyfp) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated && svs.clients[num].netconnection->crypto.use_aes)
+                       PRVM_serveredictstring(e, crypto_encryptmethod) = PRVM_SetEngineString("AES128");
+               else
+                       PRVM_serveredictstring(e, crypto_encryptmethod) = 0;
+               if(svs.clients[num].netconnection != NULL && svs.clients[num].netconnection->crypto.authenticated)
+                       PRVM_serveredictstring(e, crypto_signmethod) = PRVM_SetEngineString("HMAC-SHA256");
+               else
+                       PRVM_serveredictstring(e, crypto_signmethod) = 0;

        }
 }
 
        }
 }
 

diff --git a/sv_phys.c b/sv_phys.c
index 541a105939ea937c01dde83ebbecf0287e0cd449..c0f89c89ecefe16aa75f31e8f891dce54ad5e3fc 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -52,7 +52,7 @@ int SV_GetPitchSign(prvm_edict_t *ent)
                        model->type == mod_alias
                        :
                        (
                        model->type == mod_alias
                        :
                        (

-                        (((unsigned char)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.pflags)) & PFLAGS_FULLDYNAMIC)
+                        (((unsigned char)PRVM_serveredictfloat(ent, pflags)) & PFLAGS_FULLDYNAMIC)

                         ||
                         ((gamemode == GAME_TENEBRAE) && ((unsigned int)ent->fields.server->effects & (16 | 32)))
                        )
                         ||
                         ((gamemode == GAME_TENEBRAE) && ((unsigned int)ent->fields.server->effects & (16 | 32)))
                        )


@@ -73,7 +73,7 @@ int SV_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
 {
        if (passedict)
        {
 {
        if (passedict)
        {

-               int dphitcontentsmask = (int)PRVM_EDICTFIELDFLOAT(passedict, prog->fieldoffsets.dphitcontentsmask);
+               int dphitcontentsmask = (int)PRVM_serveredictfloat(passedict, dphitcontentsmask);

                if (dphitcontentsmask)
                        return dphitcontentsmask;
                else if (passedict->fields.server->solid == SOLID_SLIDEBOX)
                if (dphitcontentsmask)
                        return dphitcontentsmask;
                else if (passedict->fields.server->solid == SOLID_SLIDEBOX)


@@ -713,10 +713,10 @@ void SV_LinkEdict_TouchAreaGrid_Call(prvm_edict_t *touch, prvm_edict_t *ent)
        VectorSet (prog->globals.server->trace_plane_normal, 0, 0, 1);
        prog->globals.server->trace_plane_dist = 0;
        prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(ent);
        VectorSet (prog->globals.server->trace_plane_normal, 0, 0, 1);
        prog->globals.server->trace_plane_dist = 0;
        prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(ent);

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dpstartcontents) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitcontents) = 0;
-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitq3surfaceflags) = 0;
-       PRVM_GLOBALFIELDSTRING(prog->globaloffsets.trace_dphittexturename) = 0;
+       PRVM_serverglobalfloat(trace_dpstartcontents) = 0;
+       PRVM_serverglobalfloat(trace_dphitcontents) = 0;
+       PRVM_serverglobalfloat(trace_dphitq3surfaceflags) = 0;
+       PRVM_serverglobalstring(trace_dphittexturename) = 0;

        PRVM_ExecuteProgram (touch->fields.server->touch, "QC function self.touch is missing");
 }
 
        PRVM_ExecuteProgram (touch->fields.server->touch, "QC function self.touch is missing");
 }
 


@@ -1013,7 +1013,7 @@ int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
        if(ent->fields.server->watertype != nContents)
        { // Changed Contents
                // Acquire Contents Transition Function from QC
        if(ent->fields.server->watertype != nContents)
        { // Changed Contents
                // Acquire Contents Transition Function from QC

-               if(PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.contentstransition))
+               if(PRVM_serveredictfunction(ent, contentstransition))

                { // Valid Function; Execute
                        // Assign Valid Function
                        bValidFunctionCall = true;
                { // Valid Function; Execute
                        // Assign Valid Function
                        bValidFunctionCall = true;


@@ -1025,7 +1025,7 @@ int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
                                // Assign Self
                                prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
                        // Execute VM Function
                                // Assign Self
                                prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
                        // Execute VM Function

-                       PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.contentstransition), "contentstransition: NULL function");
+                       PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, contentstransition), "contentstransition: NULL function");

                }
        }
 
                }
        }
 


@@ -1151,10 +1151,10 @@ void SV_Impact (prvm_edict_t *e1, trace_t *trace)
                VectorNegate(trace->plane.normal, prog->globals.server->trace_plane_normal);
                prog->globals.server->trace_plane_dist = -trace->plane.dist;
                prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(e1);
                VectorNegate(trace->plane.normal, prog->globals.server->trace_plane_normal);
                prog->globals.server->trace_plane_dist = -trace->plane.dist;
                prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(e1);

-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dpstartcontents) = 0;
-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitcontents) = 0;
-               PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_dphitq3surfaceflags) = 0;
-               PRVM_GLOBALFIELDSTRING(prog->globaloffsets.trace_dphittexturename) = 0;
+               PRVM_serverglobalfloat(trace_dpstartcontents) = 0;
+               PRVM_serverglobalfloat(trace_dphitcontents) = 0;
+               PRVM_serverglobalfloat(trace_dphitq3surfaceflags) = 0;
+               PRVM_serverglobalstring(trace_dphittexturename) = 0;

                PRVM_ExecuteProgram (e2->fields.server->touch, "QC function self.touch is missing");
        }
 
                PRVM_ExecuteProgram (e2->fields.server->touch, "QC function self.touch is missing");
        }
 


@@ -1434,7 +1434,7 @@ static float SV_Gravity (prvm_edict_t *ent)
 {
        float ent_gravity;
 
 {
        float ent_gravity;
 

-       ent_gravity = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.gravity);
+       ent_gravity = PRVM_serveredictfloat(ent, gravity);

        if (!ent_gravity)
                ent_gravity = 1.0f;
        return ent_gravity * sv_gravity.value * sv.frametime;
        if (!ent_gravity)
                ent_gravity = 1.0f;
        return ent_gravity * sv_gravity.value * sv.frametime;


@@ -2505,7 +2505,7 @@ void SV_Physics_Toss (prvm_edict_t *ent)
                if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
                {
                        float bouncefactor;
                if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
                {
                        float bouncefactor;

-                       bouncefactor = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.bouncefactor);
+                       bouncefactor = PRVM_serveredictfloat(ent, bouncefactor);

                        if (!bouncefactor)
                                bouncefactor = 1.0f;
 
                        if (!bouncefactor)
                                bouncefactor = 1.0f;
 


@@ -2518,16 +2518,16 @@ void SV_Physics_Toss (prvm_edict_t *ent)
                        float bouncefactor;
                        float bouncestop;
 
                        float bouncefactor;
                        float bouncestop;
 

-                       bouncefactor = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.bouncefactor);
+                       bouncefactor = PRVM_serveredictfloat(ent, bouncefactor);

                        if (!bouncefactor)
                                bouncefactor = 0.5f;
 
                        if (!bouncefactor)
                                bouncefactor = 0.5f;
 

-                       bouncestop = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.bouncestop);
+                       bouncestop = PRVM_serveredictfloat(ent, bouncestop);

                        if (!bouncestop)
                                bouncestop = 60.0f / 800.0f;
 
                        ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);
                        if (!bouncestop)
                                bouncestop = 60.0f / 800.0f;
 
                        ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);

-                       ent_gravity = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.gravity);
+                       ent_gravity = PRVM_serveredictfloat(ent, gravity);

                        if (!ent_gravity)
                                ent_gravity = 1.0f;
                        // LordHavoc: fixed grenades not bouncing when fired down a slope
                        if (!ent_gravity)
                                ent_gravity = 1.0f;
                        // LordHavoc: fixed grenades not bouncing when fired down a slope


@@ -2639,7 +2639,7 @@ void SV_Physics_Step (prvm_edict_t *ent)
                        if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND)
                        {
                                // DRESK - Check for Entity Land Event Function
                        if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND)
                        {
                                // DRESK - Check for Entity Land Event Function

-                               if(PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.movetypesteplandevent))
+                               if(PRVM_serveredictfunction(ent, movetypesteplandevent))

                                { // Valid Function; Execute
                                        // Prepare Parameters
                                                // Assign Velocity at Impact
                                { // Valid Function; Execute
                                        // Prepare Parameters
                                                // Assign Velocity at Impact


@@ -2649,7 +2649,7 @@ void SV_Physics_Step (prvm_edict_t *ent)
                                                // Assign Self
                                                prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
                                        // Execute VM Function
                                                // Assign Self
                                                prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
                                        // Execute VM Function

-                                       PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ent, prog->fieldoffsets.movetypesteplandevent), "movetypesteplandevent: NULL function");
+                                       PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, movetypesteplandevent), "movetypesteplandevent: NULL function");

                                }
                                else
                                // Check for Engine Landing Sound
                                }
                                else
                                // Check for Engine Landing Sound

diff --git a/sv_user.c b/sv_user.c
index 4a70f1a6d57ea87e4aef2eadd80f64ca5331ac5a..d675990fd89d39ce169c5963241c04ee571a7a4e 100644 (file)
--- a/sv_user.c
+++ b/sv_user.c
@@ -199,7 +199,7 @@ void DropPunchAngle (void)
                len = 0;
        VectorScale (host_client->edict->fields.server->punchangle, len, host_client->edict->fields.server->punchangle);
 
                len = 0;
        VectorScale (host_client->edict->fields.server->punchangle, len, host_client->edict->fields.server->punchangle);
 

-       VectorCopy(PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.punchvector), v);
+       VectorCopy(PRVM_serveredictvector(host_client->edict, punchvector), v);

        len = VectorNormalizeLength(v);
        if (len > 0)
        {
        len = VectorNormalizeLength(v);
        if (len > 0)
        {


@@ -208,7 +208,7 @@ void DropPunchAngle (void)
                        len = 0;
                VectorScale(v, len, v);
        }
                        len = 0;
                VectorScale(v, len, v);
        }

-       VectorCopy(v, PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.punchvector));
+       VectorCopy(v, PRVM_serveredictvector(host_client->edict, punchvector));

 }
 
 /*
 }
 
 /*


@@ -597,7 +597,7 @@ void SV_ExecuteClientMoves(void)
        if (ceil(max(sv_readmoves[sv_numreadmoves-1].receivetime - sv_readmoves[sv_numreadmoves-1].time, 0) * 1000.0) < sv_clmovement_minping.integer)
                host_client->clmovement_disabletimeout = realtime + sv_clmovement_minping_disabletime.value / 1000.0;
        // several conditions govern whether clientside movement prediction is allowed
        if (ceil(max(sv_readmoves[sv_numreadmoves-1].receivetime - sv_readmoves[sv_numreadmoves-1].time, 0) * 1000.0) < sv_clmovement_minping.integer)
                host_client->clmovement_disabletimeout = realtime + sv_clmovement_minping_disabletime.value / 1000.0;
        // several conditions govern whether clientside movement prediction is allowed

-       if (sv_readmoves[sv_numreadmoves-1].sequence && sv_clmovement_enable.integer && sv_clmovement_inputtimeout.value > 0 && host_client->clmovement_disabletimeout <= realtime && host_client->edict->fields.server->movetype == MOVETYPE_WALK && (!PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.disableclientprediction)))
+       if (sv_readmoves[sv_numreadmoves-1].sequence && sv_clmovement_enable.integer && sv_clmovement_inputtimeout.value > 0 && host_client->clmovement_disabletimeout <= realtime && host_client->edict->fields.server->movetype == MOVETYPE_WALK && (!PRVM_serveredictfloat(host_client->edict, disableclientprediction)))

        {
                // process the moves in order and ignore old ones
                // but always trust the latest move
        {
                // process the moves in order and ignore old ones
                // but always trust the latest move


@@ -738,31 +738,31 @@ void SV_ApplyClientMove (void)
        }
 
        VectorCopy(move->viewangles, host_client->edict->fields.server->v_angle);
        }
 
        VectorCopy(move->viewangles, host_client->edict->fields.server->v_angle);

-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button3) = ((move->buttons >> 2) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button4) = ((move->buttons >> 3) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button5) = ((move->buttons >> 4) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button6) = ((move->buttons >> 5) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button7) = ((move->buttons >> 6) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button8) = ((move->buttons >> 7) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button9) = ((move->buttons >> 11) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button10) = ((move->buttons >> 12) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button11) = ((move->buttons >> 13) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button12) = ((move->buttons >> 14) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button13) = ((move->buttons >> 15) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button14) = ((move->buttons >> 16) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button15) = ((move->buttons >> 17) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.button16) = ((move->buttons >> 18) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.buttonuse) = ((move->buttons >> 8) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.buttonchat) = ((move->buttons >> 9) & 1);
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.cursor_active) = ((move->buttons >> 10) & 1);
-       VectorSet(PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.movement), move->forwardmove, move->sidemove, move->upmove);
-       VectorCopy(move->cursor_screen, PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.cursor_screen));
-       VectorCopy(move->cursor_start, PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.cursor_trace_start));
-       VectorCopy(move->cursor_impact, PRVM_EDICTFIELDVECTOR(host_client->edict, prog->fieldoffsets.cursor_trace_endpos));
-       PRVM_EDICTFIELDEDICT(host_client->edict, prog->fieldoffsets.cursor_trace_ent) = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(move->cursor_entitynumber));
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ping) = host_client->ping * 1000.0;
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ping_packetloss) = packetloss / (float) NETGRAPH_PACKETS;
-       PRVM_EDICTFIELDFLOAT(host_client->edict, prog->fieldoffsets.ping_movementloss) = movementloss / (float) NETGRAPH_PACKETS;
+       PRVM_serveredictfloat(host_client->edict, button3) = ((move->buttons >> 2) & 1);
+       PRVM_serveredictfloat(host_client->edict, button4) = ((move->buttons >> 3) & 1);
+       PRVM_serveredictfloat(host_client->edict, button5) = ((move->buttons >> 4) & 1);
+       PRVM_serveredictfloat(host_client->edict, button6) = ((move->buttons >> 5) & 1);
+       PRVM_serveredictfloat(host_client->edict, button7) = ((move->buttons >> 6) & 1);
+       PRVM_serveredictfloat(host_client->edict, button8) = ((move->buttons >> 7) & 1);
+       PRVM_serveredictfloat(host_client->edict, button9) = ((move->buttons >> 11) & 1);
+       PRVM_serveredictfloat(host_client->edict, button10) = ((move->buttons >> 12) & 1);
+       PRVM_serveredictfloat(host_client->edict, button11) = ((move->buttons >> 13) & 1);
+       PRVM_serveredictfloat(host_client->edict, button12) = ((move->buttons >> 14) & 1);
+       PRVM_serveredictfloat(host_client->edict, button13) = ((move->buttons >> 15) & 1);
+       PRVM_serveredictfloat(host_client->edict, button14) = ((move->buttons >> 16) & 1);
+       PRVM_serveredictfloat(host_client->edict, button15) = ((move->buttons >> 17) & 1);
+       PRVM_serveredictfloat(host_client->edict, button16) = ((move->buttons >> 18) & 1);
+       PRVM_serveredictfloat(host_client->edict, buttonuse) = ((move->buttons >> 8) & 1);
+       PRVM_serveredictfloat(host_client->edict, buttonchat) = ((move->buttons >> 9) & 1);
+       PRVM_serveredictfloat(host_client->edict, cursor_active) = ((move->buttons >> 10) & 1);
+       VectorSet(PRVM_serveredictvector(host_client->edict, movement), move->forwardmove, move->sidemove, move->upmove);
+       VectorCopy(move->cursor_screen, PRVM_serveredictvector(host_client->edict, cursor_screen));
+       VectorCopy(move->cursor_start, PRVM_serveredictvector(host_client->edict, cursor_trace_start));
+       VectorCopy(move->cursor_impact, PRVM_serveredictvector(host_client->edict, cursor_trace_endpos));
+       PRVM_serveredictedict(host_client->edict, cursor_trace_ent) = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(move->cursor_entitynumber));
+       PRVM_serveredictfloat(host_client->edict, ping) = host_client->ping * 1000.0;
+       PRVM_serveredictfloat(host_client->edict, ping_packetloss) = packetloss / (float) NETGRAPH_PACKETS;
+       PRVM_serveredictfloat(host_client->edict, ping_movementloss) = movementloss / (float) NETGRAPH_PACKETS;

 }
 
 void SV_FrameLost(int framenum)
 }
 
 void SV_FrameLost(int framenum)

diff --git a/svvm_cmds.c b/svvm_cmds.c
index b5a83994ff4c25d132ef78399e17f7cc5ab8a99b..f2028c475968ac54a3dae0bfa13accaa8ff3abd4 100644 (file)
--- a/svvm_cmds.c
+++ b/svvm_cmds.c
@@ -674,7 +674,7 @@ static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
        VectorCopy(tossent->fields.server->angles   , original_angles   );
        VectorCopy(tossent->fields.server->avelocity, original_avelocity);
 
        VectorCopy(tossent->fields.server->angles   , original_angles   );
        VectorCopy(tossent->fields.server->avelocity, original_avelocity);
 

-       gravity = PRVM_EDICTFIELDFLOAT(tossent, prog->fieldoffsets.gravity);
+       gravity = PRVM_serveredictfloat(tossent, gravity);

        if (!gravity)
                gravity = 1.0f;
        gravity *= sv_gravity.value * 0.025;
        if (!gravity)
                gravity = 1.0f;
        gravity *= sv_gravity.value * 0.025;


@@ -1742,7 +1742,7 @@ static void VM_SV_setcolor (void)
        client = svs.clients + entnum-1;
        if (client->edict)
        {
        client = svs.clients + entnum-1;
        if (client->edict)
        {

-               PRVM_EDICTFIELDFLOAT(client->edict, prog->fieldoffsets.clientcolors) = i;
+               PRVM_serveredictfloat(client->edict, clientcolors) = i;

                client->edict->fields.server->team = (i & 15) + 1;
        }
        client->colors = i;
                client->edict->fields.server->team = (i & 15) + 1;
        }
        client->colors = i;


@@ -2324,8 +2324,8 @@ static void VM_SV_setattachment (void)
                        Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 
                        Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 

-       PRVM_EDICTFIELDEDICT(e, prog->fieldoffsets.tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
-       PRVM_EDICTFIELDFLOAT(e, prog->fieldoffsets.tag_index) = tagindex;
+       PRVM_serveredictedict(e, tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
+       PRVM_serveredictfloat(e, tag_index) = tagindex;

 }
 
 /////////////////////////////////////////
 }
 
 /////////////////////////////////////////


@@ -2369,7 +2369,7 @@ void SV_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatri
        float scale;
        float pitchsign = 1;
 
        float scale;
        float pitchsign = 1;
 

-       scale = PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.scale);
+       scale = PRVM_serveredictfloat(ent, scale);

        if (!scale)
                scale = 1.0f;
        
        if (!scale)
                scale = 1.0f;
        


@@ -2446,10 +2446,10 @@ int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
                Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                // next iteration we process the parent entity
                Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                // next iteration we process the parent entity

-               if (PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.tag_entity))
+               if (PRVM_serveredictedict(ent, tag_entity))

                {
                {

-                       tagindex = (int)PRVM_EDICTFIELDFLOAT(ent, prog->fieldoffsets.tag_index);
-                       ent = PRVM_EDICT_NUM(PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.tag_entity));
+                       tagindex = (int)PRVM_serveredictfloat(ent, tag_index);
+                       ent = PRVM_EDICT_NUM(PRVM_serveredictedict(ent, tag_entity));

                }
                else
                        break;
                }
                else
                        break;


@@ -2457,10 +2457,10 @@ int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
        }
 
        // RENDER_VIEWMODEL magic
        }
 
        // RENDER_VIEWMODEL magic

-       if (PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.viewmodelforclient))
+       if (PRVM_serveredictedict(ent, viewmodelforclient))

        {
                Matrix4x4_Copy(&tagmatrix, out);
        {
                Matrix4x4_Copy(&tagmatrix, out);

-               ent = PRVM_EDICT_NUM(PRVM_EDICTFIELDEDICT(ent, prog->fieldoffsets.viewmodelforclient));
+               ent = PRVM_EDICT_NUM(PRVM_serveredictedict(ent, viewmodelforclient));

 
                SV_GetEntityMatrix(ent, &entitymatrix, true);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
 
                SV_GetEntityMatrix(ent, &entitymatrix, true);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);


@@ -2556,12 +2556,12 @@ static void VM_SV_gettaginfo (void)
        SV_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
        Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 
        SV_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
        Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
 

-       PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.gettaginfo_parent) = parentindex;
-       PRVM_GLOBALFIELDSTRING(prog->globaloffsets.gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
-       VectorCopy(trans, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_offset));
-       VectorCopy(fo, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_forward));
-       VectorScale(le, -1, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_right));
-       VectorCopy(up, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.gettaginfo_up));
+       PRVM_serverglobalfloat(gettaginfo_parent) = parentindex;
+       PRVM_serverglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(tagname) : 0;
+       VectorCopy(trans, PRVM_serverglobalvector(gettaginfo_offset));
+       VectorCopy(fo, PRVM_serverglobalvector(gettaginfo_forward));
+       VectorScale(le, -1, PRVM_serverglobalvector(gettaginfo_right));
+       VectorCopy(up, PRVM_serverglobalvector(gettaginfo_up));

 
        switch(returncode)
        {
 
        switch(returncode)
        {

diff --git a/world.c b/world.c
index e914f381caf30418c96426ca4880dc84b9013a81..eadb9895547840a775b7c995355f5411ea88b48d 100644 (file)
--- a/world.c
+++ b/world.c
@@ -1755,10 +1755,10 @@ static void World_Physics_Frame_BodyToEntity(world_t *world, prvm_edict_t *ed)
        int jointtype;
        if (!body)
                return;
        int jointtype;
        if (!body)
                return;

-       movetype = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.movetype);
+       movetype = (int)PRVM_gameedictfloat(ed, movetype);

        if (movetype != MOVETYPE_PHYSICS)
        {
        if (movetype != MOVETYPE_PHYSICS)
        {

-               jointtype = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.jointtype);
+               jointtype = (int)PRVM_gameedictfloat(ed, jointtype);

                switch(jointtype)
                {
                        // TODO feed back data from physics
                switch(jointtype)
                {
                        // TODO feed back data from physics


@@ -1815,14 +1815,14 @@ static void World_Physics_Frame_BodyToEntity(world_t *world, prvm_edict_t *ed)
                avelocity[PITCH] *= pitchsign;
        }
 
                avelocity[PITCH] *= pitchsign;
        }
 

-       VectorCopy(origin, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.origin));
-       VectorCopy(velocity, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.velocity));
-       //VectorCopy(forward, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_forward));
-       //VectorCopy(left, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_left));
-       //VectorCopy(up, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_up));
-       //VectorCopy(spinvelocity, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.spinvelocity));
-       VectorCopy(angles, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.angles));
-       VectorCopy(avelocity, PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.avelocity));
+       VectorCopy(origin, PRVM_gameedictvector(ed, origin));
+       VectorCopy(velocity, PRVM_gameedictvector(ed, velocity));
+       //VectorCopy(forward, PRVM_gameedictvector(ed, axis_forward));
+       //VectorCopy(left, PRVM_gameedictvector(ed, axis_left));
+       //VectorCopy(up, PRVM_gameedictvector(ed, axis_up));
+       //VectorCopy(spinvelocity, PRVM_gameedictvector(ed, spinvelocity));
+       VectorCopy(angles, PRVM_gameedictvector(ed, angles));
+       VectorCopy(avelocity, PRVM_gameedictvector(ed, avelocity));

 
        // values for BodyFromEntity to check if the qc modified anything later
        VectorCopy(origin, ed->priv.server->ode_origin);
 
        // values for BodyFromEntity to check if the qc modified anything later
        VectorCopy(origin, ed->priv.server->ode_origin);


@@ -1852,14 +1852,14 @@ static void World_Physics_Frame_JointFromEntity(world_t *world, prvm_edict_t *ed
        VectorClear(velocity);
        VectorClear(angles);
        VectorClear(movedir);
        VectorClear(velocity);
        VectorClear(angles);
        VectorClear(movedir);

-       movetype = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.movetype);
-       jointtype = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.jointtype);
-       enemy = PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.enemy);
-       aiment = PRVM_EDICTFIELDEDICT(ed, prog->fieldoffsets.aiment);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.origin), origin);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.velocity), velocity);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.angles), angles);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.movedir), movedir);
+       movetype = (int)PRVM_gameedictfloat(ed, movetype);
+       jointtype = (int)PRVM_gameedictfloat(ed, jointtype);
+       enemy = PRVM_gameedictedict(ed, enemy);
+       aiment = PRVM_gameedictedict(ed, aiment);
+       VectorCopy(PRVM_gameedictvector(ed, origin), origin);
+       VectorCopy(PRVM_gameedictvector(ed, velocity), velocity);
+       VectorCopy(PRVM_gameedictvector(ed, angles), angles);
+       VectorCopy(PRVM_gameedictvector(ed, movedir), movedir);

        if(movetype == MOVETYPE_PHYSICS)
                jointtype = 0; // can't have both
        if(enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].priv.required->free || prog->edicts[enemy].priv.server->ode_body == 0)
        if(movetype == MOVETYPE_PHYSICS)
                jointtype = 0; // can't have both
        if(enemy <= 0 || enemy >= prog->num_edicts || prog->edicts[enemy].priv.required->free || prog->edicts[enemy].priv.server->ode_body == 0)


@@ -2070,9 +2070,9 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
 #endif
        VectorClear(entmins);
        VectorClear(entmaxs);
 #endif
        VectorClear(entmins);
        VectorClear(entmaxs);

-       solid = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.solid);
-       movetype = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.movetype);
-       scale = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.scale);if (!scale) scale = 1.0f;
+       solid = (int)PRVM_gameedictfloat(ed, solid);
+       movetype = (int)PRVM_gameedictfloat(ed, movetype);
+       scale = PRVM_gameedictfloat(ed, scale);if (!scale) scale = 1.0f;

        modelindex = 0;
        if (world == &sv.world)
                mempool = sv_mempool;
        modelindex = 0;
        if (world == &sv.world)
                mempool = sv_mempool;


@@ -2084,7 +2084,7 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
        switch(solid)
        {
        case SOLID_BSP:
        switch(solid)
        {
        case SOLID_BSP:

-               modelindex = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.modelindex);
+               modelindex = (int)PRVM_gameedictfloat(ed, modelindex);

                if (world == &sv.world)
                        model = SV_GetModelByIndex(modelindex);
                else if (world == &cl.world)
                if (world == &sv.world)
                        model = SV_GetModelByIndex(modelindex);
                else if (world == &cl.world)


@@ -2095,7 +2095,7 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
                {
                        VectorScale(model->normalmins, scale, entmins);
                        VectorScale(model->normalmaxs, scale, entmaxs);
                {
                        VectorScale(model->normalmins, scale, entmins);
                        VectorScale(model->normalmaxs, scale, entmaxs);

-                       massval = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.mass);
+                       massval = PRVM_gameedictfloat(ed, mass);

                }
                else
                {
                }
                else
                {


@@ -2109,9 +2109,9 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
        case SOLID_PHYSICS_BOX:
        case SOLID_PHYSICS_SPHERE:
        case SOLID_PHYSICS_CAPSULE:
        case SOLID_PHYSICS_BOX:
        case SOLID_PHYSICS_SPHERE:
        case SOLID_PHYSICS_CAPSULE:

-               VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.mins), entmins);
-               VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.maxs), entmaxs);
-               massval = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.mass);
+               VectorCopy(PRVM_gameedictvector(ed, mins), entmins);
+               VectorCopy(PRVM_gameedictvector(ed, maxs), entmaxs);
+               massval = PRVM_gameedictfloat(ed, mass);

                break;
        default:
                if (ed->priv.server->ode_physics)
                break;
        default:
                if (ed->priv.server->ode_physics)


@@ -2151,7 +2151,7 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
                if (massval * geomsize[0] * geomsize[1] * geomsize[2] == 0)
                {
                        if (movetype == MOVETYPE_PHYSICS)
                if (massval * geomsize[0] * geomsize[1] * geomsize[2] == 0)
                {
                        if (movetype == MOVETYPE_PHYSICS)

-                               Con_Printf("entity %i (classname %s) .mass * .size_x * .size_y * .size_z == 0\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname)));
+                               Con_Printf("entity %i (classname %s) .mass * .size_x * .size_y * .size_z == 0\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));

                        massval = 1.0f;
                        VectorSet(geomsize, 1.0f, 1.0f, 1.0f);
                }
                        massval = 1.0f;
                        VectorSet(geomsize, 1.0f, 1.0f, 1.0f);
                }


@@ -2162,7 +2162,7 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
                        ed->priv.server->ode_offsetmatrix = identitymatrix;
                        if (!model)
                        {
                        ed->priv.server->ode_offsetmatrix = identitymatrix;
                        if (!model)
                        {

-                               Con_Printf("entity %i (classname %s) has no model\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname)));
+                               Con_Printf("entity %i (classname %s) has no model\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));

                                goto treatasbox;
                        }
                        // add an optimized mesh to the model containing only the SUPERCONTENTS_SOLID surfaces
                                goto treatasbox;
                        }
                        // add an optimized mesh to the model containing only the SUPERCONTENTS_SOLID surfaces


@@ -2170,7 +2170,7 @@ static void World_Physics_Frame_BodyFromEntity(world_t *world, prvm_edict_t *ed)
                                Mod_CreateCollisionMesh(model);
                        if (!model->brush.collisionmesh || !model->brush.collisionmesh->numtriangles)
                        {
                                Mod_CreateCollisionMesh(model);
                        if (!model->brush.collisionmesh || !model->brush.collisionmesh->numtriangles)
                        {

-                               Con_Printf("entity %i (classname %s) has no geometry\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname)));
+                               Con_Printf("entity %i (classname %s) has no geometry\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)));

                                goto treatasbox;
                        }
                        // ODE requires persistent mesh storage, so we need to copy out
                                goto treatasbox;
                        }
                        // ODE requires persistent mesh storage, so we need to copy out


@@ -2288,15 +2288,15 @@ treatasbox:
        VectorClear(angles);
        VectorClear(avelocity);
        gravity = true;
        VectorClear(angles);
        VectorClear(avelocity);
        gravity = true;

-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.origin), origin);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.velocity), velocity);
-       //VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_forward), forward);
-       //VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_left), left);
-       //VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.axis_up), up);
-       //VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.spinvelocity), spinvelocity);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.angles), angles);
-       VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.avelocity), avelocity);
-       if (PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.gravity) != 0.0f && PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.gravity) < 0.5f) gravity = false;
+       VectorCopy(PRVM_gameedictvector(ed, origin), origin);
+       VectorCopy(PRVM_gameedictvector(ed, velocity), velocity);
+       //VectorCopy(PRVM_gameedictvector(ed, axis_forward), forward);
+       //VectorCopy(PRVM_gameedictvector(ed, axis_left), left);
+       //VectorCopy(PRVM_gameedictvector(ed, axis_up), up);
+       //VectorCopy(PRVM_gameedictvector(ed, spinvelocity), spinvelocity);
+       VectorCopy(PRVM_gameedictvector(ed, angles), angles);
+       VectorCopy(PRVM_gameedictvector(ed, avelocity), avelocity);
+       if (PRVM_gameedictfloat(ed, gravity) != 0.0f && PRVM_EDICTFIELDFLOAT(ed, gravity) < 0.5f) gravity = false;

        if (ed == prog->edicts)
                gravity = false;
 
        if (ed == prog->edicts)
                gravity = false;
 


@@ -2346,9 +2346,9 @@ treatasbox:
                if (IS_NAN(test))
                {
                        modified = true;
                if (IS_NAN(test))
                {
                        modified = true;

-                       //Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .axis_forward = '%f %f %f' .axis_left = '%f %f %f' .axis_up = %f %f %f' .spinvelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], forward[0], forward[1], forward[2], left[0], left[1], left[2], up[0], up[1], up[2], spinvelocity[0], spinvelocity[1], spinvelocity[2]);
+                       //Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .axis_forward = '%f %f %f' .axis_left = '%f %f %f' .axis_up = %f %f %f' .spinvelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], forward[0], forward[1], forward[2], left[0], left[1], left[2], up[0], up[1], up[2], spinvelocity[0], spinvelocity[1], spinvelocity[2]);

                        if (physics_ode_trick_fixnan.integer >= 2)
                        if (physics_ode_trick_fixnan.integer >= 2)

-                               Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .angles = '%f %f %f' .avelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_EDICTFIELDSTRING(ed, prog->fieldoffsets.classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], angles[0], angles[1], angles[2], avelocity[0], avelocity[1], avelocity[2]);
+                               Con_Printf("Fixing NAN values on entity %i : .classname = \"%s\" .origin = '%f %f %f' .velocity = '%f %f %f' .angles = '%f %f %f' .avelocity = '%f %f %f'\n", PRVM_NUM_FOR_EDICT(ed), PRVM_GetString(PRVM_gameedictstring(ed, classname)), origin[0], origin[1], origin[2], velocity[0], velocity[1], velocity[2], angles[0], angles[1], angles[2], avelocity[0], avelocity[1], avelocity[2]);

                        test = VectorLength2(origin);
                        if (IS_NAN(test))
                                VectorClear(origin);
                        test = VectorLength2(origin);
                        if (IS_NAN(test))
                                VectorClear(origin);


@@ -2534,8 +2534,8 @@ static void nearCallback (void *data, dGeomID o1, dGeomID o2)
                ed1 = NULL;
        if(ed1)
        {
                ed1 = NULL;
        if(ed1)
        {

-               bouncefactor1 = PRVM_EDICTFIELDFLOAT(ed1, prog->fieldoffsets.bouncefactor);
-               bouncestop1 = PRVM_EDICTFIELDFLOAT(ed1, prog->fieldoffsets.bouncestop);
+               bouncefactor1 = PRVM_gameedictfloat(ed1, bouncefactor);
+               bouncestop1 = PRVM_gameedictfloat(ed1, bouncestop);

                if (!bouncestop1)
                        bouncestop1 = 60.0f / 800.0f;
        }
                if (!bouncestop1)
                        bouncestop1 = 60.0f / 800.0f;
        }


@@ -2545,8 +2545,8 @@ static void nearCallback (void *data, dGeomID o1, dGeomID o2)
                ed2 = NULL;
        if(ed2)
        {
                ed2 = NULL;
        if(ed2)
        {

-               bouncefactor2 = PRVM_EDICTFIELDFLOAT(ed2, prog->fieldoffsets.bouncefactor);
-               bouncestop2 = PRVM_EDICTFIELDFLOAT(ed2, prog->fieldoffsets.bouncestop);
+               bouncefactor2 = PRVM_gameedictfloat(ed2, bouncefactor);
+               bouncestop2 = PRVM_gameedictfloat(ed2, bouncestop);

                if (!bouncestop2)
                        bouncestop2 = 60.0f / 800.0f;
        }
                if (!bouncestop2)
                        bouncestop2 = 60.0f / 800.0f;
        }