reworked progs loading so that entvars_t and globalvars_t are no longer

required to match (if they do match, the relevant fields will match the
structs, otherwise name lookups are used), this means the PROGHEADER_CRC
no longer has to match either...  and same for csqc and menuqc

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

diff --git a/cl_collision.c b/cl_collision.c
index 0f8ab408ae2af3f1bac59fe661469fc8a878b5a0..8c9540669c9ba6518bcb472962286efa79b71446 100644 (file)
--- a/cl_collision.c
+++ b/cl_collision.c
@@ -130,7 +130,7 @@ dp_model_t *CL_GetModelFromEdict(prvm_edict_t *ed)
 {
        if (!ed || ed->priv.server->free)
                return NULL;
 {
        if (!ed || ed->priv.server->free)
                return NULL;

-       return CL_GetModelByIndex((int)ed->fields.client->modelindex);
+       return CL_GetModelByIndex((int)PRVM_clientedictfloat(ed, modelindex));

 }
 
 void CL_LinkEdict(prvm_edict_t *ent)
 }
 
 void CL_LinkEdict(prvm_edict_t *ent)


@@ -145,9 +145,9 @@ void CL_LinkEdict(prvm_edict_t *ent)
 
        // set the abs box
 
 
        // set the abs box
 

-       if (ent->fields.client->solid == SOLID_BSP)
+       if (PRVM_clientedictfloat(ent, solid) == SOLID_BSP)

        {
        {

-               dp_model_t *model = CL_GetModelByIndex( (int)ent->fields.client->modelindex );
+               dp_model_t *model = CL_GetModelByIndex( (int)PRVM_clientedictfloat(ent, modelindex) );

                if (model == NULL)
                {
                        Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));
                if (model == NULL)
                {
                        Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));


@@ -160,39 +160,39 @@ void CL_LinkEdict(prvm_edict_t *ent)
                        if (!model->TraceBox)
                                Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 
                        if (!model->TraceBox)
                                Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 

-                       if (ent->fields.client->angles[0] || ent->fields.client->angles[2] || ent->fields.client->avelocity[0] || ent->fields.client->avelocity[2])
+                       if (PRVM_clientedictvector(ent, angles)[0] || PRVM_clientedictvector(ent, angles)[2] || PRVM_clientedictvector(ent, avelocity)[0] || PRVM_clientedictvector(ent, avelocity)[2])

                        {
                        {

-                               VectorAdd(ent->fields.client->origin, model->rotatedmins, mins);
-                               VectorAdd(ent->fields.client->origin, model->rotatedmaxs, maxs);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->rotatedmins, mins);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->rotatedmaxs, maxs);

                        }
                        }

-                       else if (ent->fields.client->angles[1] || ent->fields.client->avelocity[1])
+                       else if (PRVM_clientedictvector(ent, angles)[1] || PRVM_clientedictvector(ent, avelocity)[1])

                        {
                        {

-                               VectorAdd(ent->fields.client->origin, model->yawmins, mins);
-                               VectorAdd(ent->fields.client->origin, model->yawmaxs, maxs);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->yawmins, mins);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->yawmaxs, maxs);

                        }
                        else
                        {
                        }
                        else
                        {

-                               VectorAdd(ent->fields.client->origin, model->normalmins, mins);
-                               VectorAdd(ent->fields.client->origin, model->normalmaxs, maxs);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->normalmins, mins);
+                               VectorAdd(PRVM_clientedictvector(ent, origin), model->normalmaxs, maxs);

                        }
                }
                else
                {
                        // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily
                        }
                }
                else
                {
                        // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily

-                       VectorAdd(ent->fields.client->origin, ent->fields.client->mins, mins);
-                       VectorAdd(ent->fields.client->origin, ent->fields.client->maxs, maxs);
+                       VectorAdd(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+                       VectorAdd(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);

                }
        }
        else
        {
                }
        }
        else
        {

-               VectorAdd(ent->fields.client->origin, ent->fields.client->mins, mins);
-               VectorAdd(ent->fields.client->origin, ent->fields.client->maxs, maxs);
+               VectorAdd(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+               VectorAdd(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);

        }
 
        }
 

-       VectorCopy(mins, ent->fields.client->absmin);
-       VectorCopy(maxs, ent->fields.client->absmax);
+       VectorCopy(mins, PRVM_clientedictvector(ent, absmin));
+       VectorCopy(maxs, PRVM_clientedictvector(ent, absmax));

 
 

-       World_LinkEdict(&cl.world, ent, ent->fields.client->absmin, ent->fields.client->absmax);
+       World_LinkEdict(&cl.world, ent, PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax));

 }
 
 int CL_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
 }
 
 int CL_GenericHitSuperContentsMask(const prvm_edict_t *passedict)


@@ -202,16 +202,16 @@ int CL_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
                int dphitcontentsmask = (int)PRVM_clientedictfloat(passedict, dphitcontentsmask);
                if (dphitcontentsmask)
                        return dphitcontentsmask;
                int dphitcontentsmask = (int)PRVM_clientedictfloat(passedict, dphitcontentsmask);
                if (dphitcontentsmask)
                        return dphitcontentsmask;

-               else if (passedict->fields.client->solid == SOLID_SLIDEBOX)
+               else if (PRVM_clientedictfloat(passedict, solid) == SOLID_SLIDEBOX)

                {
                {

-                       if ((int)passedict->fields.client->flags & FL_MONSTER)
+                       if ((int)PRVM_clientedictfloat(passedict, flags) & FL_MONSTER)

                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
                        else
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
                }
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
                        else
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
                }

-               else if (passedict->fields.client->solid == SOLID_CORPSE)
+               else if (PRVM_clientedictfloat(passedict, solid) == SOLID_CORPSE)

                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;

-               else if (passedict->fields.client->solid == SOLID_TRIGGER)
+               else if (PRVM_clientedictfloat(passedict, solid) == SOLID_TRIGGER)

                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                else
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                else
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;


@@ -297,7 +297,7 @@ trace_t CL_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int
        // precalculate prog value for passedict for comparisons
        passedictprog = prog != NULL ? PRVM_EDICT_TO_PROG(passedict) : 0;
        // precalculate passedict's owner edict pointer for comparisons
        // precalculate prog value for passedict for comparisons
        passedictprog = prog != NULL ? PRVM_EDICT_TO_PROG(passedict) : 0;
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.client->owner) : NULL;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_clientedictedict(passedict, owner)) : NULL;

 
        // collide against network entities
        if (hitnetworkbrushmodels)
 
        // collide against network entities
        if (hitnetworkbrushmodels)


@@ -382,9 +382,9 @@ skipnetworkplayers:
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.client->solid < SOLID_BBOX)
+               if (PRVM_clientedictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.client->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_clientedictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -396,32 +396,32 @@ skipnetworkplayers:
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.client->owner)
+                       if (passedictprog == PRVM_clientedictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (VectorCompare(touch->fields.client->mins, touch->fields.client->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.client->flags & FL_MONSTER)))
+                       if (VectorCompare(PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.client->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_clientedictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.client->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_clientedictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                        model = CL_GetModelFromEdict(touch);
                if (model)
                        model = CL_GetModelFromEdict(touch);
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2], touch->fields.client->angles[0], touch->fields.client->angles[1], touch->fields.client->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2], PRVM_clientedictvector(touch, angles)[0], PRVM_clientedictvector(touch, angles)[1], PRVM_clientedictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);

-               if ((int)touch->fields.client->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask);
+               if ((int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask);

                else
                else

-                       Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask);
+                       Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask);

 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;
 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.client->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_clientedictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:


@@ -530,7 +530,7 @@ trace_t CL_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_
        // precalculate prog value for passedict for comparisons
        passedictprog = prog != NULL ? PRVM_EDICT_TO_PROG(passedict) : 0;
        // precalculate passedict's owner edict pointer for comparisons
        // precalculate prog value for passedict for comparisons
        passedictprog = prog != NULL ? PRVM_EDICT_TO_PROG(passedict) : 0;
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.client->owner) : NULL;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_clientedictedict(passedict, owner)) : NULL;

 
        // collide against network entities
        if (hitnetworkbrushmodels)
 
        // collide against network entities
        if (hitnetworkbrushmodels)


@@ -615,9 +615,9 @@ skipnetworkplayers:
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.client->solid < SOLID_BBOX)
+               if (PRVM_clientedictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.client->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_clientedictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -629,32 +629,32 @@ skipnetworkplayers:
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.client->owner)
+                       if (passedictprog == PRVM_clientedictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (VectorCompare(touch->fields.client->mins, touch->fields.client->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.client->flags & FL_MONSTER)))
+                       if (VectorCompare(PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.client->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_clientedictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.client->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_clientedictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                        model = CL_GetModelFromEdict(touch);
                if (model)
                        model = CL_GetModelFromEdict(touch);
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2], touch->fields.client->angles[0], touch->fields.client->angles[1], touch->fields.client->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2], PRVM_clientedictvector(touch, angles)[0], PRVM_clientedictvector(touch, angles)[1], PRVM_clientedictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);

-               if (type == MOVE_MISSILE && (int)touch->fields.client->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
+               if (type == MOVE_MISSILE && (int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);

                else
                else

-                       Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask, hitsurfaces);
+                       Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask, hitsurfaces);

 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;
 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.client->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_clientedictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:


@@ -804,7 +804,7 @@ trace_t CL_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
        // figure out whether this is a point trace for comparisons
        pointtrace = VectorCompare(clipmins, clipmaxs);
        // precalculate passedict's owner edict pointer for comparisons
        // figure out whether this is a point trace for comparisons
        pointtrace = VectorCompare(clipmins, clipmaxs);
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.client->owner) : NULL;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_clientedictedict(passedict, owner)) : NULL;

 
        // collide against network entities
        if (hitnetworkbrushmodels)
 
        // collide against network entities
        if (hitnetworkbrushmodels)


@@ -889,9 +889,9 @@ skipnetworkplayers:
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.client->solid < SOLID_BBOX)
+               if (PRVM_clientedictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.client->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_clientedictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -903,32 +903,32 @@ skipnetworkplayers:
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.client->owner)
+                       if (passedictprog == PRVM_clientedictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (pointtrace && VectorCompare(touch->fields.client->mins, touch->fields.client->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.client->flags & FL_MONSTER)))
+                       if (pointtrace && VectorCompare(PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.client->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_clientedictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.client->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_clientedictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                        model = CL_GetModelFromEdict(touch);
                if (model)
                        model = CL_GetModelFromEdict(touch);
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2], touch->fields.client->angles[0], touch->fields.client->angles[1], touch->fields.client->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2], PRVM_clientedictvector(touch, angles)[0], PRVM_clientedictvector(touch, angles)[1], PRVM_clientedictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.client->origin[0], touch->fields.client->origin[1], touch->fields.client->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_clientedictvector(touch, origin)[0], PRVM_clientedictvector(touch, origin)[1], PRVM_clientedictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);

-               if ((int)touch->fields.client->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
+               if ((int)PRVM_clientedictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);

                else
                else

-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.client->mins, touch->fields.client->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_clientedictvector(touch, mins), PRVM_clientedictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);

 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;
 
                if (cliptrace.realfraction > trace.realfraction && hitnetworkentity)
                        *hitnetworkentity = 0;

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.client->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_clientedictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:

diff --git a/clprogdefs.h b/clprogdefs.h
index b9354fbb599895ee3c2058345b5efdd6fbc1d58b..bee62abdcdd0a4e84d2319315d13928f3ba644ba 100644 (file)
--- a/clprogdefs.h
+++ b/clprogdefs.h
@@ -4,6 +4,7 @@
 #ifndef CLPROGDEFS_H
 #define CLPROGDEFS_H
 
 #ifndef CLPROGDEFS_H
 #define CLPROGDEFS_H
 

+/*

 typedef struct cl_globalvars_s
 {
        int                     pad[28];
 typedef struct cl_globalvars_s
 {
        int                     pad[28];


@@ -92,5 +93,6 @@ typedef struct cl_entvars_s
 } cl_entvars_t;
 
 #define CL_PROGHEADER_CRC 52195
 } cl_entvars_t;
 
 #define CL_PROGHEADER_CRC 52195

+*/

 
 #endif
 
 #endif

diff --git a/clvm_cmds.c b/clvm_cmds.c
index 3c153c8f110c716efbae0d0cb0ebcd28dd87aced..cedd20815f1da92d18f43f4d1356a13b75d530a6 100644 (file)
--- a/clvm_cmds.c
+++ b/clvm_cmds.c
@@ -34,7 +34,7 @@ void CSQC_RelinkCSQCEntities (void);
 static void VM_CL_makevectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
 static void VM_CL_makevectors (void)
 {
        VM_SAFEPARMCOUNT(1, VM_CL_makevectors);

-       AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up);
+       AngleVectors (PRVM_G_VECTOR(OFS_PARM0), PRVM_clientglobalvector(v_forward), PRVM_clientglobalvector(v_right), PRVM_clientglobalvector(v_up));

 }
 
 // #2 void(entity e, vector o) setorigin
 }
 
 // #2 void(entity e, vector o) setorigin


@@ -56,7 +56,7 @@ void VM_CL_setorigin (void)
                return;
        }
        org = PRVM_G_VECTOR(OFS_PARM1);
                return;
        }
        org = PRVM_G_VECTOR(OFS_PARM1);

-       VectorCopy (org, e->fields.client->origin);
+       VectorCopy (org, PRVM_clientedictvector(e, origin));

        CL_LinkEdict(e);
 }
 
        CL_LinkEdict(e);
 }
 


@@ -69,9 +69,9 @@ static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
                        PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
 
        // set derived values
                        PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
 
        // set derived values

-       VectorCopy (min, e->fields.client->mins);
-       VectorCopy (max, e->fields.client->maxs);
-       VectorSubtract (max, min, e->fields.client->size);
+       VectorCopy (min, PRVM_clientedictvector(e, mins));
+       VectorCopy (max, PRVM_clientedictvector(e, maxs));
+       VectorSubtract (max, min, PRVM_clientedictvector(e, size));

 
        CL_LinkEdict (e);
 }
 
        CL_LinkEdict (e);
 }


@@ -87,8 +87,8 @@ void VM_CL_setmodel (void)
        VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
 
        e = PRVM_G_EDICT(OFS_PARM0);
        VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
 
        e = PRVM_G_EDICT(OFS_PARM0);

-       e->fields.client->modelindex = 0;
-       e->fields.client->model = 0;
+       PRVM_clientedictfloat(e, modelindex) = 0;
+       PRVM_clientedictstring(e, model) = 0;

 
        m = PRVM_G_STRING(OFS_PARM1);
        mod = NULL;
 
        m = PRVM_G_STRING(OFS_PARM1);
        mod = NULL;


@@ -97,8 +97,8 @@ void VM_CL_setmodel (void)
                if (!strcmp(cl.csqc_model_precache[i]->name, m))
                {
                        mod = cl.csqc_model_precache[i];
                if (!strcmp(cl.csqc_model_precache[i]->name, m))
                {
                        mod = cl.csqc_model_precache[i];

-                       e->fields.client->model = PRVM_SetEngineString(mod->name);
-                       e->fields.client->modelindex = -(i+1);
+                       PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+                       PRVM_clientedictfloat(e, modelindex) = -(i+1);

                        break;
                }
        }
                        break;
                }
        }


@@ -109,8 +109,8 @@ void VM_CL_setmodel (void)
                        mod = cl.model_precache[i];
                        if (mod && !strcmp(mod->name, m))
                        {
                        mod = cl.model_precache[i];
                        if (mod && !strcmp(mod->name, m))
                        {

-                               e->fields.client->model = PRVM_SetEngineString(mod->name);
-                               e->fields.client->modelindex = i;
+                               PRVM_clientedictstring(e, model) = PRVM_SetEngineString(mod->name);
+                               PRVM_clientedictfloat(e, modelindex) = i;

                                break;
                        }
                }
                                break;
                        }
                }


@@ -320,10 +320,10 @@ trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
        vec3_t original_avelocity;
        trace_t trace;
 
        vec3_t original_avelocity;
        trace_t trace;
 

-       VectorCopy(tossent->fields.client->origin   , original_origin   );
-       VectorCopy(tossent->fields.client->velocity , original_velocity );
-       VectorCopy(tossent->fields.client->angles   , original_angles   );
-       VectorCopy(tossent->fields.client->avelocity, original_avelocity);
+       VectorCopy(PRVM_clientedictvector(tossent, origin)   , original_origin   );
+       VectorCopy(PRVM_clientedictvector(tossent, velocity) , original_velocity );
+       VectorCopy(PRVM_clientedictvector(tossent, angles)   , original_angles   );
+       VectorCopy(PRVM_clientedictvector(tossent, avelocity), original_avelocity);

 
        gravity = PRVM_clientedictfloat(tossent, gravity);
        if (!gravity)
 
        gravity = PRVM_clientedictfloat(tossent, gravity);
        if (!gravity)


@@ -332,21 +332,21 @@ trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
 
        for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
        {
 
        for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
        {

-               tossent->fields.client->velocity[2] -= gravity;
-               VectorMA (tossent->fields.client->angles, 0.05, tossent->fields.client->avelocity, tossent->fields.client->angles);
-               VectorScale (tossent->fields.client->velocity, 0.05, move);
-               VectorAdd (tossent->fields.client->origin, move, end);
-               trace = CL_TraceBox(tossent->fields.client->origin, tossent->fields.client->mins, tossent->fields.client->maxs, end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
-               VectorCopy (trace.endpos, tossent->fields.client->origin);
+               PRVM_clientedictvector(tossent, velocity)[2] -= gravity;
+               VectorMA (PRVM_clientedictvector(tossent, angles), 0.05, PRVM_clientedictvector(tossent, avelocity), PRVM_clientedictvector(tossent, angles));
+               VectorScale (PRVM_clientedictvector(tossent, velocity), 0.05, move);
+               VectorAdd (PRVM_clientedictvector(tossent, origin), move, end);
+               trace = CL_TraceBox(PRVM_clientedictvector(tossent, origin), PRVM_clientedictvector(tossent, mins), PRVM_clientedictvector(tossent, maxs), end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
+               VectorCopy (trace.endpos, PRVM_clientedictvector(tossent, origin));

 
                if (trace.fraction < 1)
                        break;
        }
 
 
                if (trace.fraction < 1)
                        break;
        }
 

-       VectorCopy(original_origin   , tossent->fields.client->origin   );
-       VectorCopy(original_velocity , tossent->fields.client->velocity );
-       VectorCopy(original_angles   , tossent->fields.client->angles   );
-       VectorCopy(original_avelocity, tossent->fields.client->avelocity);
+       VectorCopy(original_origin   , PRVM_clientedictvector(tossent, origin)   );
+       VectorCopy(original_velocity , PRVM_clientedictvector(tossent, velocity) );
+       VectorCopy(original_angles   , PRVM_clientedictvector(tossent, angles)   );
+       VectorCopy(original_avelocity, PRVM_clientedictvector(tossent, avelocity));

 
        return trace;
 }
 
        return trace;
 }


@@ -423,7 +423,7 @@ int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **li
        {
                if (ent->priv.required->free)
                        continue;
        {
                if (ent->priv.required->free)
                        continue;

-               if(BoxesOverlap(mins, maxs, ent->fields.client->absmin, ent->fields.client->absmax))
+               if(BoxesOverlap(mins, maxs, PRVM_clientedictvector(ent, absmin), PRVM_clientedictvector(ent, absmax)))

                        list[k++] = ent;
        }
        return k;
                        list[k++] = ent;
        }
        return k;


@@ -472,20 +472,20 @@ static void VM_CL_findradius (void)
                ent = touchedicts[i];
                // Quake did not return non-solid entities but darkplaces does
                // (note: this is the reason you can't blow up fallen zombies)
                ent = touchedicts[i];
                // Quake did not return non-solid entities but darkplaces does
                // (note: this is the reason you can't blow up fallen zombies)

-               if (ent->fields.client->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
+               if (PRVM_clientedictfloat(ent, solid) == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)

                        continue;
                // LordHavoc: compare against bounding box rather than center so it
                // doesn't miss large objects, and use DotProduct instead of Length
                // for a major speedup
                        continue;
                // LordHavoc: compare against bounding box rather than center so it
                // doesn't miss large objects, and use DotProduct instead of Length
                // for a major speedup

-               VectorSubtract(org, ent->fields.client->origin, eorg);
+               VectorSubtract(org, PRVM_clientedictvector(ent, origin), eorg);

                if (sv_gameplayfix_findradiusdistancetobox.integer)
                {
                if (sv_gameplayfix_findradiusdistancetobox.integer)
                {

-                       eorg[0] -= bound(ent->fields.client->mins[0], eorg[0], ent->fields.client->maxs[0]);
-                       eorg[1] -= bound(ent->fields.client->mins[1], eorg[1], ent->fields.client->maxs[1]);
-                       eorg[2] -= bound(ent->fields.client->mins[2], eorg[2], ent->fields.client->maxs[2]);
+                       eorg[0] -= bound(PRVM_clientedictvector(ent, mins)[0], eorg[0], PRVM_clientedictvector(ent, maxs)[0]);
+                       eorg[1] -= bound(PRVM_clientedictvector(ent, mins)[1], eorg[1], PRVM_clientedictvector(ent, maxs)[1]);
+                       eorg[2] -= bound(PRVM_clientedictvector(ent, mins)[2], eorg[2], PRVM_clientedictvector(ent, maxs)[2]);

                }
                else
                }
                else

-                       VectorMAMAM(1, eorg, -0.5f, ent->fields.client->mins, -0.5f, ent->fields.client->maxs, eorg);
+                       VectorMAMAM(1, eorg, -0.5f, PRVM_clientedictvector(ent, mins), -0.5f, PRVM_clientedictvector(ent, maxs), eorg);

                if (DotProduct(eorg, eorg) < radius2)
                {
                        PRVM_EDICTFIELDEDICT(ent, chainfield) = PRVM_EDICT_TO_PROG(chain);
                if (DotProduct(eorg, eorg) < radius2)
                {
                        PRVM_EDICTFIELDEDICT(ent, chainfield) = PRVM_EDICT_TO_PROG(chain);


@@ -508,7 +508,7 @@ static void VM_CL_droptofloor (void)
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 

-       ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
+       ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));

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


@@ -520,15 +520,15 @@ static void VM_CL_droptofloor (void)
                return;
        }
 
                return;
        }
 

-       VectorCopy (ent->fields.client->origin, end);
+       VectorCopy (PRVM_clientedictvector(ent, origin), end);

        end[2] -= 256;
 
        end[2] -= 256;
 

-       trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
+       trace = CL_TraceBox(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);

 
        if (trace.fraction != 1)
        {
 
        if (trace.fraction != 1)
        {

-               VectorCopy (trace.endpos, ent->fields.client->origin);
-               ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
+               VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));
+               PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) | FL_ONGROUND;

                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)
                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)


@@ -570,8 +570,8 @@ static void VM_CL_checkbottom (void)
        ent = PRVM_G_EDICT(OFS_PARM0);
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 
        ent = PRVM_G_EDICT(OFS_PARM0);
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 

-       VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
-       VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
+       VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+       VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);

 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks
 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks


@@ -739,7 +739,7 @@ void VM_CL_R_AddEntities (void)
        CSQC_RelinkAllEntities(drawmask);
        CL_RelinkLightFlashes();
 
        CSQC_RelinkAllEntities(drawmask);
        CL_RelinkLightFlashes();
 

-       prog->globals.client->time = cl.time;
+       PRVM_clientglobalfloat(time) = cl.time;

        for(i=1;i<prog->num_edicts;i++)
        {
                // so we can easily check if CSQC entity #edictnum is currently drawn
        for(i=1;i<prog->num_edicts;i++)
        {
                // so we can easily check if CSQC entity #edictnum is currently drawn


@@ -754,7 +754,7 @@ void VM_CL_R_AddEntities (void)
                CSQC_Predraw(ed);
                if(ed->priv.required->free)
                        continue;
                CSQC_Predraw(ed);
                if(ed->priv.required->free)
                        continue;

-               if(!((int)ed->fields.client->drawmask & drawmask))
+               if(!((int)PRVM_clientedictfloat(ed, drawmask) & drawmask))

                        continue;
                CSQC_AddRenderEdict(ed, i);
        }
                        continue;
                CSQC_AddRenderEdict(ed, i);
        }


@@ -1038,9 +1038,9 @@ void VM_CL_R_AddDynamicLight (void)
        coronaintensity = (pflags & PFLAGS_CORONA) != 0;
        castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
 
        coronaintensity = (pflags & PFLAGS_CORONA) != 0;
        castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
 

-       VectorScale(prog->globals.client->v_forward, radius, forward);
-       VectorScale(prog->globals.client->v_right, -radius, left);
-       VectorScale(prog->globals.client->v_up, radius, up);
+       VectorScale(PRVM_clientglobalvector(v_forward), radius, forward);
+       VectorScale(PRVM_clientglobalvector(v_right), -radius, left);
+       VectorScale(PRVM_clientglobalvector(v_up), radius, up);

        Matrix4x4_FromVectors(&matrix, forward, left, up, org);
 
        R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        Matrix4x4_FromVectors(&matrix, forward, left, up, org);
 
        R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);


@@ -1173,8 +1173,8 @@ static void VM_CL_setmodelindex (void)
 
        i = (int)PRVM_G_FLOAT(OFS_PARM1);
 
 
        i = (int)PRVM_G_FLOAT(OFS_PARM1);
 

-       t->fields.client->model = 0;
-       t->fields.client->modelindex = 0;
+       PRVM_clientedictstring(t, model) = 0;
+       PRVM_clientedictfloat(t, modelindex) = 0;

 
        if (!i)
                return;
 
        if (!i)
                return;


@@ -1185,8 +1185,8 @@ static void VM_CL_setmodelindex (void)
                VM_Warning("VM_CL_setmodelindex: null model\n");
                return;
        }
                VM_Warning("VM_CL_setmodelindex: null model\n");
                return;
        }

-       t->fields.client->model = PRVM_SetEngineString(model->name);
-       t->fields.client->modelindex = i;
+       PRVM_clientedictstring(t, model) = PRVM_SetEngineString(model->name);
+       PRVM_clientedictfloat(t, modelindex) = i;

 
        // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
        if (model)
 
        // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
        if (model)


@@ -1235,7 +1235,7 @@ static void VM_CL_trailparticles (void)
 
        if (i < 0)
                return;
 
        if (i < 0)
                return;

-       CL_ParticleEffect(i, 1, start, end, t->fields.client->velocity, t->fields.client->velocity, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
+       CL_ParticleEffect(i, 1, start, end, PRVM_clientedictvector(t, velocity), PRVM_clientedictvector(t, velocity), NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);

 }
 
 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
 }
 
 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)


@@ -1335,21 +1335,21 @@ static void VM_CL_getinputstate (void)
        {
                if (cl.movecmd[i].sequence == frame)
                {
        {
                if (cl.movecmd[i].sequence == frame)
                {

-                       VectorCopy(cl.movecmd[i].viewangles, prog->globals.client->input_angles);
-                       prog->globals.client->input_buttons = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
-                       prog->globals.client->input_movevalues[0] = cl.movecmd[i].forwardmove;
-                       prog->globals.client->input_movevalues[1] = cl.movecmd[i].sidemove;
-                       prog->globals.client->input_movevalues[2] = cl.movecmd[i].upmove;
-                       prog->globals.client->input_timelength = cl.movecmd[i].frametime;
+                       VectorCopy(cl.movecmd[i].viewangles, PRVM_clientglobalvector(input_angles));
+                       PRVM_clientglobalfloat(input_buttons) = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
+                       PRVM_clientglobalvector(input_movevalues)[0] = cl.movecmd[i].forwardmove;
+                       PRVM_clientglobalvector(input_movevalues)[1] = cl.movecmd[i].sidemove;
+                       PRVM_clientglobalvector(input_movevalues)[2] = cl.movecmd[i].upmove;
+                       PRVM_clientglobalfloat(input_timelength) = cl.movecmd[i].frametime;

                        if(cl.movecmd[i].crouch)
                        {
                        if(cl.movecmd[i].crouch)
                        {

-                               VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
-                               VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
+                               VectorCopy(cl.playercrouchmins, PRVM_clientglobalvector(pmove_mins));
+                               VectorCopy(cl.playercrouchmaxs, PRVM_clientglobalvector(pmove_maxs));

                        }
                        else
                        {
                        }
                        else
                        {

-                               VectorCopy(cl.playerstandmins, prog->globals.client->pmove_mins);
-                               VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
+                               VectorCopy(cl.playerstandmins, PRVM_clientglobalvector(pmove_mins));
+                               VectorCopy(cl.playerstandmaxs, PRVM_clientglobalvector(pmove_maxs));

                        }
                        PRVM_G_FLOAT(OFS_RETURN) = true;
                }
                        }
                        PRVM_G_FLOAT(OFS_RETURN) = true;
                }


@@ -1596,13 +1596,13 @@ static void VM_CL_makestatic (void)
 
                // copy it to the current state
                memset(staticent, 0, sizeof(*staticent));
 
                // copy it to the current state
                memset(staticent, 0, sizeof(*staticent));

-               staticent->render.model = CL_GetModelByIndex((int)ent->fields.client->modelindex);
-               staticent->render.framegroupblend[0].frame = (int)ent->fields.client->frame;
+               staticent->render.model = CL_GetModelByIndex((int)PRVM_clientedictfloat(ent, modelindex));
+               staticent->render.framegroupblend[0].frame = (int)PRVM_clientedictfloat(ent, frame);

                staticent->render.framegroupblend[0].lerp = 1;
                // make torchs play out of sync
                staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
                staticent->render.framegroupblend[0].lerp = 1;
                // make torchs play out of sync
                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.skinnum = (int)PRVM_clientedictfloat(ent, skin);
+               staticent->render.effects = (int)PRVM_clientedictfloat(ent, effects);

                staticent->render.alpha = PRVM_clientedictfloat(ent, alpha);
                staticent->render.scale = PRVM_clientedictfloat(ent, scale);
                VectorCopy(PRVM_clientedictvector(ent, colormod), staticent->render.colormod);
                staticent->render.alpha = PRVM_clientedictfloat(ent, alpha);
                staticent->render.scale = PRVM_clientedictfloat(ent, scale);
                VectorCopy(PRVM_clientedictvector(ent, colormod), staticent->render.colormod);


@@ -1622,12 +1622,12 @@ static void VM_CL_makestatic (void)
                if (renderflags & RF_USEAXIS)
                {
                        vec3_t left;
                if (renderflags & RF_USEAXIS)
                {
                        vec3_t left;

-                       VectorNegate(prog->globals.client->v_right, left);
-                       Matrix4x4_FromVectors(&staticent->render.matrix, prog->globals.client->v_forward, left, prog->globals.client->v_up, ent->fields.client->origin);
+                       VectorNegate(PRVM_clientglobalvector(v_right), left);
+                       Matrix4x4_FromVectors(&staticent->render.matrix, PRVM_clientglobalvector(v_forward), left, PRVM_clientglobalvector(v_up), PRVM_clientedictvector(ent, origin));

                        Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
                }
                else
                        Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
                }
                else

-                       Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], staticent->render.scale);
+                       Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], staticent->render.scale);

 
                // either fullbright or lit
                if(!r_fullbright.integer)
 
                // either fullbright or lit
                if(!r_fullbright.integer)


@@ -2134,11 +2134,11 @@ void VM_CL_setattachment (void)
        tagindex = 0;
        if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
        {
        tagindex = 0;
        if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
        {

-               modelindex = (int)tagentity->fields.client->modelindex;
+               modelindex = (int)PRVM_clientedictfloat(tagentity, modelindex);

                model = CL_GetModelByIndex(modelindex);
                if (model)
                {
                model = CL_GetModelByIndex(modelindex);
                if (model)
                {

-                       tagindex = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.client->skin, tagname);
+                       tagindex = Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(tagentity, skin), tagname);

                        if (tagindex == 0)
                                Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
                }
                        if (tagindex == 0)
                                Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
                }


@@ -2157,7 +2157,7 @@ int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
 {
        dp_model_t *model = CL_GetModelFromEdict(e);
        if (model)
 {
        dp_model_t *model = CL_GetModelFromEdict(e);
        if (model)

-               return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
+               return Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(e, skin), tagname);

        else
                return -1;
 }
        else
                return -1;
 }


@@ -2175,7 +2175,7 @@ int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, cons
         && (model = CL_GetModelFromEdict(e))
         && model->animscenes)
        {
         && (model = CL_GetModelFromEdict(e))
         && model->animscenes)
        {

-               r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
+               r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)PRVM_clientedictfloat(e, skin), e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);

 
                if(!r) // success?
                        *parentindex += 1;
 
                if(!r) // success?
                        *parentindex += 1;


@@ -2211,16 +2211,16 @@ void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatri
                vec3_t left;
                vec3_t up;
                vec3_t origin;
                vec3_t left;
                vec3_t up;
                vec3_t origin;

-               VectorScale(prog->globals.client->v_forward, scale, forward);
-               VectorScale(prog->globals.client->v_right, -scale, left);
-               VectorScale(prog->globals.client->v_up, scale, up);
-               VectorCopy(ent->fields.client->origin, origin);
+               VectorScale(PRVM_clientglobalvector(v_forward), scale, forward);
+               VectorScale(PRVM_clientglobalvector(v_right), -scale, left);
+               VectorScale(PRVM_clientglobalvector(v_up), scale, up);
+               VectorCopy(PRVM_clientedictvector(ent, origin), origin);

                Matrix4x4_FromVectors(out, forward, left, up, origin);
        }
        else
        {
                pitchsign = CL_GetPitchSign(ent);
                Matrix4x4_FromVectors(out, forward, left, up, origin);
        }
        else
        {
                pitchsign = CL_GetPitchSign(ent);

-               Matrix4x4_CreateFromQuakeEntity(out, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], pitchsign * ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], scale);
+               Matrix4x4_CreateFromQuakeEntity(out, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], pitchsign * PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], scale);

        }
 }
 
        }
 }
 


@@ -2303,7 +2303,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 
                /*
                // Cl_bob, ported from rendering code
 
                /*
                // Cl_bob, ported from rendering code

-               if (ent->fields.client->health > 0 && cl_bob.value && cl_bobcycle.value)
+               if (PRVM_clientedictfloat(ent, health) > 0 && cl_bob.value && cl_bobcycle.value)

                {
                        double bob, cycle;
                        // LordHavoc: this code is *weird*, but not replacable (I think it
                {
                        double bob, cycle;
                        // LordHavoc: this code is *weird*, but not replacable (I think it


@@ -2318,7 +2318,7 @@ int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
                                cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
                        // bob is proportional to velocity in the xy plane
                        // (don't count Z, or jumping messes it up)
                                cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
                        // bob is proportional to velocity in the xy plane
                        // (don't count Z, or jumping messes it up)

-                       bob = sqrt(ent->fields.client->velocity[0]*ent->fields.client->velocity[0] + ent->fields.client->velocity[1]*ent->fields.client->velocity[1])*cl_bob.value;
+                       bob = sqrt(PRVM_clientedictvector(ent, velocity)[0]*PRVM_clientedictvector(ent, velocity)[0] + PRVM_clientedictvector(ent, velocity)[1]*PRVM_clientedictvector(ent, velocity)[1])*cl_bob.value;

                        bob = bob*0.3 + bob*0.7*cycle;
                        Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
                }
                        bob = bob*0.3 + bob*0.7*cycle;
                        Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
                }


@@ -2379,8 +2379,8 @@ void VM_CL_gettaginfo (void)
        e = PRVM_G_EDICT(OFS_PARM0);
        tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
        returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
        e = PRVM_G_EDICT(OFS_PARM0);
        tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
        returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);

-       Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, le, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
-       VectorScale(le, -1, prog->globals.client->v_right);
+       Matrix4x4_ToVectors(&tag_matrix, PRVM_clientglobalvector(v_forward), le, PRVM_clientglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));
+       VectorScale(le, -1, PRVM_clientglobalvector(v_right));

        model = CL_GetModelFromEdict(e);
        VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
        VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
        model = CL_GetModelFromEdict(e);
        VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
        VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);


@@ -2919,7 +2919,7 @@ void VM_CL_GetEntity (void)
                        PRVM_G_FLOAT(OFS_RETURN) = Matrix4x4_ScaleFromMatrix(&cl.entities[entnum].render.matrix);
                        break;  
                case 6: // origin + v_forward, v_right, v_up
                        PRVM_G_FLOAT(OFS_RETURN) = Matrix4x4_ScaleFromMatrix(&cl.entities[entnum].render.matrix);
                        break;  
                case 6: // origin + v_forward, v_right, v_up

-                       Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN)); 
+                       Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, PRVM_clientglobalvector(v_forward), PRVM_clientglobalvector(v_right), PRVM_clientglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));        

                        break;  
                case 7: // alpha
                        PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.alpha;
                        break;  
                case 7: // alpha
                        PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.alpha;


@@ -3368,8 +3368,8 @@ qboolean CL_CheckBottom (prvm_edict_t *ent)
        int             x, y;
        float   mid, bottom;
 
        int             x, y;
        float   mid, bottom;
 

-       VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
-       VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
+       VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
+       VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);

 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks
 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks


@@ -3438,36 +3438,36 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        prvm_edict_t            *enemy;
 
 // try the move
        prvm_edict_t            *enemy;
 
 // try the move

-       VectorCopy (ent->fields.client->origin, oldorg);
-       VectorAdd (ent->fields.client->origin, move, neworg);
+       VectorCopy (PRVM_clientedictvector(ent, origin), oldorg);
+       VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);

 
 // flying monsters don't step up
 
 // flying monsters don't step up

-       if ( (int)ent->fields.client->flags & (FL_SWIM | FL_FLY) )
+       if ( (int)PRVM_clientedictfloat(ent, flags) & (FL_SWIM | FL_FLY) )

        {
        // try one move with vertical motion, then one without
                for (i=0 ; i<2 ; i++)
                {
        {
        // try one move with vertical motion, then one without
                for (i=0 ; i<2 ; i++)
                {

-                       VectorAdd (ent->fields.client->origin, move, neworg);
-                       enemy = PRVM_PROG_TO_EDICT(ent->fields.client->enemy);
+                       VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);
+                       enemy = PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy));

                        if (i == 0 && enemy != prog->edicts)
                        {
                        if (i == 0 && enemy != prog->edicts)
                        {

-                               dz = ent->fields.client->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.client->enemy)->fields.client->origin[2];
+                               dz = PRVM_clientedictvector(ent, origin)[2] - PRVM_clientedictvector(PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy)), origin)[2];

                                if (dz > 40)
                                        neworg[2] -= 8;
                                if (dz < 30)
                                        neworg[2] += 8;
                        }
                                if (dz > 40)
                                        neworg[2] -= 8;
                                if (dz < 30)
                                        neworg[2] += 8;
                        }

-                       trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+                       trace = CL_TraceBox(PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);

                        if (settrace)
                                CL_VM_SetTraceGlobals(&trace, svent);
 
                        if (trace.fraction == 1)
                        {
                                VectorCopy(trace.endpos, traceendpos);
                        if (settrace)
                                CL_VM_SetTraceGlobals(&trace, svent);
 
                        if (trace.fraction == 1)
                        {
                                VectorCopy(trace.endpos, traceendpos);

-                               if (((int)ent->fields.client->flags & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
+                               if (((int)PRVM_clientedictfloat(ent, flags) & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))

                                        return false;   // swim monster left water
 
                                        return false;   // swim monster left water
 

-                               VectorCopy (traceendpos, ent->fields.client->origin);
+                               VectorCopy (traceendpos, PRVM_clientedictvector(ent, origin));

                                if (relink)
                                        CL_LinkEdict(ent);
                                return true;
                                if (relink)
                                        CL_LinkEdict(ent);
                                return true;


@@ -3485,14 +3485,14 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        VectorCopy (neworg, end);
        end[2] -= sv_stepheight.value*2;
 
        VectorCopy (neworg, end);
        end[2] -= sv_stepheight.value*2;
 

-       trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+       trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);

        if (settrace)
                CL_VM_SetTraceGlobals(&trace, svent);
 
        if (trace.startsolid)
        {
                neworg[2] -= sv_stepheight.value;
        if (settrace)
                CL_VM_SetTraceGlobals(&trace, svent);
 
        if (trace.startsolid)
        {
                neworg[2] -= sv_stepheight.value;

-               trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
+               trace = CL_TraceBox(neworg, PRVM_clientedictvector(ent, mins), PRVM_clientedictvector(ent, maxs), end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);

                if (settrace)
                        CL_VM_SetTraceGlobals(&trace, svent);
                if (trace.startsolid)
                if (settrace)
                        CL_VM_SetTraceGlobals(&trace, svent);
                if (trace.startsolid)


@@ -3501,12 +3501,12 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        if (trace.fraction == 1)
        {
        // if monster had the ground pulled out, go ahead and fall
        if (trace.fraction == 1)
        {
        // if monster had the ground pulled out, go ahead and fall

-               if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
+               if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )

                {
                {

-                       VectorAdd (ent->fields.client->origin, move, ent->fields.client->origin);
+                       VectorAdd (PRVM_clientedictvector(ent, origin), move, PRVM_clientedictvector(ent, origin));

                        if (relink)
                                CL_LinkEdict(ent);
                        if (relink)
                                CL_LinkEdict(ent);

-                       ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_ONGROUND;
+                       PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_ONGROUND;

                        return true;
                }
 
                        return true;
                }
 


@@ -3514,23 +3514,23 @@ qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        }
 
 // check point traces down for dangling corners
        }
 
 // check point traces down for dangling corners

-       VectorCopy (trace.endpos, ent->fields.client->origin);
+       VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));

 
        if (!CL_CheckBottom (ent))
        {
 
        if (!CL_CheckBottom (ent))
        {

-               if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
+               if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )

                {       // entity had floor mostly pulled out from underneath it
                        // and is trying to correct
                        if (relink)
                                CL_LinkEdict(ent);
                        return true;
                }
                {       // entity had floor mostly pulled out from underneath it
                        // and is trying to correct
                        if (relink)
                                CL_LinkEdict(ent);
                        return true;
                }

-               VectorCopy (oldorg, ent->fields.client->origin);
+               VectorCopy (oldorg, PRVM_clientedictvector(ent, origin));

                return false;
        }
 
                return false;
        }
 

-       if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
-               ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
+       if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
+               PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_PARTIALGROUND;

 
        PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 
 
        PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 


@@ -3561,7 +3561,7 @@ static void VM_CL_walkmove (void)
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 

-       ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
+       ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));

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


@@ -3576,7 +3576,7 @@ static void VM_CL_walkmove (void)
        dist = PRVM_G_FLOAT(OFS_PARM1);
        settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
 
        dist = PRVM_G_FLOAT(OFS_PARM1);
        settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
 

-       if ( !( (int)ent->fields.client->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
+       if ( !( (int)PRVM_clientedictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )

                return;
 
        yaw = yaw*M_PI*2 / 360;
                return;
 
        yaw = yaw*M_PI*2 / 360;


@@ -3587,14 +3587,14 @@ static void VM_CL_walkmove (void)
 
 // save program state, because CL_movestep may call other progs
        oldf = prog->xfunction;
 
 // save program state, because CL_movestep may call other progs
        oldf = prog->xfunction;

-       oldself = prog->globals.client->self;
+       oldself = PRVM_clientglobaledict(self);

 
        PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
 
 
 // restore program state
        prog->xfunction = oldf;
 
        PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
 
 
 // restore program state
        prog->xfunction = oldf;

-       prog->globals.client->self = oldself;
+       PRVM_clientglobaledict(self) = oldself;

 }
 
 /*
 }
 
 /*


@@ -3645,8 +3645,8 @@ static void VM_CL_checkpvs (void)
                return;
        }
 
                return;
        }
 

-       VectorAdd(viewee->fields.server->origin, viewee->fields.server->mins, mi);
-       VectorAdd(viewee->fields.server->origin, viewee->fields.server->maxs, ma);
+       VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, mins), mi);
+       VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, maxs), ma);

 
 #if 1
        if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
 
 #if 1
        if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)


@@ -3810,18 +3810,18 @@ static void VM_CL_skel_get_bonerel(void)
        matrix4x4_t matrix;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));
        matrix4x4_t matrix;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));

-       VectorClear(prog->globals.client->v_forward);
-       VectorClear(prog->globals.client->v_right);
-       VectorClear(prog->globals.client->v_up);
+       VectorClear(PRVM_clientglobalvector(v_forward));
+       VectorClear(PRVM_clientglobalvector(v_right));
+       VectorClear(PRVM_clientglobalvector(v_up));

        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        matrix = skeleton->relativetransforms[bonenum];
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        matrix = skeleton->relativetransforms[bonenum];
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);

-       VectorCopy(forward, prog->globals.client->v_forward);
-       VectorNegate(left, prog->globals.client->v_right);
-       VectorCopy(up, prog->globals.client->v_up);
+       VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+       VectorNegate(left, PRVM_clientglobalvector(v_right));
+       VectorCopy(up, PRVM_clientglobalvector(v_up));

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


@@ -3835,9 +3835,9 @@ static void VM_CL_skel_get_boneabs(void)
        matrix4x4_t temp;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));
        matrix4x4_t temp;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));

-       VectorClear(prog->globals.client->v_forward);
-       VectorClear(prog->globals.client->v_right);
-       VectorClear(prog->globals.client->v_up);
+       VectorClear(PRVM_clientglobalvector(v_forward));
+       VectorClear(PRVM_clientglobalvector(v_right));
+       VectorClear(PRVM_clientglobalvector(v_up));

        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)


@@ -3850,9 +3850,9 @@ static void VM_CL_skel_get_boneabs(void)
                Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
        }
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
                Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
        }
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);

-       VectorCopy(forward, prog->globals.client->v_forward);
-       VectorNegate(left, prog->globals.client->v_right);
-       VectorCopy(up, prog->globals.client->v_up);
+       VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+       VectorNegate(left, PRVM_clientglobalvector(v_right));
+       VectorCopy(up, PRVM_clientglobalvector(v_up));

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


@@ -3868,9 +3868,9 @@ static void VM_CL_skel_set_bone(void)
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        skeleton->relativetransforms[bonenum] = matrix;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        skeleton->relativetransforms[bonenum] = matrix;


@@ -3890,9 +3890,9 @@ static void VM_CL_skel_mul_bone(void)
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        temp = skeleton->relativetransforms[bonenum];
        Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        temp = skeleton->relativetransforms[bonenum];
        Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);


@@ -3912,9 +3912,9 @@ static void VM_CL_skel_mul_bones(void)
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        firstbone = max(0, firstbone);
        lastbone = min(lastbone, skeleton->model->num_bones - 1);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        firstbone = max(0, firstbone);
        lastbone = min(lastbone, skeleton->model->num_bones - 1);

diff --git a/csprogs.c b/csprogs.c
index 75104721549811e89e7aca7586803fd6dd37244b..6a6ca9938dc5f628ae33f94d45d39e01500e48aa 100644 (file)
--- a/csprogs.c
+++ b/csprogs.c
@@ -244,29 +244,29 @@ void CSQC_R_RecalcView (void);
 static void CSQC_SetGlobals (void)
 {
        CSQC_BEGIN
 static void CSQC_SetGlobals (void)
 {
        CSQC_BEGIN

-               prog->globals.client->time = cl.time;
-               prog->globals.client->frametime = max(0, cl.time - cl.oldtime);
-               prog->globals.client->servercommandframe = cls.servermovesequence;
-               prog->globals.client->clientcommandframe = cl.movecmd[0].sequence;
-               VectorCopy(cl.viewangles, prog->globals.client->input_angles);
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobalfloat(frametime) = max(0, cl.time - cl.oldtime);
+               PRVM_clientglobalfloat(servercommandframe) = cls.servermovesequence;
+               PRVM_clientglobalfloat(clientcommandframe) = cl.movecmd[0].sequence;
+               VectorCopy(cl.viewangles, PRVM_clientglobalvector(input_angles));

                // // FIXME: this actually belongs into getinputstate().. [12/17/2007 Black]
                // // FIXME: this actually belongs into getinputstate().. [12/17/2007 Black]

-               prog->globals.client->input_buttons = cl.movecmd[0].buttons;
-               VectorSet(prog->globals.client->input_movevalues, cl.movecmd[0].forwardmove, cl.movecmd[0].sidemove, cl.movecmd[0].upmove);
+               PRVM_clientglobalfloat(input_buttons) = cl.movecmd[0].buttons;
+               VectorSet(PRVM_clientglobalvector(input_movevalues), cl.movecmd[0].forwardmove, cl.movecmd[0].sidemove, cl.movecmd[0].upmove);

                VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
                VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
 
                // LordHavoc: Spike says not to do this, but without pmove_org the
                // CSQC is useless as it can't alter the view origin without
                // completely replacing it
                VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
                VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
 
                // LordHavoc: Spike says not to do this, but without pmove_org the
                // CSQC is useless as it can't alter the view origin without
                // 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);
+               Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, PRVM_clientglobalvector(pmove_org));
+               VectorCopy(cl.movement_velocity, PRVM_clientglobalvector(pmove_vel));

                PRVM_clientglobalfloat(pmove_onground) = cl.onground;
                PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;
 
                VectorCopy(cl.viewangles, PRVM_clientglobalvector(view_angles));
                VectorCopy(cl.punchangle, PRVM_clientglobalvector(view_punchangle));
                VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));
                PRVM_clientglobalfloat(pmove_onground) = cl.onground;
                PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;
 
                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;
+               PRVM_clientglobalfloat(maxclients) = cl.maxclients;

 
                CSQC_R_RecalcView();
        CSQC_END
 
                CSQC_R_RecalcView();
        CSQC_END


@@ -275,25 +275,25 @@ static void CSQC_SetGlobals (void)
 void CSQC_Predraw (prvm_edict_t *ed)
 {
        int b;
 void CSQC_Predraw (prvm_edict_t *ed)
 {
        int b;

-       if(!ed->fields.client->predraw)
+       if(!PRVM_clientedictfunction(ed, predraw))

                return;
                return;

-       b = prog->globals.client->self;
-       prog->globals.client->self = PRVM_EDICT_TO_PROG(ed);
-       PRVM_ExecuteProgram(ed->fields.client->predraw, "CSQC_Predraw: NULL function\n");
-       prog->globals.client->self = b;
+       b = PRVM_clientglobaledict(self);
+       PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
+       PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, predraw), "CSQC_Predraw: NULL function\n");
+       PRVM_clientglobaledict(self) = b;

 }
 
 void CSQC_Think (prvm_edict_t *ed)
 {
        int b;
 }
 
 void CSQC_Think (prvm_edict_t *ed)
 {
        int b;

-       if(ed->fields.client->think)
-       if(ed->fields.client->nextthink && ed->fields.client->nextthink <= prog->globals.client->time)
+       if(PRVM_clientedictfunction(ed, think))
+       if(PRVM_clientedictfloat(ed, nextthink) && PRVM_clientedictfloat(ed, nextthink) <= PRVM_clientglobalfloat(time))

        {
        {

-               ed->fields.client->nextthink = 0;
-               b = prog->globals.client->self;
-               prog->globals.client->self = PRVM_EDICT_TO_PROG(ed);
-               PRVM_ExecuteProgram(ed->fields.client->think, "CSQC_Think: NULL function\n");
-               prog->globals.client->self = b;
+               PRVM_clientedictfloat(ed, nextthink) = 0;
+               b = PRVM_clientglobaledict(self);
+               PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
+               PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, think), "CSQC_Think: NULL function\n");
+               PRVM_clientglobaledict(self) = b;

        }
 }
 
        }
 }
 


@@ -339,14 +339,14 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
        entrender->userwavefunc_param[3] = PRVM_clientedictfloat(ed, userwavefunc_param3);
 
        entrender->model = model;
        entrender->userwavefunc_param[3] = PRVM_clientedictfloat(ed, userwavefunc_param3);
 
        entrender->model = model;

-       entrender->skinnum = (int)ed->fields.client->skin;
+       entrender->skinnum = (int)PRVM_clientedictfloat(ed, skin);

        entrender->effects |= entrender->model->effects;
        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);
        entrender->effects |= entrender->model->effects;
        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(PRVM_clientedictfloat(ed, effects))  entrender->effects |= (int)PRVM_clientedictfloat(ed, effects);

        if (!entrender->alpha)
                entrender->alpha = 1.0f;
        if (!entrender->scale)
        if (!entrender->alpha)
                entrender->alpha = 1.0f;
        if (!entrender->scale)


@@ -379,7 +379,7 @@ qboolean CSQC_AddRenderEdict(prvm_edict_t *ed, int edictnum)
                if(renderflags & RF_ADDITIVE)           entrender->flags |= RENDER_ADDITIVE;
        }
 
                if(renderflags & RF_ADDITIVE)           entrender->flags |= RENDER_ADDITIVE;
        }
 

-       c = (int)ed->fields.client->colormap;
+       c = (int)PRVM_clientedictfloat(ed, colormap);

        if (c <= 0)
                CL_SetEntityColormapColors(entrender, -1);
        else if (c <= cl.maxclients && cl.scores != NULL)
        if (c <= 0)
                CL_SetEntityColormapColors(entrender, -1);
        else if (c <= cl.maxclients && cl.scores != NULL)


@@ -439,8 +439,8 @@ qboolean CL_VM_InputEvent (qboolean down, int key, int ascii)
                        r = false;
                else
                {
                        r = false;
                else
                {

-                       prog->globals.client->time = cl.time;
-                       prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+                       PRVM_clientglobalfloat(time) = cl.time;
+                       PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                        PRVM_G_FLOAT(OFS_PARM0) = !down; // 0 is down, 1 is up
                        PRVM_G_FLOAT(OFS_PARM1) = key;
                        PRVM_G_FLOAT(OFS_PARM2) = ascii;
                        PRVM_G_FLOAT(OFS_PARM0) = !down; // 0 is down, 1 is up
                        PRVM_G_FLOAT(OFS_PARM1) = key;
                        PRVM_G_FLOAT(OFS_PARM2) = ascii;


@@ -463,8 +463,8 @@ qboolean CL_VM_UpdateView (void)
        R_TimeReport("pre-UpdateView");
        CSQC_BEGIN
                //VectorCopy(cl.viewangles, oldangles);
        R_TimeReport("pre-UpdateView");
        CSQC_BEGIN
                //VectorCopy(cl.viewangles, oldangles);

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                CSQC_SetGlobals();
                // clear renderable entity and light lists to prevent crashes if the
                // CSQC_UpdateView function does not call R_ClearScene as it should
                CSQC_SetGlobals();
                // clear renderable entity and light lists to prevent crashes if the
                // CSQC_UpdateView function does not call R_ClearScene as it should


@@ -492,8 +492,8 @@ qboolean CL_VM_ConsoleCommand (const char *cmd)
        CSQC_BEGIN
        if (PRVM_clientfunction(CSQC_ConsoleCommand))
        {
        CSQC_BEGIN
        if (PRVM_clientfunction(CSQC_ConsoleCommand))
        {

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(cmd);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(cmd);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");


@@ -514,8 +514,8 @@ qboolean CL_VM_Parse_TempEntity (void)
        if(PRVM_clientfunction(CSQC_Parse_TempEntity))
        {
                t = msg_readcount;
        if(PRVM_clientfunction(CSQC_Parse_TempEntity))
        {
                t = msg_readcount;

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_TempEntity), "QC function CSQC_Parse_TempEntity is missing");
                r = CSQC_RETURNVAL != 0;
                if(!r)
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_TempEntity), "QC function CSQC_Parse_TempEntity is missing");
                r = CSQC_RETURNVAL != 0;
                if(!r)


@@ -596,8 +596,8 @@ void CL_VM_Parse_StuffCmd (const char *msg)
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Parse_StuffCmd))
        {
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Parse_StuffCmd))
        {

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_StuffCmd), "QC function CSQC_Parse_StuffCmd is missing");
                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_StuffCmd), "QC function CSQC_Parse_StuffCmd is missing");


@@ -611,8 +611,8 @@ void CL_VM_Parse_StuffCmd (const char *msg)
 static void CL_VM_Parse_Print (const char *msg)
 {
        int restorevm_tempstringsbuf_cursize;
 static void CL_VM_Parse_Print (const char *msg)
 {
        int restorevm_tempstringsbuf_cursize;

-       prog->globals.client->time = cl.time;
-       prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+       PRVM_clientglobalfloat(time) = cl.time;
+       PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

        restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
        PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_Print), "QC function CSQC_Parse_Print is missing");
        restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
        PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_Print), "QC function CSQC_Parse_Print is missing");


@@ -663,8 +663,8 @@ void CL_VM_Parse_CenterPrint (const char *msg)
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
        {
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
        {

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_CenterPrint), "QC function CSQC_Parse_CenterPrint is missing");
                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_CenterPrint), "QC function CSQC_Parse_CenterPrint is missing");


@@ -701,8 +701,8 @@ qboolean CL_VM_Event_Sound(int sound_num, float volume, int channel, float atten
                CSQC_BEGIN
                if(PRVM_clientfunction(CSQC_Event_Sound))
                {
                CSQC_BEGIN
                if(PRVM_clientfunction(CSQC_Event_Sound))
                {

-                       prog->globals.client->time = cl.time;
-                       prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+                       PRVM_clientglobalfloat(time) = cl.time;
+                       PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                        PRVM_G_FLOAT(OFS_PARM0) = ent;
                        PRVM_G_FLOAT(OFS_PARM1) = channel;
                        PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(cl.sound_name[sound_num] );
                        PRVM_G_FLOAT(OFS_PARM0) = ent;
                        PRVM_G_FLOAT(OFS_PARM1) = channel;
                        PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(cl.sound_name[sound_num] );


@@ -757,8 +757,8 @@ float CL_VM_Event (float event)             //[515]: needed ? I'd say "YES", but don't know
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Event))
        {
        CSQC_BEGIN
        if(PRVM_clientfunction(CSQC_Event))
        {

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];

                PRVM_G_FLOAT(OFS_PARM0) = event;
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event), "QC function CSQC_Event is missing");
                r = CSQC_RETURNVAL;
                PRVM_G_FLOAT(OFS_PARM0) = event;
                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event), "QC function CSQC_Event is missing");
                r = CSQC_RETURNVAL;


@@ -777,18 +777,18 @@ void CSQC_ReadEntities (void)
        }
 
        CSQC_BEGIN
        }
 
        CSQC_BEGIN

-               prog->globals.client->time = cl.time;
-               oldself = prog->globals.client->self;
+               PRVM_clientglobalfloat(time) = cl.time;
+               oldself = PRVM_clientglobaledict(self);

                while(1)
                {
                        entnum = MSG_ReadShort();
                        if(!entnum || msg_badread)
                                break;
                        realentnum = entnum & 0x7FFF;
                while(1)
                {
                        entnum = MSG_ReadShort();
                        if(!entnum || msg_badread)
                                break;
                        realentnum = entnum & 0x7FFF;

-                       prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum];
+                       PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum];

                        if(entnum & 0x8000)
                        {
                        if(entnum & 0x8000)
                        {

-                               if(prog->globals.client->self)
+                               if(PRVM_clientglobaledict(self))

                                {
                                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Remove), "QC function CSQC_Ent_Remove is missing");
                                        cl.csqc_server2csqcentitynumber[realentnum] = 0;
                                {
                                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Remove), "QC function CSQC_Ent_Remove is missing");
                                        cl.csqc_server2csqcentitynumber[realentnum] = 0;


@@ -804,14 +804,14 @@ void CSQC_ReadEntities (void)
                        }
                        else
                        {
                        }
                        else
                        {

-                               if(!prog->globals.client->self)
+                               if(!PRVM_clientglobaledict(self))

                                {
                                        if(!PRVM_clientfunction(CSQC_Ent_Spawn))
                                        {
                                                prvm_edict_t    *ed;
                                                ed = PRVM_ED_Alloc();
                                {
                                        if(!PRVM_clientfunction(CSQC_Ent_Spawn))
                                        {
                                                prvm_edict_t    *ed;
                                                ed = PRVM_ED_Alloc();

-                                               ed->fields.client->entnum = realentnum;
-                                               prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed);
+                                               PRVM_clientedictfloat(ed, entnum) = realentnum;
+                                               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed);

                                        }
                                        else
                                        {
                                        }
                                        else
                                        {


@@ -819,9 +819,9 @@ void CSQC_ReadEntities (void)
                                                // the qc function should set entnum, too (this way it also can return world [2/1/2008 Andreas]
                                                PRVM_G_FLOAT(OFS_PARM0) = (float) realentnum;
                                                // make sure no one gets wrong ideas
                                                // the qc function should set entnum, too (this way it also can return world [2/1/2008 Andreas]
                                                PRVM_G_FLOAT(OFS_PARM0) = (float) realentnum;
                                                // make sure no one gets wrong ideas

-                                               prog->globals.client->self = 0;
+                                               PRVM_clientglobaledict(self) = 0;

                                                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Spawn), "QC function CSQC_Ent_Spawn is missing");
                                                PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Spawn), "QC function CSQC_Ent_Spawn is missing");

-                                               prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT( PRVM_G_INT( OFS_RETURN ) );
+                                               PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT( PRVM_G_INT( OFS_RETURN ) );

                                        }
                                        PRVM_G_FLOAT(OFS_PARM0) = 1;
                                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
                                        }
                                        PRVM_G_FLOAT(OFS_PARM0) = 1;
                                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");


@@ -832,7 +832,7 @@ void CSQC_ReadEntities (void)
                                }
                        }
                }
                                }
                        }
                }

-               prog->globals.client->self = oldself;
+               PRVM_clientglobaledict(self) = oldself;

        CSQC_END
 }
 
        CSQC_END
 }
 


@@ -872,7 +872,7 @@ void CL_VM_CB_FreeEdict(prvm_edict_t *ed)
        R_DecalSystem_Reset(&entrender->decalsystem);
        memset(entrender, 0, sizeof(*entrender));
        World_UnlinkEdict(ed);
        R_DecalSystem_Reset(&entrender->decalsystem);
        memset(entrender, 0, sizeof(*entrender));
        World_UnlinkEdict(ed);

-       memset(ed->fields.client, 0, sizeof(*ed->fields.client));
+       memset(ed->fields.vp, 0, prog->entityfields * 4);

        VM_RemoveEdictSkeleton(ed);
        World_Physics_RemoveFromEntity(&cl.world, ed);
        World_Physics_RemoveJointFromEntity(&cl.world, ed);
        VM_RemoveEdictSkeleton(ed);
        World_Physics_RemoveFromEntity(&cl.world, ed);
        World_Physics_RemoveJointFromEntity(&cl.world, ed);


@@ -890,9 +890,9 @@ void CL_VM_CB_CountEdicts(void)
                if (ent->priv.server->free)
                        continue;
                active++;
                if (ent->priv.server->free)
                        continue;
                active++;

-               if (ent->fields.client->solid)
+               if (PRVM_clientedictfloat(ent, solid))

                        solid++;
                        solid++;

-               if (ent->fields.client->model)
+               if (PRVM_clientedictstring(ent, model))

                        models++;
        }
 
                        models++;
        }
 


@@ -1017,7 +1017,6 @@ void CL_VM_Init (void)
 
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
 
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);

-       prog->headercrc = CL_PROGHEADER_CRC;

        prog->edictprivate_size = 0; // no private struct used
        prog->name = CL_NAME;
        prog->num_edicts = 1;
        prog->edictprivate_size = 0; // no private struct used
        prog->name = CL_NAME;
        prog->num_edicts = 1;


@@ -1082,16 +1081,16 @@ void CL_VM_Init (void)
                prog->flag |= PRVM_OP_STATE;
 
        // set time
                prog->flag |= PRVM_OP_STATE;
 
        // set time

-       prog->globals.client->time = cl.time;
-       prog->globals.client->self = 0;
+       PRVM_clientglobalfloat(time) = cl.time;
+       PRVM_clientglobaledict(self) = 0;

 
 

-       prog->globals.client->mapname = PRVM_SetEngineString(cl.worldname);
-       prog->globals.client->player_localentnum = cl.playerentity;
+       PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(cl.worldname);
+       PRVM_clientglobalfloat(player_localentnum) = cl.playerentity;

 
        // set map description (use world entity 0)
        PRVM_clientedictstring(prog->edicts, message) = PRVM_SetEngineString(cl.worldmessage);
 
        // set map description (use world entity 0)
        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, PRVM_clientedictvector(prog->edicts, mins));
+       VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, maxs));

 
        // call the prog init
        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");
 
        // call the prog init
        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");


@@ -1114,8 +1113,8 @@ void CL_VM_ShutDown (void)
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN
        if(!cl.csqc_loaded)
                return;
        CSQC_BEGIN

-               prog->globals.client->time = cl.time;
-               prog->globals.client->self = 0;
+               PRVM_clientglobalfloat(time) = cl.time;
+               PRVM_clientglobaledict(self) = 0;

                if (PRVM_clientfunction(CSQC_Shutdown))
                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
                PRVM_ResetProg();
                if (PRVM_clientfunction(CSQC_Shutdown))
                        PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
                PRVM_ResetProg();


@@ -1140,7 +1139,7 @@ qboolean CL_VM_GetEntitySoundOrigin(int entnum, vec3_t out)
        if(!ed->priv.required->free)
        {
                mod = CL_GetModelFromEdict(ed);
        if(!ed->priv.required->free)
        {
                mod = CL_GetModelFromEdict(ed);

-               VectorCopy(ed->fields.client->origin, out);
+               VectorCopy(PRVM_clientedictvector(ed, origin), out);

                if(CL_GetTagMatrix (&matrix, ed, 0) == 0)
                        Matrix4x4_OriginFromMatrix(&matrix, out);
                if (mod && mod->soundfromcenter)
                if(CL_GetTagMatrix (&matrix, ed, 0) == 0)
                        Matrix4x4_OriginFromMatrix(&matrix, out);
                if (mod && mod->soundfromcenter)


@@ -1171,8 +1170,8 @@ qboolean CL_VM_TransformView(int entnum, matrix4x4_t *viewmatrix, mplane_t *clip
                        {
                                Matrix4x4_ToVectors(viewmatrix, forward, left, up, origin);
                                AnglesFromVectors(ang, forward, up, false);
                        {
                                Matrix4x4_ToVectors(viewmatrix, forward, left, up, origin);
                                AnglesFromVectors(ang, forward, up, false);

-                               prog->globals.client->time = cl.time;
-                               prog->globals.client->self = entnum;
+                               PRVM_clientglobalfloat(time) = cl.time;
+                               PRVM_clientglobaledict(self) = entnum;

                                VectorCopy(origin, PRVM_G_VECTOR(OFS_PARM0));
                                VectorCopy(ang, PRVM_G_VECTOR(OFS_PARM1));
                                VectorCopy(forward, PRVM_clientglobalvector(v_forward));
                                VectorCopy(origin, PRVM_G_VECTOR(OFS_PARM0));
                                VectorCopy(ang, PRVM_G_VECTOR(OFS_PARM1));
                                VectorCopy(forward, PRVM_clientglobalvector(v_forward));

diff --git a/gl_rmain.c b/gl_rmain.c
index 35b11c2a139c67585f3e6f10e2540c97a22683a6..8574aeb2db3c3dc43ed43ee2915348e17d72a800 100644 (file)
--- a/gl_rmain.c
+++ b/gl_rmain.c
@@ -7141,7 +7141,7 @@ static void R_DrawEntityBBoxes_Callback(const entity_render_t *ent, const rtligh
        for (i = 0;i < numsurfaces;i++)
        {
                edict = PRVM_EDICT_NUM(surfacelist[i]);
        for (i = 0;i < numsurfaces;i++)
        {
                edict = PRVM_EDICT_NUM(surfacelist[i]);

-               switch ((int)edict->fields.server->solid)
+               switch ((int)PRVM_serveredictfloat(edict, solid))

                {
                        case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
                        case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;
                {
                        case SOLID_NOT:      Vector4Set(color, 1, 1, 1, 0.05);break;
                        case SOLID_TRIGGER:  Vector4Set(color, 1, 0, 1, 0.10);break;

diff --git a/host.c b/host.c
index d8909c14a884c0cc5adad10d9ac7e6ada2074294..e7a37d9bea54788470e245d92d35c7e2708b67ef 100644 (file)
--- a/host.c
+++ b/host.c
@@ -468,11 +468,11 @@ void SV_DropClient(qboolean crash)
        {
                // call the prog function for removing a client
                // this will set the body to a dead frame, among other things
        {
                // call the prog function for removing a client
                // this will set the body to a dead frame, among other things

-               int saveSelf = prog->globals.server->self;
+               int saveSelf = PRVM_serverglobaledict(self);

                host_client->clientconnectcalled = false;
                host_client->clientconnectcalled = false;

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-               PRVM_ExecuteProgram(prog->globals.server->ClientDisconnect, "QC function ClientDisconnect is missing");
-               prog->globals.server->self = saveSelf;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_ExecuteProgram(PRVM_serverfunction(ClientDisconnect), "QC function ClientDisconnect is missing");
+               PRVM_serverglobaledict(self) = saveSelf;

        }
 
        if (host_client->netconnection)
        }
 
        if (host_client->netconnection)

diff --git a/host_cmd.c b/host_cmd.c
index 1f12018f1b74385251e3e1d4a15f2fbd2096f7bb..6f368f03ee0310dd61db62695819f208cc078490 100644 (file)
--- a/host_cmd.c
+++ b/host_cmd.c
@@ -218,8 +218,8 @@ void Host_God_f (void)
                return;
        }
 
                return;
        }
 

-       host_client->edict->fields.server->flags = (int)host_client->edict->fields.server->flags ^ FL_GODMODE;
-       if (!((int)host_client->edict->fields.server->flags & FL_GODMODE) )
+       PRVM_serveredictfloat(host_client->edict, flags) = (int)PRVM_serveredictfloat(host_client->edict, flags) ^ FL_GODMODE;
+       if (!((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_GODMODE) )

                SV_ClientPrint("godmode OFF\n");
        else
                SV_ClientPrint("godmode ON\n");
                SV_ClientPrint("godmode OFF\n");
        else
                SV_ClientPrint("godmode ON\n");


@@ -233,8 +233,8 @@ void Host_Notarget_f (void)
                return;
        }
 
                return;
        }
 

-       host_client->edict->fields.server->flags = (int)host_client->edict->fields.server->flags ^ FL_NOTARGET;
-       if (!((int)host_client->edict->fields.server->flags & FL_NOTARGET) )
+       PRVM_serveredictfloat(host_client->edict, flags) = (int)PRVM_serveredictfloat(host_client->edict, flags) ^ FL_NOTARGET;
+       if (!((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_NOTARGET) )

                SV_ClientPrint("notarget OFF\n");
        else
                SV_ClientPrint("notarget ON\n");
                SV_ClientPrint("notarget OFF\n");
        else
                SV_ClientPrint("notarget ON\n");


@@ -250,16 +250,16 @@ void Host_Noclip_f (void)
                return;
        }
 
                return;
        }
 

-       if (host_client->edict->fields.server->movetype != MOVETYPE_NOCLIP)
+       if (PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_NOCLIP)

        {
                noclip_anglehack = true;
        {
                noclip_anglehack = true;

-               host_client->edict->fields.server->movetype = MOVETYPE_NOCLIP;
+               PRVM_serveredictfloat(host_client->edict, movetype) = MOVETYPE_NOCLIP;

                SV_ClientPrint("noclip ON\n");
        }
        else
        {
                noclip_anglehack = false;
                SV_ClientPrint("noclip ON\n");
        }
        else
        {
                noclip_anglehack = false;

-               host_client->edict->fields.server->movetype = MOVETYPE_WALK;
+               PRVM_serveredictfloat(host_client->edict, movetype) = MOVETYPE_WALK;

                SV_ClientPrint("noclip OFF\n");
        }
 }
                SV_ClientPrint("noclip OFF\n");
        }
 }


@@ -279,14 +279,14 @@ void Host_Fly_f (void)
                return;
        }
 
                return;
        }
 

-       if (host_client->edict->fields.server->movetype != MOVETYPE_FLY)
+       if (PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_FLY)

        {
        {

-               host_client->edict->fields.server->movetype = MOVETYPE_FLY;
+               PRVM_serveredictfloat(host_client->edict, movetype) = MOVETYPE_FLY;

                SV_ClientPrint("flymode ON\n");
        }
        else
        {
                SV_ClientPrint("flymode ON\n");
        }
        else
        {

-               host_client->edict->fields.server->movetype = MOVETYPE_WALK;
+               PRVM_serveredictfloat(host_client->edict, movetype) = MOVETYPE_WALK;

                SV_ClientPrint("flymode OFF\n");
        }
 }
                SV_ClientPrint("flymode OFF\n");
        }
 }


@@ -578,7 +578,7 @@ void Host_Savegame_to (const char *name)
 
        memset(comment, 0, sizeof(comment));
        if(isserver)
 
        memset(comment, 0, sizeof(comment));
        if(isserver)

-               dpsnprintf(comment, sizeof(comment), "%-21.21s kills:%3i/%3i", PRVM_GetString(prog->edicts->fields.server->message), (int)prog->globals.server->killed_monsters, (int)prog->globals.server->total_monsters);
+               dpsnprintf(comment, sizeof(comment), "%-21.21s kills:%3i/%3i", PRVM_GetString(PRVM_serveredictstring(prog->edicts, message)), (int)PRVM_serverglobalfloat(killed_monsters), (int)PRVM_serverglobalfloat(total_monsters));

        else
                dpsnprintf(comment, sizeof(comment), "(crash dump of %s progs)", PRVM_NAME);
        // convert space to _ to make stdio happy
        else
                dpsnprintf(comment, sizeof(comment), "(crash dump of %s progs)", PRVM_NAME);
        // convert space to _ to make stdio happy


@@ -716,7 +716,7 @@ void Host_Savegame_f (void)
                        return;
                }
 
                        return;
                }
 

-               if (svs.clients[0].active && svs.clients[0].edict->fields.server->deadflag)
+               if (svs.clients[0].active && PRVM_serveredictfloat(svs.clients[0].edict, deadflag))

                {
                        Con_Print("Can't savegame with a dead player\n");
                        return;
                {
                        Con_Print("Can't savegame with a dead player\n");
                        return;


@@ -944,7 +944,7 @@ void Host_Loadgame_f (void)
                        while (entnum >= prog->max_edicts)
                                PRVM_MEM_IncreaseEdicts();
                        ent = PRVM_EDICT_NUM(entnum);
                        while (entnum >= prog->max_edicts)
                                PRVM_MEM_IncreaseEdicts();
                        ent = PRVM_EDICT_NUM(entnum);

-                       memset (ent->fields.server, 0, prog->entityfields * 4);
+                       memset(ent->fields.vp, 0, prog->entityfields * 4);

                        ent->priv.server->free = false;
 
                        if(developer_entityparsing.integer)
                        ent->priv.server->free = false;
 
                        if(developer_entityparsing.integer)


@@ -1195,7 +1195,7 @@ void Host_Name_f (void)
        if (j >= 0 && strlen(host_client->name) < sizeof(host_client->name) - 2)
                memcpy(host_client->name + strlen(host_client->name), STRING_COLOR_DEFAULT_STR, strlen(STRING_COLOR_DEFAULT_STR) + 1);
 
        if (j >= 0 && strlen(host_client->name) < sizeof(host_client->name) - 2)
                memcpy(host_client->name + strlen(host_client->name), STRING_COLOR_DEFAULT_STR, strlen(STRING_COLOR_DEFAULT_STR) + 1);
 

-       host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
+       PRVM_serveredictstring(host_client->edict, netname) = PRVM_SetEngineString(host_client->name);

        if (strcmp(host_client->old_name, host_client->name))
        {
                if (host_client->spawned)
        if (strcmp(host_client->old_name, host_client->name))
        {
                if (host_client->spawned)


@@ -1388,7 +1388,7 @@ void Host_Say(qboolean teamonly)
        // note: save is not a valid edict if fromServer is true
        save = host_client;
        for (j = 0, host_client = svs.clients;j < svs.maxclients;j++, host_client++)
        // note: save is not a valid edict if fromServer is true
        save = host_client;
        for (j = 0, host_client = svs.clients;j < svs.maxclients;j++, host_client++)

-               if (host_client->active && (!teamonly || host_client->edict->fields.server->team == save->edict->fields.server->team))
+               if (host_client->active && (!teamonly || PRVM_serveredictfloat(host_client->edict, team) == PRVM_serveredictfloat(save->edict, team)))

                        SV_ClientPrint(text);
        host_client = save;
 
                        SV_ClientPrint(text);
        host_client = save;
 


@@ -1575,9 +1575,9 @@ void Host_Color(int changetop, int changebottom)
        if (host_client->edict && PRVM_clientfunction(SV_ChangeTeam))
        {
                Con_DPrint("Calling SV_ChangeTeam\n");
        if (host_client->edict && PRVM_clientfunction(SV_ChangeTeam))
        {
                Con_DPrint("Calling SV_ChangeTeam\n");

-               prog->globals.server->time = sv.time;
+               PRVM_serverglobalfloat(time) = sv.time;

                prog->globals.generic[OFS_PARM0] = playercolor;
                prog->globals.generic[OFS_PARM0] = playercolor;

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);

                PRVM_ExecuteProgram(PRVM_clientfunction(SV_ChangeTeam), "QC function SV_ChangeTeam is missing");
        }
        else
                PRVM_ExecuteProgram(PRVM_clientfunction(SV_ChangeTeam), "QC function SV_ChangeTeam is missing");
        }
        else


@@ -1585,7 +1585,7 @@ void Host_Color(int changetop, int changebottom)
                if (host_client->edict)
                {
                        PRVM_serveredictfloat(host_client->edict, clientcolors) = playercolor;
                if (host_client->edict)
                {
                        PRVM_serveredictfloat(host_client->edict, clientcolors) = playercolor;

-                       host_client->edict->fields.server->team = bottom + 1;
+                       PRVM_serveredictfloat(host_client->edict, team) = bottom + 1;

                }
                host_client->colors = playercolor;
                if (host_client->old_colors != host_client->colors)
                }
                host_client->colors = playercolor;
                if (host_client->old_colors != host_client->colors)


@@ -1674,15 +1674,15 @@ Host_Kill_f
 */
 void Host_Kill_f (void)
 {
 */
 void Host_Kill_f (void)
 {

-       if (host_client->edict->fields.server->health <= 0)
+       if (PRVM_serveredictfloat(host_client->edict, health) <= 0)

        {
                SV_ClientPrint("Can't suicide -- already dead!\n");
                return;
        }
 
        {
                SV_ClientPrint("Can't suicide -- already dead!\n");
                return;
        }
 

-       prog->globals.server->time = sv.time;
-       prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-       PRVM_ExecuteProgram (prog->globals.server->ClientKill, "QC function ClientKill is missing");
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+       PRVM_ExecuteProgram (PRVM_serverfunction(ClientKill), "QC function ClientKill is missing");

 }
 
 
 }
 
 


@@ -1798,29 +1798,29 @@ void Host_Spawn_f (void)
                if (PRVM_serverfunction(RestoreGame))
                {
                        Con_DPrint("Calling RestoreGame\n");
                if (PRVM_serverfunction(RestoreGame))
                {
                        Con_DPrint("Calling RestoreGame\n");

-                       prog->globals.server->time = sv.time;
-                       prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+                       PRVM_serverglobalfloat(time) = sv.time;
+                       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);

                        PRVM_ExecuteProgram(PRVM_serverfunction(RestoreGame), "QC function RestoreGame is missing");
                }
        }
        else
        {
                        PRVM_ExecuteProgram(PRVM_serverfunction(RestoreGame), "QC function RestoreGame is missing");
                }
        }
        else
        {

-               //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PRVM_GetString(host_client->edict->fields.server->netname), PRVM_GetString(host_client->edict->fields.server->netname), host_client->name);
+               //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PRVM_GetString(PRVM_serveredictstring(host_client->edict, netname)), PRVM_GetString(PRVM_serveredictstring(host_client->edict, netname)), host_client->name);

 
                // copy spawn parms out of the client_t
                for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
 
                // copy spawn parms out of the client_t
                for (i=0 ; i< NUM_SPAWN_PARMS ; i++)

-                       (&prog->globals.server->parm1)[i] = host_client->spawn_parms[i];
+                       (&PRVM_serverglobalfloat(parm1))[i] = host_client->spawn_parms[i];

 
                // call the spawn function
                host_client->clientconnectcalled = true;
 
                // call the spawn function
                host_client->clientconnectcalled = true;

-               prog->globals.server->time = sv.time;
-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-               PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_ExecuteProgram (PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");

 
                if (cls.state == ca_dedicated)
                        Con_Printf("%s connected\n", host_client->name);
 
 
                if (cls.state == ca_dedicated)
                        Con_Printf("%s connected\n", host_client->name);
 

-               PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
+               PRVM_ExecuteProgram (PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");

        }
 
        if (!host_client->netconnection)
        }
 
        if (!host_client->netconnection)


@@ -1860,19 +1860,19 @@ void Host_Spawn_f (void)
        // send some stats
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALSECRETS);
        // send some stats
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALSECRETS);

-       MSG_WriteLong (&host_client->netconnection->message, (int)prog->globals.server->total_secrets);
+       MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(total_secrets));

 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALMONSTERS);
 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_TOTALMONSTERS);

-       MSG_WriteLong (&host_client->netconnection->message, (int)prog->globals.server->total_monsters);
+       MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(total_monsters));

 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_SECRETS);
 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_SECRETS);

-       MSG_WriteLong (&host_client->netconnection->message, (int)prog->globals.server->found_secrets);
+       MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(found_secrets));

 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_MONSTERS);
 
        MSG_WriteByte (&host_client->netconnection->message, svc_updatestat);
        MSG_WriteByte (&host_client->netconnection->message, STAT_MONSTERS);

-       MSG_WriteLong (&host_client->netconnection->message, (int)prog->globals.server->killed_monsters);
+       MSG_WriteLong (&host_client->netconnection->message, (int)PRVM_serverglobalfloat(killed_monsters));

 
        // send a fixangle
        // Never send a roll angle, because savegames can catch the server
 
        // send a fixangle
        // Never send a roll angle, because savegames can catch the server


@@ -1882,15 +1882,15 @@ void Host_Spawn_f (void)
        if (sv.loadgame)
        {
                MSG_WriteByte (&host_client->netconnection->message, svc_setangle);
        if (sv.loadgame)
        {
                MSG_WriteByte (&host_client->netconnection->message, svc_setangle);

-               MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->v_angle[0], sv.protocol);
-               MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->v_angle[1], sv.protocol);
+               MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, v_angle)[0], sv.protocol);
+               MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, v_angle)[1], sv.protocol);

                MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
        }
        else
        {
                MSG_WriteByte (&host_client->netconnection->message, svc_setangle);
                MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
        }
        else
        {
                MSG_WriteByte (&host_client->netconnection->message, svc_setangle);

-               MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->angles[0], sv.protocol);
-               MSG_WriteAngle (&host_client->netconnection->message, host_client->edict->fields.server->angles[1], sv.protocol);
+               MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, angles)[0], sv.protocol);
+               MSG_WriteAngle (&host_client->netconnection->message, PRVM_serveredictvector(host_client->edict, angles)[1], sv.protocol);

                MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
        }
 
                MSG_WriteAngle (&host_client->netconnection->message, 0, sv.protocol);
        }
 


@@ -2052,21 +2052,21 @@ void Host_Give_f (void)
                        if (t[0] == '6')
                        {
                                if (t[1] == 'a')
                        if (t[0] == '6')
                        {
                                if (t[1] == 'a')

-                                       host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_PROXIMITY_GUN;
+                                       PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | HIT_PROXIMITY_GUN;

                                else
                                else

-                                       host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | IT_GRENADE_LAUNCHER;
+                                       PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | IT_GRENADE_LAUNCHER;

                        }
                        else if (t[0] == '9')
                        }
                        else if (t[0] == '9')

-                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_LASER_CANNON;
+                               PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | HIT_LASER_CANNON;

                        else if (t[0] == '0')
                        else if (t[0] == '0')

-                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_MJOLNIR;
+                               PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | HIT_MJOLNIR;

                        else if (t[0] >= '2')
                        else if (t[0] >= '2')

-                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
+                               PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | (IT_SHOTGUN << (t[0] - '2'));

                }
                else
                {
                        if (t[0] >= '2')
                }
                else
                {
                        if (t[0] >= '2')

-                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
+                               PRVM_serveredictfloat(host_client->edict, items) = (int)PRVM_serveredictfloat(host_client->edict, items) | (IT_SHOTGUN << (t[0] - '2'));

                }
                break;
 
                }
                break;
 


@@ -2074,69 +2074,69 @@ void Host_Give_f (void)
                if (gamemode == GAME_ROGUE)
                        PRVM_serveredictfloat(host_client->edict, ammo_shells1) = v;
 
                if (gamemode == GAME_ROGUE)
                        PRVM_serveredictfloat(host_client->edict, ammo_shells1) = v;
 

-               host_client->edict->fields.server->ammo_shells = v;
+               PRVM_serveredictfloat(host_client->edict, ammo_shells) = v;

                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_nails1) = v;
                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) <= IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_nails) = v;

                }
                else
                {
                }
                else
                {

-                       host_client->edict->fields.server->ammo_nails = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_nails) = v;

                }
                break;
        case 'l':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_lava_nails) = v;
                }
                break;
        case 'l':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) > IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_nails) = v;

                }
                break;
        case 'r':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_rockets1) = v;
                }
                break;
        case 'r':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) <= IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_rockets) = v;

                }
                else
                {
                }
                else
                {

-                       host_client->edict->fields.server->ammo_rockets = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_rockets) = v;

                }
                break;
        case 'm':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_multi_rockets) = v;
                }
                break;
        case 'm':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) > IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_rockets) = v;

                }
                break;
        case 'h':
                }
                break;
        case 'h':

-               host_client->edict->fields.server->health = v;
+               PRVM_serveredictfloat(host_client->edict, health) = v;

                break;
        case 'c':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_cells1) = v;
                break;
        case 'c':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) <= IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_cells) = v;

                }
                else
                {
                }
                else
                {

-                       host_client->edict->fields.server->ammo_cells = v;
+                       PRVM_serveredictfloat(host_client->edict, ammo_cells) = v;

                }
                break;
        case 'p':
                if (gamemode == GAME_ROGUE)
                {
                        PRVM_serveredictfloat(host_client->edict, ammo_plasma) = v;
                }
                break;
        case 'p':
                if (gamemode == GAME_ROGUE)
                {
                        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 (PRVM_serveredictfloat(host_client->edict, weapon) > IT_LIGHTNING)
+                               PRVM_serveredictfloat(host_client->edict, ammo_cells) = v;

                }
                break;
        }
                }
                break;
        }


@@ -2150,7 +2150,7 @@ prvm_edict_t      *FindViewthing (void)
        for (i=0 ; i<prog->num_edicts ; i++)
        {
                e = PRVM_EDICT_NUM(i);
        for (i=0 ; i<prog->num_edicts ; i++)
        {
                e = PRVM_EDICT_NUM(i);

-               if (!strcmp (PRVM_GetString(e->fields.server->classname), "viewthing"))
+               if (!strcmp (PRVM_GetString(PRVM_serveredictstring(e, classname)), "viewthing"))

                        return e;
        }
        Con_Print("No viewthing on map\n");
                        return e;
        }
        Con_Print("No viewthing on map\n");


@@ -2183,8 +2183,8 @@ void Host_Viewmodel_f (void)
                return;
        }
 
                return;
        }
 

-       e->fields.server->frame = 0;
-       cl.model_precache[(int)e->fields.server->modelindex] = m;
+       PRVM_serveredictfloat(e, frame) = 0;
+       cl.model_precache[(int)PRVM_serveredictfloat(e, modelindex)] = m;

 }
 
 /*
 }
 
 /*


@@ -2206,13 +2206,13 @@ void Host_Viewframe_f (void)
        SV_VM_End();
        if (!e)
                return;
        SV_VM_End();
        if (!e)
                return;

-       m = cl.model_precache[(int)e->fields.server->modelindex];
+       m = cl.model_precache[(int)PRVM_serveredictfloat(e, modelindex)];

 
        f = atoi(Cmd_Argv(1));
        if (f >= m->numframes)
                f = m->numframes-1;
 
 
        f = atoi(Cmd_Argv(1));
        if (f >= m->numframes)
                f = m->numframes-1;
 

-       e->fields.server->frame = f;
+       PRVM_serveredictfloat(e, frame) = f;

 }
 
 
 }
 
 


@@ -2242,13 +2242,13 @@ void Host_Viewnext_f (void)
        SV_VM_End();
        if (!e)
                return;
        SV_VM_End();
        if (!e)
                return;

-       m = cl.model_precache[(int)e->fields.server->modelindex];
+       m = cl.model_precache[(int)PRVM_serveredictfloat(e, modelindex)];

 
 

-       e->fields.server->frame = e->fields.server->frame + 1;
-       if (e->fields.server->frame >= m->numframes)
-               e->fields.server->frame = m->numframes - 1;
+       PRVM_serveredictfloat(e, frame) = PRVM_serveredictfloat(e, frame) + 1;
+       if (PRVM_serveredictfloat(e, frame) >= m->numframes)
+               PRVM_serveredictfloat(e, frame) = m->numframes - 1;

 
 

-       PrintFrameName (m, (int)e->fields.server->frame);
+       PrintFrameName (m, (int)PRVM_serveredictfloat(e, frame));

 }
 
 /*
 }
 
 /*


@@ -2270,13 +2270,13 @@ void Host_Viewprev_f (void)
        if (!e)
                return;
 
        if (!e)
                return;
 

-       m = cl.model_precache[(int)e->fields.server->modelindex];
+       m = cl.model_precache[(int)PRVM_serveredictfloat(e, modelindex)];

 
 

-       e->fields.server->frame = e->fields.server->frame - 1;
-       if (e->fields.server->frame < 0)
-               e->fields.server->frame = 0;
+       PRVM_serveredictfloat(e, frame) = PRVM_serveredictfloat(e, frame) - 1;
+       if (PRVM_serveredictfloat(e, frame) < 0)
+               PRVM_serveredictfloat(e, frame) = 0;

 
 

-       PrintFrameName (m, (int)e->fields.server->frame);
+       PrintFrameName (m, (int)PRVM_serveredictfloat(e, frame));

 }
 
 /*
 }
 
 /*

diff --git a/menu.c b/menu.c
index f0ef7c0168e2b257af174ef18f853ae18af9c880..5df5370fe419708336d411ef9e340adfbd57a78b 100644 (file)
--- a/menu.c
+++ b/menu.c
@@ -5300,7 +5300,6 @@ void MP_Init (void)
        PRVM_Begin;
        PRVM_InitProg(PRVM_MENUPROG);
 
        PRVM_Begin;
        PRVM_InitProg(PRVM_MENUPROG);
 

-       prog->headercrc = M_PROGHEADER_CRC;

        prog->edictprivate_size = 0; // no private struct used
        prog->name = M_NAME;
        prog->num_edicts = 1;
        prog->edictprivate_size = 0; // no private struct used
        prog->name = M_NAME;
        prog->num_edicts = 1;

diff --git a/mprogdefs.h b/mprogdefs.h
index 3ca5093fa2578c278ce1f98c95c662d66eb9030e..c7993b7dd85b2eb61ccab8f3d86338a7c525da9a 100644 (file)
--- a/mprogdefs.h
+++ b/mprogdefs.h
@@ -1,14 +1,22 @@
 
 

+#ifndef MPROGDEFS_H
+#define MPROGDEFS_H
+

 /* file generated by qcc, do not modify */
 
 /* file generated by qcc, do not modify */
 

+/*

 typedef struct m_globalvars_s
 {
        int     pad[28];
        int     self;
 } m_globalvars_t;
 
 typedef struct m_globalvars_s
 {
        int     pad[28];
        int     self;
 } m_globalvars_t;
 

-/*typedef struct m_entvars_s
+typedef struct m_entvars_s

 {
 {

-} m_entvars_t;*/
+} m_entvars_t;

 
 #define M_PROGHEADER_CRC 10020
 
 #define M_PROGHEADER_CRC 10020

+
+*/
+
+#endif

diff --git a/progsvm.h b/progsvm.h
index 9794111c08ac435529bad883fe0ee1e38d493ecd..60c3f212f0bc31a1b7e8991fc900d8458f09403d 100644 (file)
--- a/progsvm.h
+++ b/progsvm.h
@@ -110,8 +110,8 @@ typedef struct prvm_edict_s
        union
        {
                vec_t *vp;
        union
        {
                vec_t *vp;

-               entvars_t               *server;
-               cl_entvars_t    *client;
+//             entvars_t               *server;
+//             cl_entvars_t    *client;

        } fields;
 } prvm_edict_t;
 
        } fields;
 } prvm_edict_t;
 


@@ -528,8 +528,8 @@ typedef struct prvm_prog_s
 
        union {
                vec_t *generic;
 
        union {
                vec_t *generic;

-               globalvars_t *server;
-               cl_globalvars_t *client;
+//             globalvars_t *server;
+//             cl_globalvars_t *client;

        } globals;
 
        int                                     maxknownstrings;
        } globals;
 
        int                                     maxknownstrings;


@@ -564,9 +564,6 @@ typedef struct prvm_prog_s
        int                                     localstack[PRVM_LOCALSTACK_SIZE];
        int                                     localstack_used;
 
        int                                     localstack[PRVM_LOCALSTACK_SIZE];
        int                                     localstack_used;
 

-       unsigned short          headercrc; // [INIT]
-       unsigned short          headercrc2; // [INIT] alternate CRC for tenebrae progs.dat
-

        unsigned short          filecrc;
 
        //============================================================================
        unsigned short          filecrc;
 
        //============================================================================

diff --git a/protocol.c b/protocol.c
index 3ae47c56564cdb05b709a3a80b31d68f56db520f..7e6046342b153d714ca07c43cc0cdd4734b89f9a 100644 (file)
--- a/protocol.c
+++ b/protocol.c
@@ -553,7 +553,7 @@ qboolean EntityFrameCSQC_WriteFrame (sizebuf_t *msg, int maxsize, int numnumbers
                                        msg->allowoverflow = true;
                                        PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
                                        PRVM_G_FLOAT(OFS_PARM1) = sendflags;
                                        msg->allowoverflow = true;
                                        PRVM_G_INT(OFS_PARM0) = sv.writeentitiestoclient_cliententitynumber;
                                        PRVM_G_FLOAT(OFS_PARM1) = sendflags;

-                                       prog->globals.server->self = number;
+                                       PRVM_serverglobaledict(self) = number;

                                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ed, SendEntity), "Null SendEntity\n");
                                        msg->allowoverflow = false;
                                        if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)
                                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ed, SendEntity), "Null SendEntity\n");
                                        msg->allowoverflow = false;
                                        if(PRVM_G_FLOAT(OFS_RETURN) && msg->cursize + 2 <= maxsize)

diff --git a/prvm_cmds.c b/prvm_cmds.c
index 819bada04d0f639ac96d5def8469fabf972056fe..df5ea5eaf90a57d5db11d5e4373046359e747cdb 100644 (file)
--- a/prvm_cmds.c
+++ b/prvm_cmds.c
@@ -6845,7 +6845,7 @@ void VM_getsurfaceclippedpoint(void)
        animatemodel(model, ed);
        applytransform_inverted(PRVM_G_VECTOR(OFS_PARM2), ed, p);
        clippointtosurface(ed, model, surface, p, out);
        animatemodel(model, ed);
        applytransform_inverted(PRVM_G_VECTOR(OFS_PARM2), ed, p);
        clippointtosurface(ed, model, surface, p, out);

-       VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
+       VectorAdd(out, PRVM_serveredictvector(ed, origin), PRVM_G_VECTOR(OFS_RETURN));

 }
 
 //PF_getsurfacenumtriangles, // #??? float(entity e, float s) getsurfacenumtriangles = #???;
 }
 
 //PF_getsurfacenumtriangles, // #??? float(entity e, float s) getsurfacenumtriangles = #???;


@@ -6924,7 +6924,7 @@ void VM_physics_enable(void)
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer

-       if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+       if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)

        {
                VM_Warning("VM_physics_enable: entity is not MOVETYPE_PHYSICS!\n");
                return;
        {
                VM_Warning("VM_physics_enable: entity is not MOVETYPE_PHYSICS!\n");
                return;


@@ -6948,14 +6948,14 @@ void VM_physics_addforce(void)
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer

-       if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+       if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)

        {
                VM_Warning("VM_physics_addforce: entity is not MOVETYPE_PHYSICS!\n");
                return;
        }
        f.type = ODEFUNC_RELFORCEATPOS;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);
        {
                VM_Warning("VM_physics_addforce: entity is not MOVETYPE_PHYSICS!\n");
                return;
        }
        f.type = ODEFUNC_RELFORCEATPOS;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f.v1);

-       VectorSubtract(ed->fields.server->origin, PRVM_G_VECTOR(OFS_PARM2), f.v2);
+       VectorSubtract(PRVM_serveredictvector(ed, origin), PRVM_G_VECTOR(OFS_PARM2), f.v2);

        VM_physics_ApplyCmd(ed, &f);
 }
 
        VM_physics_ApplyCmd(ed, &f);
 }
 


@@ -6974,7 +6974,7 @@ void VM_physics_addtorque(void)
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer
                return;
        }
        // entity should have MOVETYPE_PHYSICS already set, this can damage memory (making leaked allocation) so warn about this even if non-developer

-       if (ed->fields.server->movetype != MOVETYPE_PHYSICS)
+       if (PRVM_serveredictfloat(ed, movetype) != MOVETYPE_PHYSICS)

        {
                VM_Warning("VM_physics_addtorque: entity is not MOVETYPE_PHYSICS!\n");
                return;
        {
                VM_Warning("VM_physics_addtorque: entity is not MOVETYPE_PHYSICS!\n");
                return;

diff --git a/prvm_edict.c b/prvm_edict.c
index fcc0b5317d0ca0b0fe331ad8a05881b139643c0a..ffe917a8060034737664e089d8cb042321b4740a 100644 (file)
--- a/prvm_edict.c
+++ b/prvm_edict.c
@@ -1972,8 +1972,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, const char **re
        prog->progs_crc = LittleLong(dprograms->crc);
        if (prog->progs_version != PROG_VERSION)
                PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs_version, PROG_VERSION);
        prog->progs_crc = LittleLong(dprograms->crc);
        if (prog->progs_version != PROG_VERSION)
                PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs_version, PROG_VERSION);

-       if (prog->progs_crc != prog->headercrc && prog->progs_crc != prog->headercrc2)
-               PRVM_ERROR ("%s: %s system vars have been modified (CRC of progs.dat systemvars %i != engine %i), progdefs.h is out of date", PRVM_NAME, filename, prog->progs_crc, prog->headercrc);

        instatements = (dstatement_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_statements));
        prog->progs_numstatements = LittleLong(dprograms->numstatements);
        inglobaldefs = (ddef_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globaldefs));
        instatements = (dstatement_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_statements));
        prog->progs_numstatements = LittleLong(dprograms->numstatements);
        inglobaldefs = (ddef_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globaldefs));


@@ -3018,21 +3016,20 @@ static qboolean PRVM_IsEdictRelevant(prvm_edict_t *edict)
        {
                case PRVM_SERVERPROG:
                        {
        {
                case PRVM_SERVERPROG:
                        {

-                               entvars_t *ev = edict->fields.server;
-                               if(ev->solid) // can block other stuff, or is a trigger?
+                               if(PRVM_serveredictfloat(edict, solid)) // can block other stuff, or is a trigger?

                                        return true;
                                        return true;

-                               if(ev->modelindex) // visible ent?
+                               if(PRVM_serveredictfloat(edict, modelindex)) // visible ent?

                                        return true;
                                        return true;

-                               if(ev->effects) // particle effect?
+                               if(PRVM_serveredictfloat(edict, effects)) // particle effect?

                                        return true;
                                        return true;

-                               if(ev->think) // has a think function?
-                                       if(ev->nextthink > 0) // that actually will eventually run?
+                               if(PRVM_serveredictfunction(edict, think)) // has a think function?
+                                       if(PRVM_serveredictfloat(edict, nextthink) > 0) // that actually will eventually run?

                                                return true;
                                                return true;

-                               if(ev->takedamage)
+                               if(PRVM_serveredictfloat(edict, takedamage))

                                        return true;
                                if(*prvm_leaktest_ignore_classnames.string)
                                {
                                        return true;
                                if(*prvm_leaktest_ignore_classnames.string)
                                {

-                                       if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
+                                       if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(PRVM_serveredictstring(edict, classname)))))

                                                return true;
                                }
                        }
                                                return true;
                                }
                        }


@@ -3040,19 +3037,18 @@ static qboolean PRVM_IsEdictRelevant(prvm_edict_t *edict)
                case PRVM_CLIENTPROG:
                        {
                                // TODO someone add more stuff here
                case PRVM_CLIENTPROG:
                        {
                                // TODO someone add more stuff here

-                               cl_entvars_t *ev = edict->fields.client;
-                               if(ev->entnum) // csqc networked
+                               if(PRVM_clientedictfloat(edict, entnum)) // csqc networked

                                        return true;
                                        return true;

-                               if(ev->modelindex) // visible ent?
+                               if(PRVM_clientedictfloat(edict, modelindex)) // visible ent?

                                        return true;
                                        return true;

-                               if(ev->effects) // particle effect?
+                               if(PRVM_clientedictfloat(edict, effects)) // particle effect?

                                        return true;
                                        return true;

-                               if(ev->think) // has a think function?
-                                       if(ev->nextthink > 0) // that actually will eventually run?
+                               if(PRVM_clientedictfunction(edict, think)) // has a think function?
+                                       if(PRVM_clientedictfloat(edict, nextthink) > 0) // that actually will eventually run?

                                                return true;
                                if(*prvm_leaktest_ignore_classnames.string)
                                {
                                                return true;
                                if(*prvm_leaktest_ignore_classnames.string)
                                {

-                                       if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
+                                       if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(PRVM_clientedictstring(edict, classname)))))

                                                return true;
                                }
                        }
                                                return true;
                                }
                        }


@@ -3073,7 +3069,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
        switch(prog - prog_list)
        {
                case PRVM_SERVERPROG:
        switch(prog - prog_list)
        {
                case PRVM_SERVERPROG:

-                       targetname = PRVM_GetString(edict->fields.server->targetname);
+                       targetname = PRVM_GetString(PRVM_serveredictstring(edict, targetname));

                        break;
        }
 
                        break;
        }
 


@@ -3099,7 +3095,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
                        continue;
                if(targetname)
                {
                        continue;
                if(targetname)
                {

-                       const char *target = PRVM_GetString(ed->fields.server->target);
+                       const char *target = PRVM_GetString(PRVM_serveredictstring(ed, target));

                        if(target)
                                if(!strcmp(target, targetname))
                                        return true;
                        if(target)
                                if(!strcmp(target, targetname))
                                        return true;

diff --git a/sv_demo.c b/sv_demo.c
index c237f2f43a4b649189779509c179fe6cca596306..f6f00d33102ec3c30968a30ff05e0c9a3e446b5a 100644 (file)
--- a/sv_demo.c
+++ b/sv_demo.c
@@ -44,7 +44,7 @@ void SV_WriteDemoMessage(client_t *client, sizebuf_t *sendbuffer, qboolean clien
        FS_Write(client->sv_demo_file, &len, 4);
        for(i = 0; i < 3; ++i)
        {
        FS_Write(client->sv_demo_file, &len, 4);
        for(i = 0; i < 3; ++i)
        {

-               f = LittleFloat(client->edict->fields.server->v_angle[i]);
+               f = LittleFloat(PRVM_serveredictvector(client->edict, v_angle)[i]);

                FS_Write(client->sv_demo_file, &f, 4);
        }
        FS_Write(client->sv_demo_file, sendbuffer->data, sendbuffer->cursize);
                FS_Write(client->sv_demo_file, &f, 4);
        }
        FS_Write(client->sv_demo_file, sendbuffer->data, sendbuffer->cursize);

diff --git a/sv_main.c b/sv_main.c
index 69ea9d267163fb196073d264e7738c5a56c51179..d8e232d1fc567e3d4bd8fa2a4fe4fdd1dd2e8396 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -752,7 +752,7 @@ void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int v
        else
                MSG_WriteByte (&sv.datagram, sound_num);
        for (i = 0;i < 3;i++)
        else
                MSG_WriteByte (&sv.datagram, sound_num);
        for (i = 0;i < 3;i++)

-               MSG_WriteCoord (&sv.datagram, entity->fields.server->origin[i]+0.5*(entity->fields.server->mins[i]+entity->fields.server->maxs[i]), sv.protocol);
+               MSG_WriteCoord (&sv.datagram, PRVM_serveredictvector(entity, origin)[i]+0.5*(PRVM_serveredictvector(entity, mins)[i]+PRVM_serveredictvector(entity, maxs)[i]), sv.protocol);

        SV_FlushBroadcastMessages();
 }
 
        SV_FlushBroadcastMessages();
 }
 


@@ -970,7 +970,7 @@ void SV_SendServerinfo (client_t *client)
        else
                MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 
        else
                MSG_WriteByte (&client->netconnection->message, GAME_COOP);
 

-       MSG_WriteString (&client->netconnection->message,PRVM_GetString(prog->edicts->fields.server->message));
+       MSG_WriteString (&client->netconnection->message,PRVM_GetString(PRVM_serveredictstring(prog->edicts, message)));

 
        for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
                MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);
 
        for (i = 1;i < MAX_MODELS && sv.model_precache[i][0];i++)
                MSG_WriteString (&client->netconnection->message, sv.model_precache[i]);


@@ -982,8 +982,8 @@ void SV_SendServerinfo (client_t *client)
 
 // send music
        MSG_WriteByte (&client->netconnection->message, svc_cdtrack);
 
 // send music
        MSG_WriteByte (&client->netconnection->message, svc_cdtrack);

-       MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
-       MSG_WriteByte (&client->netconnection->message, (int)prog->edicts->fields.server->sounds);
+       MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));
+       MSG_WriteByte (&client->netconnection->message, (int)PRVM_serveredictfloat(prog->edicts, sounds));

 
 // set view
 // store this in clientcamera, too
 
 // set view
 // store this in clientcamera, too


@@ -1075,10 +1075,10 @@ void SV_ConnectClient (int clientnum, netconn_t *netconnection)
        {
                // call the progs to get default spawn parms for the new client
                // set self to world to intentionally cause errors with broken SetNewParms code in some mods
        {
                // call the progs to get default spawn parms for the new client
                // set self to world to intentionally cause errors with broken SetNewParms code in some mods

-               prog->globals.server->self = 0;
-               PRVM_ExecuteProgram (prog->globals.server->SetNewParms, "QC function SetNewParms is missing");
+               PRVM_serverglobaledict(self) = 0;
+               PRVM_ExecuteProgram (PRVM_serverfunction(SetNewParms), "QC function SetNewParms is missing");

                for (i=0 ; i<NUM_SPAWN_PARMS ; i++)
                for (i=0 ; i<NUM_SPAWN_PARMS ; i++)

-                       client->spawn_parms[i] = (&prog->globals.server->parm1)[i];
+                       client->spawn_parms[i] = (&PRVM_serverglobalfloat(parm1))[i];

 
                // set up the entity for this client (including .colormap, .team, etc)
                PRVM_ED_ClearEdict(client->edict);
 
                // set up the entity for this client (including .colormap, .team, etc)
                PRVM_ED_ClearEdict(client->edict);


@@ -1133,18 +1133,18 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
 
        // this 2 billion unit check is actually to detect NAN origins
        // (we really don't want to send those)
 
        // this 2 billion unit check is actually to detect NAN origins
        // (we really don't want to send those)

-       if (!(VectorLength2(ent->fields.server->origin) < 2000000000.0*2000000000.0))
+       if (!(VectorLength2(PRVM_serveredictvector(ent, origin)) < 2000000000.0*2000000000.0))

                return false;
 
        // EF_NODRAW prevents sending for any reason except for your own
        // client, so we must keep all clients in this superset
                return false;
 
        // EF_NODRAW prevents sending for any reason except for your own
        // client, so we must keep all clients in this superset

-       effects = (unsigned)ent->fields.server->effects;
+       effects = (unsigned)PRVM_serveredictfloat(ent, effects);

 
        // we can omit invisible entities with no effects that are not clients
        // LordHavoc: this could kill tags attached to an invisible entity, I
        // just hope we never have to support that case
 
        // we can omit invisible entities with no effects that are not clients
        // LordHavoc: this could kill tags attached to an invisible entity, I
        // just hope we never have to support that case

-       i = (int)ent->fields.server->modelindex;
-       modelindex = (i >= 1 && i < MAX_MODELS && ent->fields.server->model && *PRVM_GetString(ent->fields.server->model) && sv.models[i]) ? i : 0;
+       i = (int)PRVM_serveredictfloat(ent, modelindex);
+       modelindex = (i >= 1 && i < MAX_MODELS && PRVM_serveredictstring(ent, model) && *PRVM_GetString(PRVM_serveredictstring(ent, model)) && sv.models[i]) ? i : 0;

 
        flags = 0;
        i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);
 
        flags = 0;
        i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);


@@ -1222,14 +1222,14 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        *cs = defaultstate;
        cs->active = ACTIVE_NETWORK;
        cs->number = enumber;
        *cs = defaultstate;
        cs->active = ACTIVE_NETWORK;
        cs->number = enumber;

-       VectorCopy(ent->fields.server->origin, cs->origin);
-       VectorCopy(ent->fields.server->angles, cs->angles);
+       VectorCopy(PRVM_serveredictvector(ent, origin), cs->origin);
+       VectorCopy(PRVM_serveredictvector(ent, angles), cs->angles);

        cs->flags = flags;
        cs->effects = effects;
        cs->flags = flags;
        cs->effects = effects;

-       cs->colormap = (unsigned)ent->fields.server->colormap;
+       cs->colormap = (unsigned)PRVM_serveredictfloat(ent, colormap);

        cs->modelindex = modelindex;
        cs->modelindex = modelindex;

-       cs->skin = (unsigned)ent->fields.server->skin;
-       cs->frame = (unsigned)ent->fields.server->frame;
+       cs->skin = (unsigned)PRVM_serveredictfloat(ent, skin);
+       cs->frame = (unsigned)PRVM_serveredictfloat(ent, frame);

        cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
        cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
        cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);
        cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
        cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
        cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);


@@ -1296,11 +1296,11 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        if (f)
                cs->effects |= ((unsigned int)f & 0xff) << 24;
 
        if (f)
                cs->effects |= ((unsigned int)f & 0xff) << 24;
 

-       if (ent->fields.server->movetype == MOVETYPE_STEP)
+       if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)

                cs->flags |= RENDER_STEP;
        if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
                cs->flags |= RENDER_LOWPRECISION;
                cs->flags |= RENDER_STEP;
        if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
                cs->flags |= RENDER_LOWPRECISION;

-       if (ent->fields.server->colormap >= 1024)
+       if (PRVM_serveredictfloat(ent, colormap) >= 1024)

                cs->flags |= RENDER_COLORMAPPED;
        if (cs->viewmodelforclient)
                cs->flags |= RENDER_VIEWMODEL; // show relative to the view
                cs->flags |= RENDER_COLORMAPPED;
        if (cs->viewmodelforclient)
                cs->flags |= RENDER_VIEWMODEL; // show relative to the view


@@ -1358,8 +1358,8 @@ static qboolean SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *c
        else
        {
                // if there is no model (or it could not be loaded), use the physics box
        else
        {
                // if there is no model (or it could not be loaded), use the physics box

-               VectorAdd(cs->origin, ent->fields.server->mins, cullmins);
-               VectorAdd(cs->origin, ent->fields.server->maxs, cullmaxs);
+               VectorAdd(cs->origin, PRVM_serveredictvector(ent, mins), cullmins);
+               VectorAdd(cs->origin, PRVM_serveredictvector(ent, maxs), cullmaxs);

        }
        if (specialvisibilityradius)
        {
        }
        if (specialvisibilityradius)
        {


@@ -1497,7 +1497,7 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
        for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
        {
                touch = touchedicts[touchindex];
        for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
        {
                touch = touchedicts[touchindex];

-               if (touch->fields.server->solid != SOLID_BSP)
+               if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)

                        continue;
                model = SV_GetModelFromEdict(touch);
                if (!model || !model->brush.TraceLineOfSight)
                        continue;
                model = SV_GetModelFromEdict(touch);
                if (!model || !model->brush.TraceLineOfSight)


@@ -1506,7 +1506,7 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
                alpha = PRVM_serveredictfloat(touch, alpha);
                if (alpha && alpha < 1)
                        continue;
                alpha = PRVM_serveredictfloat(touch, alpha);
                if (alpha && alpha < 1)
                        continue;

-               if ((int)touch->fields.server->effects & EF_ADDITIVE)
+               if ((int)PRVM_serveredictfloat(touch, effects) & EF_ADDITIVE)

                        continue;
                touchedicts[numtouchedicts++] = touch;
        }
                        continue;
                touchedicts[numtouchedicts++] = touch;
        }


@@ -1529,7 +1529,7 @@ qboolean SV_CanSeeBox(int numtraces, vec_t enlarge, vec3_t eye, vec3_t entboxmin
                        {
                                // get the entity matrix
                                pitchsign = SV_GetPitchSign(touch);
                        {
                                // get the entity matrix
                                pitchsign = SV_GetPitchSign(touch);

-                               Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+                               Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);

                                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                                // see if the ray hits this entity
                                Matrix4x4_Transform(&imatrix, eye, starttransformed);
                                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                                // see if the ray hits this entity
                                Matrix4x4_Transform(&imatrix, eye, starttransformed);


@@ -1564,8 +1564,8 @@ void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 
        if (s->customizeentityforclient)
        {
 
        if (s->customizeentityforclient)
        {

-               prog->globals.server->self = s->number;
-               prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
+               PRVM_serverglobaledict(self) = s->number;
+               PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;

                PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
                if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
                        return;
                PRVM_ExecuteProgram(s->customizeentityforclient, "customizeentityforclient: NULL function");
                if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
                        return;


@@ -1700,8 +1700,8 @@ void SV_AddCameraEyes(void)
                {
                        if(PRVM_serveredictfunction(ed, camera_transform))
                        {
                {
                        if(PRVM_serveredictfunction(ed, camera_transform))
                        {

-                               prog->globals.server->self = e;
-                               prog->globals.server->other = sv.writeentitiestoclient_cliententitynumber;
+                               PRVM_serverglobaledict(self) = e;
+                               PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;

                                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_serverglobalvector(trace_endpos));
                                VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_G_VECTOR(OFS_PARM0));
                                VectorClear(PRVM_G_VECTOR(OFS_PARM1));


@@ -1728,8 +1728,8 @@ void SV_AddCameraEyes(void)
                if(!cameras[j])
                        continue;
                ed = PRVM_EDICT_NUM(cameras[j]);
                if(!cameras[j])
                        continue;
                ed = PRVM_EDICT_NUM(cameras[j]);

-               VectorAdd(ed->fields.server->origin, ed->fields.server->mins, mi);
-               VectorAdd(ed->fields.server->origin, ed->fields.server->maxs, ma);
+               VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, mins), mi);
+               VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, maxs), ma);

                for(k = 0; k < sv.writeentitiestoclient_numeyes; ++k)
                if(eye_levels[k] <= MAX_EYE_RECURSION)
                {
                for(k = 0; k < sv.writeentitiestoclient_numeyes; ++k)
                if(eye_levels[k] <= MAX_EYE_RECURSION)
                {


@@ -1777,7 +1777,7 @@ void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *
        // get eye location
        sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
        camera = PRVM_EDICT_NUM( client->clientcamera );
        // get eye location
        sv.writeentitiestoclient_cliententitynumber = PRVM_EDICT_TO_PROG(clent); // LordHavoc: for comparison purposes
        camera = PRVM_EDICT_NUM( client->clientcamera );

-       VectorAdd(camera->fields.server->origin, clent->fields.server->view_ofs, eye);
+       VectorAdd(PRVM_serveredictvector(camera, origin), PRVM_serveredictvector(clent, view_ofs), eye);

        sv.writeentitiestoclient_pvsbytes = 0;
        // get the PVS values for the eye location, later FatPVS calls will merge
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
        sv.writeentitiestoclient_pvsbytes = 0;
        // get the PVS values for the eye location, later FatPVS calls will merge
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)


@@ -1792,7 +1792,7 @@ void SV_WriteEntitiesToClient(client_t *client, prvm_edict_t *clent, sizebuf_t *
        {
                vec_t predtime = bound(0, host_client->ping, sv_cullentities_trace_prediction_time.value);
                vec3_t predeye;
        {
                vec_t predtime = bound(0, host_client->ping, sv_cullentities_trace_prediction_time.value);
                vec3_t predeye;

-               VectorMA(eye, predtime, camera->fields.server->velocity, predeye);
+               VectorMA(eye, predtime, PRVM_serveredictvector(camera, velocity), predeye);

                if (SV_CanSeeBox(1, 0, eye, predeye, predeye))
                {
                        VectorCopy(predeye, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
                if (SV_CanSeeBox(1, 0, eye, predeye, predeye))
                {
                        VectorCopy(predeye, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);


@@ -1887,7 +1887,7 @@ static void SV_CleanupEnts (void)
 
        ent = PRVM_NEXT_EDICT(prog->edicts);
        for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
 
        ent = PRVM_NEXT_EDICT(prog->edicts);
        for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))

-               ent->fields.server->effects = (int)ent->fields.server->effects & ~EF_MUZZLEFLASH;
+               PRVM_serveredictfloat(ent, effects) = (int)PRVM_serveredictfloat(ent, effects) & ~EF_MUZZLEFLASH;

 }
 
 /*
 }
 
 /*


@@ -1911,17 +1911,17 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
 //
 // send a damage message
 //
 //
 // send a damage message
 //

-       if (ent->fields.server->dmg_take || ent->fields.server->dmg_save)
+       if (PRVM_serveredictfloat(ent, dmg_take) || PRVM_serveredictfloat(ent, dmg_save))

        {
        {

-               other = PRVM_PROG_TO_EDICT(ent->fields.server->dmg_inflictor);
+               other = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, dmg_inflictor));

                MSG_WriteByte (msg, svc_damage);
                MSG_WriteByte (msg, svc_damage);

-               MSG_WriteByte (msg, (int)ent->fields.server->dmg_save);
-               MSG_WriteByte (msg, (int)ent->fields.server->dmg_take);
+               MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_save));
+               MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_take));

                for (i=0 ; i<3 ; i++)
                for (i=0 ; i<3 ; i++)

-                       MSG_WriteCoord (msg, other->fields.server->origin[i] + 0.5*(other->fields.server->mins[i] + other->fields.server->maxs[i]), sv.protocol);
+                       MSG_WriteCoord (msg, PRVM_serveredictvector(other, origin)[i] + 0.5*(PRVM_serveredictvector(other, mins)[i] + PRVM_serveredictvector(other, maxs)[i]), sv.protocol);

 
 

-               ent->fields.server->dmg_take = 0;
-               ent->fields.server->dmg_save = 0;
+               PRVM_serveredictfloat(ent, dmg_take) = 0;
+               PRVM_serveredictfloat(ent, dmg_save) = 0;

        }
 
 //
        }
 
 //


@@ -1930,15 +1930,15 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
        SV_SetIdealPitch ();            // how much to look up / down ideally
 
 // a fixangle might get lost in a dropped packet.  Oh well.
        SV_SetIdealPitch ();            // how much to look up / down ideally
 
 // a fixangle might get lost in a dropped packet.  Oh well.

-       if(ent->fields.server->fixangle)
+       if(PRVM_serveredictfloat(ent, fixangle))

        {
                // angle fixing was requested by global thinking code...
                // so store the current angles for later use
        {
                // angle fixing was requested by global thinking code...
                // so store the current angles for later use

-               memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
+               memcpy(host_client->fixangle_angles, PRVM_serveredictvector(ent, angles), sizeof(host_client->fixangle_angles));

                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame
                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame

-               ent->fields.server->fixangle = 0;
+               PRVM_serveredictfloat(ent, fixangle) = 0;

        }
 
        if (host_client->fixangle_angles_set)
        }
 
        if (host_client->fixangle_angles_set)


@@ -1952,15 +1952,15 @@ 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_serveredictfloat(ent, items2) << 23);
+               items = (int)PRVM_serveredictfloat(ent, items) | ((int)PRVM_serveredictfloat(ent, items2) << 23);

        else
        else

-               items = (int)ent->fields.server->items | ((int)prog->globals.server->serverflags << 28);
+               items = (int)PRVM_serveredictfloat(ent, items) | ((int)PRVM_serverglobalfloat(serverflags) << 28);

 
        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!)
 
        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!)

-       s = PRVM_GetString(ent->fields.server->weaponmodel);
+       s = PRVM_GetString(PRVM_serveredictstring(ent, weaponmodel));

        if (strcmp(s, client->weaponmodel))
        {
                strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
        if (strcmp(s, client->weaponmodel))
        {
                strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));


@@ -1973,46 +1973,46 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
 
        bits = 0;
 
 
        bits = 0;
 

-       if ((int)ent->fields.server->flags & FL_ONGROUND)
+       if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)

                bits |= SU_ONGROUND;
                bits |= SU_ONGROUND;

-       if (ent->fields.server->waterlevel >= 2)
+       if (PRVM_serveredictfloat(ent, waterlevel) >= 2)

                bits |= SU_INWATER;
                bits |= SU_INWATER;

-       if (ent->fields.server->idealpitch)
+       if (PRVM_serveredictfloat(ent, idealpitch))

                bits |= SU_IDEALPITCH;
 
        for (i=0 ; i<3 ; i++)
        {
                bits |= SU_IDEALPITCH;
 
        for (i=0 ; i<3 ; i++)
        {

-               if (ent->fields.server->punchangle[i])
+               if (PRVM_serveredictvector(ent, punchangle)[i])

                        bits |= (SU_PUNCH1<<i);
                if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
                        if (punchvector[i])
                                bits |= (SU_PUNCHVEC1<<i);
                        bits |= (SU_PUNCH1<<i);
                if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
                        if (punchvector[i])
                                bits |= (SU_PUNCHVEC1<<i);

-               if (ent->fields.server->velocity[i])
+               if (PRVM_serveredictvector(ent, velocity)[i])

                        bits |= (SU_VELOCITY1<<i);
        }
 
        gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;
 
        memset(stats, 0, sizeof(int[MAX_CL_STATS]));
                        bits |= (SU_VELOCITY1<<i);
        }
 
        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];
+       stats[STAT_VIEWHEIGHT] = (int)PRVM_serveredictvector(ent, view_ofs)[2];

        stats[STAT_ITEMS] = items;
        stats[STAT_ITEMS] = items;

-       stats[STAT_WEAPONFRAME] = (int)ent->fields.server->weaponframe;
-       stats[STAT_ARMOR] = (int)ent->fields.server->armorvalue;
+       stats[STAT_WEAPONFRAME] = (int)PRVM_serveredictfloat(ent, weaponframe);
+       stats[STAT_ARMOR] = (int)PRVM_serveredictfloat(ent, armorvalue);

        stats[STAT_WEAPON] = client->weaponmodelindex;
        stats[STAT_WEAPON] = client->weaponmodelindex;

-       stats[STAT_HEALTH] = (int)ent->fields.server->health;
-       stats[STAT_AMMO] = (int)ent->fields.server->currentammo;
-       stats[STAT_SHELLS] = (int)ent->fields.server->ammo_shells;
-       stats[STAT_NAILS] = (int)ent->fields.server->ammo_nails;
-       stats[STAT_ROCKETS] = (int)ent->fields.server->ammo_rockets;
-       stats[STAT_CELLS] = (int)ent->fields.server->ammo_cells;
-       stats[STAT_ACTIVEWEAPON] = (int)ent->fields.server->weapon;
+       stats[STAT_HEALTH] = (int)PRVM_serveredictfloat(ent, health);
+       stats[STAT_AMMO] = (int)PRVM_serveredictfloat(ent, currentammo);
+       stats[STAT_SHELLS] = (int)PRVM_serveredictfloat(ent, ammo_shells);
+       stats[STAT_NAILS] = (int)PRVM_serveredictfloat(ent, ammo_nails);
+       stats[STAT_ROCKETS] = (int)PRVM_serveredictfloat(ent, ammo_rockets);
+       stats[STAT_CELLS] = (int)PRVM_serveredictfloat(ent, ammo_cells);
+       stats[STAT_ACTIVEWEAPON] = (int)PRVM_serveredictfloat(ent, weapon);

        stats[STAT_VIEWZOOM] = viewzoom;
        stats[STAT_VIEWZOOM] = viewzoom;

-       stats[STAT_TOTALSECRETS] = (int)prog->globals.server->total_secrets;
-       stats[STAT_TOTALMONSTERS] = (int)prog->globals.server->total_monsters;
+       stats[STAT_TOTALSECRETS] = (int)PRVM_serverglobalfloat(total_secrets);
+       stats[STAT_TOTALMONSTERS] = (int)PRVM_serverglobalfloat(total_monsters);

        // the QC bumps these itself by sending svc_'s, so we have to keep them
        // zero or they'll be corrected by the engine
        // the QC bumps these itself by sending svc_'s, so we have to keep them
        // zero or they'll be corrected by the engine

-       //stats[STAT_SECRETS] = prog->globals.server->found_secrets;
-       //stats[STAT_MONSTERS] = prog->globals.server->killed_monsters;
+       //stats[STAT_SECRETS] = PRVM_serverglobalfloat(found_secrets);
+       //stats[STAT_MONSTERS] = PRVM_serverglobalfloat(killed_monsters);

 
        // movement settings for prediction
        // note: these are not sent in protocols with lower MAX_CL_STATS limits
 
        // movement settings for prediction
        // note: these are not sent in protocols with lower MAX_CL_STATS limits


@@ -2086,16 +2086,16 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
 
        if (bits & SU_IDEALPITCH)
                MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
 
        if (bits & SU_IDEALPITCH)

-               MSG_WriteChar (msg, (int)ent->fields.server->idealpitch);
+               MSG_WriteChar (msg, (int)PRVM_serveredictfloat(ent, idealpitch));

 
        for (i=0 ; i<3 ; i++)
        {
                if (bits & (SU_PUNCH1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
 
        for (i=0 ; i<3 ; i++)
        {
                if (bits & (SU_PUNCH1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)

-                               MSG_WriteChar(msg, (int)ent->fields.server->punchangle[i]);
+                               MSG_WriteChar(msg, (int)PRVM_serveredictvector(ent, punchangle)[i]);

                        else
                        else

-                               MSG_WriteAngle16i(msg, ent->fields.server->punchangle[i]);
+                               MSG_WriteAngle16i(msg, PRVM_serveredictvector(ent, punchangle)[i]);

                }
                if (bits & (SU_PUNCHVEC1<<i))
                {
                }
                if (bits & (SU_PUNCHVEC1<<i))
                {


@@ -2107,9 +2107,9 @@ void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t
                if (bits & (SU_VELOCITY1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
                if (bits & (SU_VELOCITY1<<i))
                {
                        if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)

-                               MSG_WriteChar(msg, (int)(ent->fields.server->velocity[i] * (1.0f / 16.0f)));
+                               MSG_WriteChar(msg, (int)(PRVM_serveredictvector(ent, velocity)[i] * (1.0f / 16.0f)));

                        else
                        else

-                               MSG_WriteCoord32f(msg, ent->fields.server->velocity[i]);
+                               MSG_WriteCoord32f(msg, PRVM_serveredictvector(ent, velocity)[i]);

                }
        }
 
                }
        }
 


@@ -2394,12 +2394,12 @@ static void SV_UpdateToReliableMessages (void)
                host_client->edict = PRVM_EDICT_NUM(i+1);
 
                // DP_SV_CLIENTNAME
                host_client->edict = PRVM_EDICT_NUM(i+1);
 
                // DP_SV_CLIENTNAME

-               name = PRVM_GetString(host_client->edict->fields.server->netname);
+               name = PRVM_GetString(PRVM_serveredictstring(host_client->edict, netname));

                if (name == NULL)
                        name = "";
                // always point the string back at host_client->name to keep it safe
                strlcpy (host_client->name, name, sizeof (host_client->name));
                if (name == NULL)
                        name = "";
                // always point the string back at host_client->name to keep it safe
                strlcpy (host_client->name, name, sizeof (host_client->name));

-               host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
+               PRVM_serveredictstring(host_client->edict, netname) = PRVM_SetEngineString(host_client->name);

                if (strcmp(host_client->old_name, host_client->name))
                {
                        if (host_client->spawned)
                if (strcmp(host_client->old_name, host_client->name))
                {
                        if (host_client->spawned)


@@ -2456,7 +2456,7 @@ static void SV_UpdateToReliableMessages (void)
                }
 
                // frags
                }
 
                // frags

-               host_client->frags = (int)host_client->edict->fields.server->frags;
+               host_client->frags = (int)PRVM_serveredictfloat(host_client->edict, frags);

                if(gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC)
                        if(!host_client->spawned && host_client->netconnection)
                                host_client->frags = -666;
                if(gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC)
                        if(!host_client->spawned && host_client->netconnection)
                                host_client->frags = -666;


@@ -2965,7 +2965,7 @@ dp_model_t *SV_GetModelFromEdict(prvm_edict_t *ed)
        int modelindex;
        if (!ed || ed->priv.server->free)
                return NULL;
        int modelindex;
        if (!ed || ed->priv.server->free)
                return NULL;

-       modelindex = (int)ed->fields.server->modelindex;
+       modelindex = (int)PRVM_serveredictfloat(ed, modelindex);

        return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
 }
 
        return (modelindex > 0 && modelindex < MAX_MODELS) ? sv.models[modelindex] : NULL;
 }
 


@@ -2991,14 +2991,14 @@ static void SV_CreateBaseline (void)
 
                if (svent->priv.server->free)
                        continue;
 
                if (svent->priv.server->free)
                        continue;

-               if (entnum > svs.maxclients && !svent->fields.server->modelindex)
+               if (entnum > svs.maxclients && !PRVM_serveredictfloat(svent, modelindex))

                        continue;
 
                // create entity baseline
                        continue;
 
                // create entity baseline

-               VectorCopy (svent->fields.server->origin, svent->priv.server->baseline.origin);
-               VectorCopy (svent->fields.server->angles, svent->priv.server->baseline.angles);
-               svent->priv.server->baseline.frame = (int)svent->fields.server->frame;
-               svent->priv.server->baseline.skin = (int)svent->fields.server->skin;
+               VectorCopy (PRVM_serveredictvector(svent, origin), svent->priv.server->baseline.origin);
+               VectorCopy (PRVM_serveredictvector(svent, angles), svent->priv.server->baseline.angles);
+               svent->priv.server->baseline.frame = (int)PRVM_serveredictfloat(svent, frame);
+               svent->priv.server->baseline.skin = (int)PRVM_serveredictfloat(svent, skin);

                if (entnum > 0 && entnum <= svs.maxclients)
                {
                        svent->priv.server->baseline.colormap = entnum;
                if (entnum > 0 && entnum <= svs.maxclients)
                {
                        svent->priv.server->baseline.colormap = entnum;


@@ -3007,7 +3007,7 @@ static void SV_CreateBaseline (void)
                else
                {
                        svent->priv.server->baseline.colormap = 0;
                else
                {
                        svent->priv.server->baseline.colormap = 0;

-                       svent->priv.server->baseline.modelindex = (int)svent->fields.server->modelindex;
+                       svent->priv.server->baseline.modelindex = (int)PRVM_serveredictfloat(svent, modelindex);

                }
 
                large = false;
                }
 
                large = false;


@@ -3111,7 +3111,7 @@ void SV_SaveSpawnparms (void)
 {
        int             i, j;
 
 {
        int             i, j;
 

-       svs.serverflags = (int)prog->globals.server->serverflags;
+       svs.serverflags = (int)PRVM_serverglobalfloat(serverflags);

 
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {
 
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {


@@ -3119,10 +3119,10 @@ void SV_SaveSpawnparms (void)
                        continue;
 
        // call the progs to get default spawn parms for the new client
                        continue;
 
        // call the progs to get default spawn parms for the new client

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-               PRVM_ExecuteProgram (prog->globals.server->SetChangeParms, "QC function SetChangeParms is missing");
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_ExecuteProgram (PRVM_serverfunction(SetChangeParms), "QC function SetChangeParms is missing");

                for (j=0 ; j<NUM_SPAWN_PARMS ; j++)
                for (j=0 ; j<NUM_SPAWN_PARMS ; j++)

-                       host_client->spawn_parms[j] = (&prog->globals.server->parm1)[j];
+                       host_client->spawn_parms[j] = (&PRVM_serverglobalfloat(parm1))[j];

        }
 }
 
        }
 }
 


@@ -3292,7 +3292,7 @@ void SV_SpawnServer (const char *server)
        prog->allowworldwrites = true;
        sv.paused = false;
 
        prog->allowworldwrites = true;
        sv.paused = false;
 

-       prog->globals.server->time = sv.time = 1.0;
+       PRVM_serverglobalfloat(time) = sv.time = 1.0;

 
        Mod_ClearUsed();
        worldmodel->used = true;
 
        Mod_ClearUsed();
        worldmodel->used = true;


@@ -3323,26 +3323,26 @@ void SV_SpawnServer (const char *server)
 //
        // AK possible hack since num_edicts is still 0
        ent = PRVM_EDICT_NUM(0);
 //
        // AK possible hack since num_edicts is still 0
        ent = PRVM_EDICT_NUM(0);

-       memset (ent->fields.server, 0, prog->entityfields * 4);
+       memset (ent->fields.vp, 0, prog->entityfields * 4);

        ent->priv.server->free = false;
        ent->priv.server->free = false;

-       ent->fields.server->model = PRVM_SetEngineString(sv.worldname);
-       ent->fields.server->modelindex = 1;             // world model
-       ent->fields.server->solid = SOLID_BSP;
-       ent->fields.server->movetype = MOVETYPE_PUSH;
-       VectorCopy(sv.world.mins, ent->fields.server->mins);
-       VectorCopy(sv.world.maxs, ent->fields.server->maxs);
-       VectorCopy(sv.world.mins, ent->fields.server->absmin);
-       VectorCopy(sv.world.maxs, ent->fields.server->absmax);
+       PRVM_serveredictstring(ent, model) = PRVM_SetEngineString(sv.worldname);
+       PRVM_serveredictfloat(ent, modelindex) = 1;             // world model
+       PRVM_serveredictfloat(ent, solid) = SOLID_BSP;
+       PRVM_serveredictfloat(ent, movetype) = MOVETYPE_PUSH;
+       VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, mins));
+       VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, maxs));
+       VectorCopy(sv.world.mins, PRVM_serveredictvector(ent, absmin));
+       VectorCopy(sv.world.maxs, PRVM_serveredictvector(ent, absmax));

 
        if (coop.value)
 
        if (coop.value)

-               prog->globals.server->coop = coop.integer;
+               PRVM_serverglobalfloat(coop) = coop.integer;

        else
        else

-               prog->globals.server->deathmatch = deathmatch.integer;
+               PRVM_serverglobalfloat(deathmatch) = deathmatch.integer;

 
 

-       prog->globals.server->mapname = PRVM_SetEngineString(sv.name);
+       PRVM_serverglobalstring(mapname) = PRVM_SetEngineString(sv.name);

 
 // serverflags are for cross level information (sigils)
 
 // serverflags are for cross level information (sigils)

-       prog->globals.server->serverflags = svs.serverflags;
+       PRVM_serverglobalfloat(serverflags) = svs.serverflags;

 
        // we need to reset the spawned flag on all connected clients here so that
        // their thinks don't run during startup (before PutClientInServer)
 
        // we need to reset the spawned flag on all connected clients here so that
        // their thinks don't run during startup (before PutClientInServer)


@@ -3367,14 +3367,14 @@ void SV_SpawnServer (const char *server)
 
 
        // LordHavoc: clear world angles (to fix e3m3.bsp)
 
 
        // LordHavoc: clear world angles (to fix e3m3.bsp)

-       VectorClear(prog->edicts->fields.server->angles);
+       VectorClear(PRVM_serveredictvector(prog->edicts, angles));

 
 // all setup is completed, any further precache statements are errors
 //     sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
        prog->allowworldwrites = false;
 
 // run two frames to allow everything to settle
 
 // all setup is completed, any further precache statements are errors
 //     sv.state = ss_active; // LordHavoc: workaround for svc_precache bug
        prog->allowworldwrites = false;
 
 // run two frames to allow everything to settle

-       prog->globals.server->time = sv.time = 1.0001;
+       PRVM_serverglobalfloat(time) = sv.time = 1.0001;

        for (i = 0;i < 2;i++)
        {
                sv.frametime = 0.1;
        for (i = 0;i < 2;i++)
        {
                sv.frametime = 0.1;


@@ -3409,20 +3409,20 @@ void SV_SpawnServer (const char *server)
 
                        // copy spawn parms out of the client_t
                        for (j=0 ; j< NUM_SPAWN_PARMS ; j++)
 
                        // copy spawn parms out of the client_t
                        for (j=0 ; j< NUM_SPAWN_PARMS ; j++)

-                               (&prog->globals.server->parm1)[j] = host_client->spawn_parms[j];
+                               (&PRVM_serverglobalfloat(parm1))[j] = host_client->spawn_parms[j];

 
                        // call the spawn function
                        host_client->clientconnectcalled = true;
 
                        // call the spawn function
                        host_client->clientconnectcalled = true;

-                       prog->globals.server->time = sv.time;
-                       prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
-                       PRVM_ExecuteProgram (prog->globals.server->ClientConnect, "QC function ClientConnect is missing");
-                       PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
+                       PRVM_serverglobalfloat(time) = sv.time;
+                       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);
+                       PRVM_ExecuteProgram (PRVM_serverfunction(ClientConnect), "QC function ClientConnect is missing");
+                       PRVM_ExecuteProgram (PRVM_serverfunction(PutClientInServer), "QC function PutClientInServer is missing");

                        host_client->spawned = true;
                }
        }
 
        // update the map title cvar
                        host_client->spawned = true;
                }
        }
 
        // update the map title cvar

-       strlcpy(sv.worldmessage, PRVM_GetString(prog->edicts->fields.server->message), sizeof(sv.worldmessage)); // map title (not related to filename)
+       strlcpy(sv.worldmessage, PRVM_GetString(PRVM_serveredictstring(prog->edicts, message)), sizeof(sv.worldmessage)); // map title (not related to filename)

        Cvar_SetQuick(&sv_worldmessage, sv.worldmessage);
 
        Con_DPrint("Server spawned.\n");
        Cvar_SetQuick(&sv_worldmessage, sv.worldmessage);
 
        Con_DPrint("Server spawned.\n");


@@ -3461,12 +3461,12 @@ static void SV_VM_CB_InitEdict(prvm_edict_t *e)
        if (num >= 0 && num < svs.maxclients)
        {
                // set colormap and team on newly created player entity
        if (num >= 0 && num < svs.maxclients)
        {
                // set colormap and team on newly created player entity

-               e->fields.server->colormap = num + 1;
-               e->fields.server->team = (svs.clients[num].colors & 15) + 1;
+               PRVM_serveredictfloat(e, colormap) = num + 1;
+               PRVM_serveredictfloat(e, team) = (svs.clients[num].colors & 15) + 1;

                // set netname/clientcolors back to client values so that
                // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
                // reset them
                // set netname/clientcolors back to client values so that
                // DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS will not immediately
                // reset them

-               e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
+               PRVM_serveredictstring(e, netname) = PRVM_SetEngineString(svs.clients[num].name);

                PRVM_serveredictfloat(e, clientcolors) = svs.clients[num].colors;
                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
                PRVM_serveredictstring(e, playermodel) = PRVM_SetEngineString(svs.clients[num].playermodel);
                PRVM_serveredictfloat(e, clientcolors) = svs.clients[num].colors;
                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
                PRVM_serveredictstring(e, playermodel) = PRVM_SetEngineString(svs.clients[num].playermodel);


@@ -3510,16 +3510,16 @@ static void SV_VM_CB_FreeEdict(prvm_edict_t *ed)
 
        World_UnlinkEdict(ed);          // unlink from world bsp
 
 
        World_UnlinkEdict(ed);          // unlink from world bsp
 

-       ed->fields.server->model = 0;
-       ed->fields.server->takedamage = 0;
-       ed->fields.server->modelindex = 0;
-       ed->fields.server->colormap = 0;
-       ed->fields.server->skin = 0;
-       ed->fields.server->frame = 0;
-       VectorClear(ed->fields.server->origin);
-       VectorClear(ed->fields.server->angles);
-       ed->fields.server->nextthink = -1;
-       ed->fields.server->solid = 0;
+       PRVM_serveredictstring(ed, model) = 0;
+       PRVM_serveredictfloat(ed, takedamage) = 0;
+       PRVM_serveredictfloat(ed, modelindex) = 0;
+       PRVM_serveredictfloat(ed, colormap) = 0;
+       PRVM_serveredictfloat(ed, skin) = 0;
+       PRVM_serveredictfloat(ed, frame) = 0;
+       VectorClear(PRVM_serveredictvector(ed, origin));
+       VectorClear(PRVM_serveredictvector(ed, angles));
+       PRVM_serveredictfloat(ed, nextthink) = -1;
+       PRVM_serveredictfloat(ed, solid) = 0;

 
        VM_RemoveEdictSkeleton(ed);
        World_Physics_RemoveFromEntity(&sv.world, ed);
 
        VM_RemoveEdictSkeleton(ed);
        World_Physics_RemoveFromEntity(&sv.world, ed);


@@ -3549,11 +3549,11 @@ static void SV_VM_CB_CountEdicts(void)
                if (ent->priv.server->free)
                        continue;
                active++;
                if (ent->priv.server->free)
                        continue;
                active++;

-               if (ent->fields.server->solid)
+               if (PRVM_serveredictfloat(ent, solid))

                        solid++;
                        solid++;

-               if (ent->fields.server->model)
+               if (PRVM_serveredictstring(ent, model))

                        models++;
                        models++;

-               if (ent->fields.server->movetype == MOVETYPE_STEP)
+               if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)

                        step++;
        }
 
                        step++;
        }
 


@@ -3571,14 +3571,14 @@ static qboolean SV_VM_CB_LoadEdict(prvm_edict_t *ent)
        {
                if (deathmatch.integer)
                {
        {
                if (deathmatch.integer)
                {

-                       if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
+                       if (((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_DEATHMATCH))

                        {
                                return false;
                        }
                }
                        {
                                return false;
                        }
                }

-               else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY  ))
-                       || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
-                       || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD  )))
+               else if ((current_skill <= 0 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_EASY  ))
+                       || (current_skill == 1 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_MEDIUM))
+                       || (current_skill >= 2 && ((int)PRVM_serveredictfloat(ent, spawnflags) & SPAWNFLAG_NOT_HARD  )))

                {
                        return false;
                }
                {
                        return false;
                }


@@ -3596,8 +3596,6 @@ static void SV_VM_Setup(void)
        prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
        prog->builtins = vm_sv_builtins;
        prog->numbuiltins = vm_sv_numbuiltins;
        prog->progs_mempool = Mem_AllocPool("Server Progs", 0, NULL);
        prog->builtins = vm_sv_builtins;
        prog->numbuiltins = vm_sv_numbuiltins;

-       prog->headercrc = PROGHEADER_CRC;
-       prog->headercrc2 = PROGHEADER_CRC_TENEBRAE;

        prog->max_edicts = 512;
        if (sv.protocol == PROTOCOL_QUAKE)
                prog->limit_edicts = 640; // before quake mission pack 1 this was 512
        prog->max_edicts = 512;
        if (sv.protocol == PROTOCOL_QUAKE)
                prog->limit_edicts = 640; // before quake mission pack 1 this was 512


@@ -3631,30 +3629,145 @@ static void SV_VM_Setup(void)
        // some mods compiled with scrambling compilers lack certain critical
        // global names and field names such as "self" and "time" and "nextthink"
        // so we have to set these offsets manually, matching the entvars_t
        // some mods compiled with scrambling compilers lack certain critical
        // global names and field names such as "self" and "time" and "nextthink"
        // so we have to set these offsets manually, matching the entvars_t

-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
-       PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
-       PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
-       // OP_STATE is always supported on server (due to entvars_t)
+       // but we only do this if the prog header crc matches, otherwise it's totally freeform
+       if (prog->progs_crc == PROGHEADER_CRC || prog->progs_crc == PROGHEADER_CRC_TENEBRAE)
+       {
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, modelindex);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, absmax);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ltime);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movetype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, solid);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, origin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, oldorigin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, velocity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, angles);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, avelocity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, punchangle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, classname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, model);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frame);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, skin);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, effects);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, mins);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, maxs);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, size);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, touch);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, use);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, think);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, blocked);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, nextthink);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, groundentity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, health);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, frags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weapon);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponmodel);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, weaponframe);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, currentammo);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_shells);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_nails);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_rockets);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ammo_cells);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, items);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, takedamage);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, chain);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, deadflag);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, view_ofs);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button0);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button1);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, button2);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, impulse);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, fixangle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, v_angle);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, idealpitch);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, netname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, enemy);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, flags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, colormap);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, team);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, max_health);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, teleport_time);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armortype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, armorvalue);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, waterlevel);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, watertype);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, ideal_yaw);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, yaw_speed);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, aiment);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, goalentity);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, spawnflags);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, target);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, targetname);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_take);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_save);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, dmg_inflictor);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, owner);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, movedir);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, message);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, sounds);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise1);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise2);
+               PRVM_ED_FindFieldOffset_FromStruct(entvars_t, noise3);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, self);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, other);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, world);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, time);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, frametime);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, force_retouch);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, mapname);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, deathmatch);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, coop);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, teamplay);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, serverflags);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_secrets);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, total_monsters);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, found_secrets);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, killed_monsters);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm1);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm2);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm3);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm4);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm5);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm6);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm7);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm8);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm9);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm10);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm11);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm12);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm13);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm14);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm15);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, parm16);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_forward);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_up);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, v_right);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_allsolid);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_startsolid);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_fraction);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_endpos);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_normal);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_plane_dist);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_ent);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inopen);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, trace_inwater);
+               PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, msg_entity);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, main);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, StartFrame);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPreThink);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PlayerPostThink);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientKill);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientConnect);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, PutClientInServer);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, ClientDisconnect);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetNewParms);
+//             PRVM_ED_FindGlobalOffset_FromStruct(globalvars_t, SetChangeParms);
+       }
+       else
+               Con_DPrintf("%s: %s system vars have been modified (CRC %i != engine %i), will not load in other engines", PRVM_NAME, sv_progs.string, prog->progs_crc, PROGHEADER_CRC);
+
+       // OP_STATE is always supported on server because we add fields/globals for it

        prog->flag |= PRVM_OP_STATE;
 
        VM_CustomStats_Clear();//[515]: csqc
        prog->flag |= PRVM_OP_STATE;
 
        VM_CustomStats_Clear();//[515]: csqc


@@ -3669,7 +3782,7 @@ void SV_VM_Begin(void)
        PRVM_Begin;
        PRVM_SetProg( PRVM_SERVERPROG );
 
        PRVM_Begin;
        PRVM_SetProg( PRVM_SERVERPROG );
 

-       prog->globals.server->time = (float) sv.time;
+       PRVM_serverglobalfloat(time) = (float) sv.time;

 }
 
 void SV_VM_End(void)
 }
 
 void SV_VM_End(void)

diff --git a/sv_move.c b/sv_move.c
index f8a1cfb6cabe0da5e392ae062a7f850f4fe0d007..d93d1f8b2b6fbc948b30515f9776fac46e1fccc8 100644 (file)
--- a/sv_move.c
+++ b/sv_move.c
@@ -40,8 +40,8 @@ qboolean SV_CheckBottom (prvm_edict_t *ent)
        int             x, y;
        float   mid, bottom;
 
        int             x, y;
        float   mid, bottom;
 

-       VectorAdd (ent->fields.server->origin, ent->fields.server->mins, mins);
-       VectorAdd (ent->fields.server->origin, ent->fields.server->maxs, maxs);
+       VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
+       VectorAdd (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);

 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks
 
 // if all of the points under the corners are solid world, don't bother
 // with the tougher checks


@@ -114,39 +114,39 @@ qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        prvm_edict_t            *enemy;
 
 // try the move
        prvm_edict_t            *enemy;
 
 // try the move

-       VectorCopy (ent->fields.server->origin, oldorg);
-       VectorAdd (ent->fields.server->origin, move, neworg);
+       VectorCopy (PRVM_serveredictvector(ent, origin), oldorg);
+       VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);

 
 // flying monsters don't step up
 
 // flying monsters don't step up

-       if ( (int)ent->fields.server->flags & (FL_SWIM | FL_FLY) )
+       if ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) )

        {
        // try one move with vertical motion, then one without
                for (i=0 ; i<2 ; i++)
                {
        {
        // try one move with vertical motion, then one without
                for (i=0 ; i<2 ; i++)
                {

-                       VectorAdd (ent->fields.server->origin, move, neworg);
+                       VectorAdd (PRVM_serveredictvector(ent, origin), move, neworg);

                        if (noenemy)
                                enemy = prog->edicts;
                        else
                        {
                        if (noenemy)
                                enemy = prog->edicts;
                        else
                        {

-                               enemy = PRVM_PROG_TO_EDICT(ent->fields.server->enemy);
+                               enemy = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy));

                                if (i == 0 && enemy != prog->edicts)
                                {
                                if (i == 0 && enemy != prog->edicts)
                                {

-                                       dz = ent->fields.server->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.server->enemy)->fields.server->origin[2];
+                                       dz = PRVM_serveredictvector(ent, origin)[2] - PRVM_serveredictvector(enemy, origin)[2];

                                        if (dz > 40)
                                                neworg[2] -= 8;
                                        if (dz < 30)
                                                neworg[2] += 8;
                                }
                        }
                                        if (dz > 40)
                                                neworg[2] -= 8;
                                        if (dz < 30)
                                                neworg[2] += 8;
                                }
                        }

-                       trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
+                       trace = SV_TraceBox(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), neworg, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));

 
                        if (trace.fraction == 1)
                        {
                                VectorCopy(trace.endpos, traceendpos);
 
                        if (trace.fraction == 1)
                        {
                                VectorCopy(trace.endpos, traceendpos);

-                               if (((int)ent->fields.server->flags & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
+                               if (((int)PRVM_serveredictfloat(ent, flags) & FL_SWIM) && !(SV_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))

                                        return false;   // swim monster left water
 
                                        return false;   // swim monster left water
 

-                               VectorCopy (traceendpos, ent->fields.server->origin);
+                               VectorCopy (traceendpos, PRVM_serveredictvector(ent, origin));

                                if (relink)
                                {
                                        SV_LinkEdict(ent);
                                if (relink)
                                {
                                        SV_LinkEdict(ent);


@@ -167,27 +167,27 @@ qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        VectorCopy (neworg, end);
        end[2] -= sv_stepheight.value*2;
 
        VectorCopy (neworg, end);
        end[2] -= sv_stepheight.value*2;
 

-       trace = SV_TraceBox(neworg, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
+       trace = SV_TraceBox(neworg, PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));

 
        if (trace.startsolid)
        {
                neworg[2] -= sv_stepheight.value;
 
        if (trace.startsolid)
        {
                neworg[2] -= sv_stepheight.value;

-               trace = SV_TraceBox(neworg, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
+               trace = SV_TraceBox(neworg, PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));

                if (trace.startsolid)
                        return false;
        }
        if (trace.fraction == 1)
        {
        // if monster had the ground pulled out, go ahead and fall
                if (trace.startsolid)
                        return false;
        }
        if (trace.fraction == 1)
        {
        // if monster had the ground pulled out, go ahead and fall

-               if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
+               if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )

                {
                {

-                       VectorAdd (ent->fields.server->origin, move, ent->fields.server->origin);
+                       VectorAdd (PRVM_serveredictvector(ent, origin), move, PRVM_serveredictvector(ent, origin));

                        if (relink)
                        {
                                SV_LinkEdict(ent);
                                SV_LinkEdict_TouchAreaGrid(ent);
                        }
                        if (relink)
                        {
                                SV_LinkEdict(ent);
                                SV_LinkEdict_TouchAreaGrid(ent);
                        }

-                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

                        return true;
                }
 
                        return true;
                }
 


@@ -195,11 +195,11 @@ qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
        }
 
 // check point traces down for dangling corners
        }
 
 // check point traces down for dangling corners

-       VectorCopy (trace.endpos, ent->fields.server->origin);
+       VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));

 
        if (!SV_CheckBottom (ent))
        {
 
        if (!SV_CheckBottom (ent))
        {

-               if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
+               if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )

                {       // entity had floor mostly pulled out from underneath it
                        // and is trying to correct
                        if (relink)
                {       // entity had floor mostly pulled out from underneath it
                        // and is trying to correct
                        if (relink)


@@ -209,24 +209,24 @@ qboolean SV_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean
                        }
                        return true;
                }
                        }
                        return true;
                }

-               VectorCopy (oldorg, ent->fields.server->origin);
+               VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));

                return false;
        }
 
                return false;
        }
 

-       if ( (int)ent->fields.server->flags & FL_PARTIALGROUND )
-               ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_PARTIALGROUND;
+       if ( (int)PRVM_serveredictfloat(ent, flags) & FL_PARTIALGROUND )
+               PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_PARTIALGROUND;

 
 // gameplayfix: check if reached pretty steep plane and bail
 
 // gameplayfix: check if reached pretty steep plane and bail

-       if ( ! ( (int)ent->fields.server->flags & (FL_SWIM | FL_FLY) ) && sv_gameplayfix_nostepmoveonsteepslopes.integer )
+       if ( ! ( (int)PRVM_serveredictfloat(ent, flags) & (FL_SWIM | FL_FLY) ) && sv_gameplayfix_nostepmoveonsteepslopes.integer )

        {
                if (trace.plane.normal[ 2 ] < 0.5)
                {
        {
                if (trace.plane.normal[ 2 ] < 0.5)
                {

-                       VectorCopy (oldorg, ent->fields.server->origin);
+                       VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));

                        return false;
                }
        }
 
                        return false;
                }
        }
 

-       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+       PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);

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


@@ -255,7 +255,7 @@ qboolean SV_StepDirection (prvm_edict_t *ent, float yaw, float dist)
        vec3_t          move, oldorigin;
        float           delta;
 
        vec3_t          move, oldorigin;
        float           delta;
 

-       ent->fields.server->ideal_yaw = yaw;
+       PRVM_serveredictfloat(ent, ideal_yaw) = yaw;

        VM_changeyaw();
 
        yaw = yaw*M_PI*2 / 360;
        VM_changeyaw();
 
        yaw = yaw*M_PI*2 / 360;


@@ -263,13 +263,13 @@ qboolean SV_StepDirection (prvm_edict_t *ent, float yaw, float dist)
        move[1] = sin(yaw)*dist;
        move[2] = 0;
 
        move[1] = sin(yaw)*dist;
        move[2] = 0;
 

-       VectorCopy (ent->fields.server->origin, oldorigin);
+       VectorCopy (PRVM_serveredictvector(ent, origin), oldorigin);

        if (SV_movestep (ent, move, false, false, false))
        {
        if (SV_movestep (ent, move, false, false, false))
        {

-               delta = ent->fields.server->angles[YAW] - ent->fields.server->ideal_yaw;
+               delta = PRVM_serveredictvector(ent, angles)[YAW] - PRVM_serveredictfloat(ent, ideal_yaw);

                if (delta > 45 && delta < 315)
                {               // not turned far enough, so don't take the step
                if (delta > 45 && delta < 315)
                {               // not turned far enough, so don't take the step

-                       VectorCopy (oldorigin, ent->fields.server->origin);
+                       VectorCopy (oldorigin, PRVM_serveredictvector(ent, origin));

                }
                SV_LinkEdict(ent);
                SV_LinkEdict_TouchAreaGrid(ent);
                }
                SV_LinkEdict(ent);
                SV_LinkEdict_TouchAreaGrid(ent);


@@ -289,7 +289,7 @@ SV_FixCheckBottom
 */
 void SV_FixCheckBottom (prvm_edict_t *ent)
 {
 */
 void SV_FixCheckBottom (prvm_edict_t *ent)
 {

-       ent->fields.server->flags = (int)ent->fields.server->flags | FL_PARTIALGROUND;
+       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_PARTIALGROUND;

 }
 
 
 }
 
 


@@ -307,11 +307,11 @@ void SV_NewChaseDir (prvm_edict_t *actor, prvm_edict_t *enemy, float dist)
        float                   d[3];
        float           tdir, olddir, turnaround;
 
        float                   d[3];
        float           tdir, olddir, turnaround;
 

-       olddir = ANGLEMOD((int)(actor->fields.server->ideal_yaw/45)*45);
+       olddir = ANGLEMOD((int)(PRVM_serveredictfloat(actor, ideal_yaw)/45)*45);

        turnaround = ANGLEMOD(olddir - 180);
 
        turnaround = ANGLEMOD(olddir - 180);
 

-       deltax = enemy->fields.server->origin[0] - actor->fields.server->origin[0];
-       deltay = enemy->fields.server->origin[1] - actor->fields.server->origin[1];
+       deltax = PRVM_serveredictvector(enemy, origin)[0] - PRVM_serveredictvector(actor, origin)[0];
+       deltay = PRVM_serveredictvector(enemy, origin)[1] - PRVM_serveredictvector(actor, origin)[1];

        if (deltax>10)
                d[1]= 0;
        else if (deltax<-10)
        if (deltax>10)
                d[1]= 0;
        else if (deltax<-10)


@@ -374,7 +374,7 @@ void SV_NewChaseDir (prvm_edict_t *actor, prvm_edict_t *enemy, float dist)
        if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
                        return;
 
        if (turnaround != DI_NODIR && SV_StepDirection(actor, turnaround, dist) )
                        return;
 

-       actor->fields.server->ideal_yaw = olddir;               // can't move
+       PRVM_serveredictfloat(actor, ideal_yaw) = olddir;               // can't move

 
 // if a bridge was pulled out from underneath a monster, it may not have
 // a valid standing position at all
 
 // if a bridge was pulled out from underneath a monster, it may not have
 // a valid standing position at all


@@ -417,23 +417,23 @@ void SV_MoveToGoal (void)
 
        VM_SAFEPARMCOUNT(1, SV_MoveToGoal);
 
 
        VM_SAFEPARMCOUNT(1, SV_MoveToGoal);
 

-       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
-       goal = PRVM_PROG_TO_EDICT(ent->fields.server->goalentity);
+       ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
+       goal = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, goalentity));

        dist = PRVM_G_FLOAT(OFS_PARM0);
 
        dist = PRVM_G_FLOAT(OFS_PARM0);
 

-       if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
+       if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )

        {
                PRVM_G_FLOAT(OFS_RETURN) = 0;
                return;
        }
 
 // if the next step hits the enemy, return immediately
        {
                PRVM_G_FLOAT(OFS_RETURN) = 0;
                return;
        }
 
 // if the next step hits the enemy, return immediately

-       if ( PRVM_PROG_TO_EDICT(ent->fields.server->enemy) != prog->edicts &&  SV_CloseEnough (ent, goal, dist) )
+       if ( PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, enemy)) != prog->edicts &&  SV_CloseEnough (ent, goal, dist) )

                return;
 
 // bump around...
        if ( (rand()&3)==1 ||
                return;
 
 // bump around...
        if ( (rand()&3)==1 ||

-       !SV_StepDirection (ent, ent->fields.server->ideal_yaw, dist))
+       !SV_StepDirection (ent, PRVM_serveredictfloat(ent, ideal_yaw), dist))

        {
                SV_NewChaseDir (ent, goal, dist);
        }
        {
                SV_NewChaseDir (ent, goal, dist);
        }

diff --git a/sv_phys.c b/sv_phys.c
index 61a5dc4e59d9a33ed5ed8defdd4f71f0fc99cd52..9c8b532b111ed547aee40bacc962a7e68de41328 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -54,7 +54,7 @@ int SV_GetPitchSign(prvm_edict_t *ent)
                        (
                         (((unsigned char)PRVM_serveredictfloat(ent, 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)PRVM_serveredictfloat(ent, effects) & (16 | 32)))

                        )
           )
                return -1;
                        )
           )
                return -1;


@@ -76,16 +76,16 @@ int SV_GenericHitSuperContentsMask(const prvm_edict_t *passedict)
                int dphitcontentsmask = (int)PRVM_serveredictfloat(passedict, dphitcontentsmask);
                if (dphitcontentsmask)
                        return dphitcontentsmask;
                int dphitcontentsmask = (int)PRVM_serveredictfloat(passedict, dphitcontentsmask);
                if (dphitcontentsmask)
                        return dphitcontentsmask;

-               else if (passedict->fields.server->solid == SOLID_SLIDEBOX)
+               else if (PRVM_serveredictfloat(passedict, solid) == SOLID_SLIDEBOX)

                {
                {

-                       if ((int)passedict->fields.server->flags & FL_MONSTER)
+                       if ((int)PRVM_serveredictfloat(passedict, flags) & FL_MONSTER)

                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
                        else
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
                }
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_MONSTERCLIP;
                        else
                                return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP;
                }

-               else if (passedict->fields.server->solid == SOLID_CORPSE)
+               else if (PRVM_serveredictfloat(passedict, solid) == SOLID_CORPSE)

                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;

-               else if (passedict->fields.server->solid == SOLID_TRIGGER)
+               else if (PRVM_serveredictfloat(passedict, solid) == SOLID_TRIGGER)

                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                else
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY;
                else
                        return SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_CORPSE;


@@ -169,7 +169,7 @@ trace_t SV_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int
        // precalculate prog value for passedict for comparisons
        passedictprog = PRVM_EDICT_TO_PROG(passedict);
        // precalculate passedict's owner edict pointer for comparisons
        // precalculate prog value for passedict for comparisons
        passedictprog = PRVM_EDICT_TO_PROG(passedict);
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;

 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap
 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap


@@ -185,9 +185,9 @@ trace_t SV_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.server->solid < SOLID_BBOX)
+               if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -199,36 +199,36 @@ trace_t SV_TracePoint(const vec3_t start, int type, prvm_edict_t *passedict, int
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.server->owner)
+                       if (passedictprog == PRVM_serveredictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
+                       if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)
                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);

-               if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask);
+               if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipstart, hitsupercontentsmask);

                else
                else

-                       Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask);
+                       Collision_ClipPointToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, hitsupercontentsmask);

 
 

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:


@@ -335,7 +335,7 @@ trace_t SV_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_
        // precalculate prog value for passedict for comparisons
        passedictprog = PRVM_EDICT_TO_PROG(passedict);
        // precalculate passedict's owner edict pointer for comparisons
        // precalculate prog value for passedict for comparisons
        passedictprog = PRVM_EDICT_TO_PROG(passedict);
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;

 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap
 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap


@@ -351,9 +351,9 @@ trace_t SV_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.server->solid < SOLID_BBOX)
+               if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -365,36 +365,36 @@ trace_t SV_TraceLine(const vec3_t start, const vec3_t end, int type, prvm_edict_
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.server->owner)
+                       if (passedictprog == PRVM_serveredictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
+                       if (VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)
                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);

-               if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
+               if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);

                else
                else

-                       Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask, false);
+                       Collision_ClipLineToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipend, hitsupercontentsmask, false);

 
 

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:


@@ -548,7 +548,7 @@ trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
        // figure out whether this is a point trace for comparisons
        pointtrace = VectorCompare(clipmins, clipmaxs);
        // precalculate passedict's owner edict pointer for comparisons
        // figure out whether this is a point trace for comparisons
        pointtrace = VectorCompare(clipmins, clipmaxs);
        // precalculate passedict's owner edict pointer for comparisons

-       traceowner = passedict ? PRVM_PROG_TO_EDICT(passedict->fields.server->owner) : 0;
+       traceowner = passedict ? PRVM_PROG_TO_EDICT(PRVM_serveredictedict(passedict, owner)) : 0;

 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap
 
        // clip to entities
        // because this uses World_EntitiestoBox, we know all entity boxes overlap


@@ -564,9 +564,9 @@ trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
        {
                touch = touchedicts[i];
 
        {
                touch = touchedicts[i];
 

-               if (touch->fields.server->solid < SOLID_BBOX)
+               if (PRVM_serveredictfloat(touch, solid) < SOLID_BBOX)

                        continue;
                        continue;

-               if (type == MOVE_NOMONSTERS && touch->fields.server->solid != SOLID_BSP)
+               if (type == MOVE_NOMONSTERS && PRVM_serveredictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                if (passedict)
                        continue;
 
                if (passedict)


@@ -578,36 +578,36 @@ trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities
                        if (traceowner == touch)
                                continue;
                        // don't clip owner against owned entities

-                       if (passedictprog == touch->fields.server->owner)
+                       if (passedictprog == PRVM_serveredictedict(touch, owner))

                                continue;
                        // don't clip points against points (they can't collide)
                                continue;
                        // don't clip points against points (they can't collide)

-                       if (pointtrace && VectorCompare(touch->fields.server->mins, touch->fields.server->maxs) && (type != MOVE_MISSILE || !((int)touch->fields.server->flags & FL_MONSTER)))
+                       if (pointtrace && VectorCompare(PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs)) && (type != MOVE_MISSILE || !((int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)))

                                continue;
                }
 
                                continue;
                }
 

-               bodysupercontents = touch->fields.server->solid == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;
+               bodysupercontents = PRVM_serveredictfloat(touch, solid) == SOLID_CORPSE ? SUPERCONTENTS_CORPSE : SUPERCONTENTS_BODY;

 
                // might interact, so do an exact clip
                model = NULL;
 
                // might interact, so do an exact clip
                model = NULL;

-               if ((int) touch->fields.server->solid == SOLID_BSP || type == MOVE_HITMODEL)
+               if ((int) PRVM_serveredictfloat(touch, solid) == SOLID_BSP || type == MOVE_HITMODEL)

                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)
                {
                        model = SV_GetModelFromEdict(touch);
                        pitchsign = SV_GetPitchSign(touch);
                }
                if (model)

-                       Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], pitchsign * touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+                       Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);

                else
                else

-                       Matrix4x4_CreateTranslate(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2]);
+                       Matrix4x4_CreateTranslate(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2]);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                VM_GenerateFrameGroupBlend(touch->priv.server->framegroupblend, touch);
                VM_FrameBlendFromFrameGroupBlend(touch->priv.server->frameblend, touch->priv.server->framegroupblend, model);
                VM_UpdateEdictSkeleton(touch, model, touch->priv.server->frameblend);

-               if (type == MOVE_MISSILE && (int)touch->fields.server->flags & FL_MONSTER)
-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);
+               if (type == MOVE_MISSILE && (int)PRVM_serveredictfloat(touch, flags) & FL_MONSTER)
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins2, clipmaxs2, clipend, hitsupercontentsmask);

                else
                else

-                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, touch->fields.server->mins, touch->fields.server->maxs, bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);
+                       Collision_ClipToGenericEntity(&trace, model, touch->priv.server->frameblend, &touch->priv.server->skeleton, PRVM_serveredictvector(touch, mins), PRVM_serveredictvector(touch, maxs), bodysupercontents, &matrix, &imatrix, clipstart, clipmins, clipmaxs, clipend, hitsupercontentsmask);

 
 

-               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, touch->fields.server->solid == SOLID_BSP);
+               Collision_CombineTraces(&cliptrace, &trace, (void *)touch, PRVM_serveredictfloat(touch, solid) == SOLID_BSP);

        }
 
 finished:
        }
 
 finished:


@@ -632,7 +632,7 @@ trace_t SV_TraceBox(const vec3_t start, const vec3_t mins, const vec3_t maxs, co
 #if COLLISIONPARANOID < 3
                if (trace.startsolid || endstuck)
 #endif
 #if COLLISIONPARANOID < 3
                if (trace.startsolid || endstuck)
 #endif

-                       Con_Printf("%s{e%i:%f %f %f:%f %f %f:%f:%f %f %f%s%s}\n", (trace.startsolid || endstuck) ? "^3" : "", passedict ? (int)(passedict - prog->edicts) : -1, passedict->fields.server->origin[0], passedict->fields.server->origin[1], passedict->fields.server->origin[2], end[0] - passedict->fields.server->origin[0], end[1] - passedict->fields.server->origin[1], end[2] - passedict->fields.server->origin[2], trace.fraction, trace.endpos[0] - passedict->fields.server->origin[0], trace.endpos[1] - passedict->fields.server->origin[1], trace.endpos[2] - passedict->fields.server->origin[2], trace.startsolid ? " startstuck" : "", endstuck ? " endstuck" : "");
+                       Con_Printf("%s{e%i:%f %f %f:%f %f %f:%f:%f %f %f%s%s}\n", (trace.startsolid || endstuck) ? "^3" : "", passedict ? (int)(passedict - prog->edicts) : -1, PRVM_serveredictvector(passedict, origin)[0], PRVM_serveredictvector(passedict, origin)[1], PRVM_serveredictvector(passedict, origin)[2], end[0] - PRVM_serveredictvector(passedict, origin)[0], end[1] - PRVM_serveredictvector(passedict, origin)[1], end[2] - PRVM_serveredictvector(passedict, origin)[2], trace.fraction, trace.endpos[0] - PRVM_serveredictvector(passedict, origin)[0], trace.endpos[1] - PRVM_serveredictvector(passedict, origin)[1], trace.endpos[2] - PRVM_serveredictvector(passedict, origin)[2], trace.startsolid ? " startstuck" : "", endstuck ? " endstuck" : "");

        }
        return trace;
 }
        }
        return trace;
 }


@@ -674,17 +674,17 @@ int SV_PointSuperContents(const vec3_t point)
                touch = touchedicts[i];
 
                // we only care about SOLID_BSP for pointcontents
                touch = touchedicts[i];
 
                // we only care about SOLID_BSP for pointcontents

-               if (touch->fields.server->solid != SOLID_BSP)
+               if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)

                        continue;
 
                // might interact, so do an exact clip
                model = SV_GetModelFromEdict(touch);
                if (!model || !model->PointSuperContents)
                        continue;
                        continue;
 
                // might interact, so do an exact clip
                model = SV_GetModelFromEdict(touch);
                if (!model || !model->PointSuperContents)
                        continue;

-               Matrix4x4_CreateFromQuakeEntity(&matrix, touch->fields.server->origin[0], touch->fields.server->origin[1], touch->fields.server->origin[2], touch->fields.server->angles[0], touch->fields.server->angles[1], touch->fields.server->angles[2], 1);
+               Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);

                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                Matrix4x4_Transform(&imatrix, point, transformed);
                Matrix4x4_Invert_Simple(&imatrix, &matrix);
                Matrix4x4_Transform(&imatrix, point, transformed);

-               frame = (int)touch->fields.server->frame;
+               frame = (int)PRVM_serveredictfloat(touch, frame);

                supercontents |= model->PointSuperContents(model, bound(0, frame, (model->numframes - 1)), transformed);
        }
 
                supercontents |= model->PointSuperContents(model, bound(0, frame, (model->numframes - 1)), transformed);
        }
 


@@ -701,23 +701,23 @@ Linking entities into the world culling system
 
 void SV_LinkEdict_TouchAreaGrid_Call(prvm_edict_t *touch, prvm_edict_t *ent)
 {
 
 void SV_LinkEdict_TouchAreaGrid_Call(prvm_edict_t *touch, prvm_edict_t *ent)
 {

-       prog->globals.server->self = PRVM_EDICT_TO_PROG(touch);
-       prog->globals.server->other = PRVM_EDICT_TO_PROG(ent);
-       prog->globals.server->time = sv.time;
-       prog->globals.server->trace_allsolid = false;
-       prog->globals.server->trace_startsolid = false;
-       prog->globals.server->trace_fraction = 1;
-       prog->globals.server->trace_inwater = false;
-       prog->globals.server->trace_inopen = true;
-       VectorCopy (touch->fields.server->origin, prog->globals.server->trace_endpos);
-       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_serverglobaledict(self) = PRVM_EDICT_TO_PROG(touch);
+       PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(ent);
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobalfloat(trace_allsolid) = false;
+       PRVM_serverglobalfloat(trace_startsolid) = false;
+       PRVM_serverglobalfloat(trace_fraction) = 1;
+       PRVM_serverglobalfloat(trace_inwater) = false;
+       PRVM_serverglobalfloat(trace_inopen) = true;
+       VectorCopy (PRVM_serveredictvector(touch, origin), PRVM_serverglobalvector(trace_endpos));
+       VectorSet (PRVM_serverglobalvector(trace_plane_normal), 0, 0, 1);
+       PRVM_serverglobalfloat(trace_plane_dist) = 0;
+       PRVM_serverglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(ent);

        PRVM_serverglobalfloat(trace_dpstartcontents) = 0;
        PRVM_serverglobalfloat(trace_dphitcontents) = 0;
        PRVM_serverglobalfloat(trace_dphitq3surfaceflags) = 0;
        PRVM_serverglobalstring(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 (PRVM_serveredictfunction(touch, touch), "QC function self.touch is missing");

 }
 
 void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent)
 }
 
 void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent)


@@ -732,7 +732,7 @@ void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent)
        if (ent->priv.server->free)
                return;
 
        if (ent->priv.server->free)
                return;
 

-       if (ent->fields.server->solid == SOLID_NOT)
+       if (PRVM_serveredictfloat(ent, solid) == SOLID_NOT)

                return;
 
        // build a list of edicts to touch, because the link loop can be corrupted
                return;
 
        // build a list of edicts to touch, because the link loop can be corrupted


@@ -745,18 +745,18 @@ void SV_LinkEdict_TouchAreaGrid(prvm_edict_t *ent)
                numtouchedicts = MAX_EDICTS;
        }
 
                numtouchedicts = MAX_EDICTS;
        }
 

-       old_self = prog->globals.server->self;
-       old_other = prog->globals.server->other;
+       old_self = PRVM_serverglobaledict(self);
+       old_other = PRVM_serverglobaledict(other);

        for (i = 0;i < numtouchedicts;i++)
        {
                touch = touchedicts[i];
        for (i = 0;i < numtouchedicts;i++)
        {
                touch = touchedicts[i];

-               if (touch != ent && (int)touch->fields.server->solid == SOLID_TRIGGER && touch->fields.server->touch)
+               if (touch != ent && (int)PRVM_serveredictfloat(touch, solid) == SOLID_TRIGGER && PRVM_serveredictfunction(touch, touch))

                {
                        SV_LinkEdict_TouchAreaGrid_Call(touch, ent);
                }
        }
                {
                        SV_LinkEdict_TouchAreaGrid_Call(touch, ent);
                }
        }

-       prog->globals.server->self = old_self;
-       prog->globals.server->other = old_other;
+       PRVM_serverglobaledict(self) = old_self;
+       PRVM_serverglobaledict(other) = old_other;

 }
 
 static void RotateBBox(const vec3_t mins, const vec3_t maxs, const vec3_t angles, vec3_t rotatedmins, vec3_t rotatedmaxs)
 }
 
 static void RotateBBox(const vec3_t mins, const vec3_t maxs, const vec3_t angles, vec3_t rotatedmins, vec3_t rotatedmaxs)


@@ -808,7 +808,7 @@ void SV_LinkEdict (prvm_edict_t *ent)
        if (ent->priv.server->free)
                return;
 
        if (ent->priv.server->free)
                return;
 

-       modelindex = (int)ent->fields.server->modelindex;
+       modelindex = (int)PRVM_serveredictfloat(ent, modelindex);

        if (modelindex < 0 || modelindex >= MAX_MODELS)
        {
                Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));
        if (modelindex < 0 || modelindex >= MAX_MODELS)
        {
                Con_Printf("edict %i: SOLID_BSP with invalid modelindex!\n", PRVM_NUM_FOR_EDICT(ent));


@@ -822,55 +822,55 @@ void SV_LinkEdict (prvm_edict_t *ent)
 
 // set the abs box
 
 
 // set the abs box
 

-       if (ent->fields.server->movetype == MOVETYPE_PHYSICS)
+       if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_PHYSICS)

        {
                // TODO maybe should do this for rotating SOLID_BSP too? Would behave better with rotating doors
                // TODO special handling for spheres?
        {
                // TODO maybe should do this for rotating SOLID_BSP too? Would behave better with rotating doors
                // TODO special handling for spheres?

-               RotateBBox(ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->angles, mins, maxs);
-               VectorAdd(ent->fields.server->origin, mins, mins);
-               VectorAdd(ent->fields.server->origin, maxs, maxs);
+               RotateBBox(PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), PRVM_serveredictvector(ent, angles), mins, maxs);
+               VectorAdd(PRVM_serveredictvector(ent, origin), mins, mins);
+               VectorAdd(PRVM_serveredictvector(ent, origin), maxs, maxs);

        }
        }

-       else if (ent->fields.server->solid == SOLID_BSP)
+       else if (PRVM_serveredictfloat(ent, solid) == SOLID_BSP)

        {
                if (model != NULL)
                {
                        if (!model->TraceBox)
                                Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 
        {
                if (model != NULL)
                {
                        if (!model->TraceBox)
                                Con_DPrintf("edict %i: SOLID_BSP with non-collidable model\n", PRVM_NUM_FOR_EDICT(ent));
 

-                       if (ent->fields.server->angles[0] || ent->fields.server->angles[2] || ent->fields.server->avelocity[0] || ent->fields.server->avelocity[2])
+                       if (PRVM_serveredictvector(ent, angles)[0] || PRVM_serveredictvector(ent, angles)[2] || PRVM_serveredictvector(ent, avelocity)[0] || PRVM_serveredictvector(ent, avelocity)[2])

                        {
                        {

-                               VectorAdd(ent->fields.server->origin, model->rotatedmins, mins);
-                               VectorAdd(ent->fields.server->origin, model->rotatedmaxs, maxs);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->rotatedmins, mins);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->rotatedmaxs, maxs);

                        }
                        }

-                       else if (ent->fields.server->angles[1] || ent->fields.server->avelocity[1])
+                       else if (PRVM_serveredictvector(ent, angles)[1] || PRVM_serveredictvector(ent, avelocity)[1])

                        {
                        {

-                               VectorAdd(ent->fields.server->origin, model->yawmins, mins);
-                               VectorAdd(ent->fields.server->origin, model->yawmaxs, maxs);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->yawmins, mins);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->yawmaxs, maxs);

                        }
                        else
                        {
                        }
                        else
                        {

-                               VectorAdd(ent->fields.server->origin, model->normalmins, mins);
-                               VectorAdd(ent->fields.server->origin, model->normalmaxs, maxs);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->normalmins, mins);
+                               VectorAdd(PRVM_serveredictvector(ent, origin), model->normalmaxs, maxs);

                        }
                }
                else
                {
                        // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily
                        }
                }
                else
                {
                        // SOLID_BSP with no model is valid, mainly because some QC setup code does so temporarily

-                       VectorAdd(ent->fields.server->origin, ent->fields.server->mins, mins);
-                       VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, maxs);
+                       VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
+                       VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);

                }
        }
        else
        {
                }
        }
        else
        {

-               VectorAdd(ent->fields.server->origin, ent->fields.server->mins, mins);
-               VectorAdd(ent->fields.server->origin, ent->fields.server->maxs, maxs);
+               VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), mins);
+               VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, maxs), maxs);

        }
 
 //
 // to make items easier to pick up and allow them to be grabbed off
 // of shelves, the abs sizes are expanded
 //
        }
 
 //
 // to make items easier to pick up and allow them to be grabbed off
 // of shelves, the abs sizes are expanded
 //

-       if ((int)ent->fields.server->flags & FL_ITEM)
+       if ((int)PRVM_serveredictfloat(ent, flags) & FL_ITEM)

        {
                mins[0] -= 15;
                mins[1] -= 15;
        {
                mins[0] -= 15;
                mins[1] -= 15;


@@ -891,8 +891,8 @@ void SV_LinkEdict (prvm_edict_t *ent)
                maxs[2] += 1;
        }
 
                maxs[2] += 1;
        }
 

-       VectorCopy(mins, ent->fields.server->absmin);
-       VectorCopy(maxs, ent->fields.server->absmax);
+       VectorCopy(mins, PRVM_serveredictvector(ent, absmin));
+       VectorCopy(maxs, PRVM_serveredictvector(ent, absmax));

 
        World_LinkEdict(&sv.world, ent, mins, maxs);
 }
 
        World_LinkEdict(&sv.world, ent, mins, maxs);
 }


@@ -918,13 +918,13 @@ static int SV_TestEntityPosition (prvm_edict_t *ent, vec3_t offset)
        vec3_t org;
        trace_t trace;
        contents = SV_GenericHitSuperContentsMask(ent);
        vec3_t org;
        trace_t trace;
        contents = SV_GenericHitSuperContentsMask(ent);

-       VectorAdd(ent->fields.server->origin, offset, org);
-       trace = SV_TraceBox(org, ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->origin, MOVE_NOMONSTERS, ent, contents);
+       VectorAdd(PRVM_serveredictvector(ent, origin), offset, org);
+       trace = SV_TraceBox(org, PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), PRVM_serveredictvector(ent, origin), MOVE_NOMONSTERS, ent, contents);

        if (trace.startsupercontents & contents)
                return true;
        else
        {
        if (trace.startsupercontents & contents)
                return true;
        else
        {

-               if (sv.worldmodel->brushq1.numclipnodes && !VectorCompare(ent->fields.server->mins, ent->fields.server->maxs))
+               if (sv.worldmodel->brushq1.numclipnodes && !VectorCompare(PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs)))

                {
                        // q1bsp/hlbsp use hulls and if the entity does not exactly match
                        // a hull size it is incorrectly tested, so this code tries to
                {
                        // q1bsp/hlbsp use hulls and if the entity does not exactly match
                        // a hull size it is incorrectly tested, so this code tries to


@@ -932,8 +932,8 @@ static int SV_TestEntityPosition (prvm_edict_t *ent, vec3_t offset)
                        // FIXME: this breaks entities larger than the hull size
                        int i;
                        vec3_t v, m1, m2, s;
                        // FIXME: this breaks entities larger than the hull size
                        int i;
                        vec3_t v, m1, m2, s;

-                       VectorAdd(org, ent->fields.server->mins, m1);
-                       VectorAdd(org, ent->fields.server->maxs, m2);
+                       VectorAdd(org, PRVM_serveredictvector(ent, mins), m1);
+                       VectorAdd(org, PRVM_serveredictvector(ent, maxs), m2);

                        VectorSubtract(m2, m1, s);
 #define EPSILON (1.0f / 32.0f)
                        if (s[0] >= EPSILON*2) {m1[0] += EPSILON;m2[0] -= EPSILON;}
                        VectorSubtract(m2, m1, s);
 #define EPSILON (1.0f / 32.0f)
                        if (s[0] >= EPSILON*2) {m1[0] += EPSILON;m2[0] -= EPSILON;}


@@ -950,19 +950,19 @@ static int SV_TestEntityPosition (prvm_edict_t *ent, vec3_t offset)
                }
        }
        // if the trace found a better position for the entity, move it there
                }
        }
        // if the trace found a better position for the entity, move it there

-       if (VectorDistance2(trace.endpos, ent->fields.server->origin) >= 0.0001)
+       if (VectorDistance2(trace.endpos, PRVM_serveredictvector(ent, origin)) >= 0.0001)

        {
 #if 0
                // please switch back to this code when trace.endpos sometimes being in solid bug is fixed
        {
 #if 0
                // please switch back to this code when trace.endpos sometimes being in solid bug is fixed

-               VectorCopy(trace.endpos, ent->fields.server->origin);
+               VectorCopy(trace.endpos, PRVM_serveredictvector(ent, origin));

 #else
                // verify if the endpos is REALLY outside solid
                VectorCopy(trace.endpos, org);
 #else
                // verify if the endpos is REALLY outside solid
                VectorCopy(trace.endpos, org);

-               trace = SV_TraceBox(org, ent->fields.server->mins, ent->fields.server->maxs, org, MOVE_NOMONSTERS, ent, contents);
+               trace = SV_TraceBox(org, PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), org, MOVE_NOMONSTERS, ent, contents);

                if(trace.startsolid)
                        Con_Printf("SV_TestEntityPosition: trace.endpos detected to be in solid. NOT using it.\n");
                else
                if(trace.startsolid)
                        Con_Printf("SV_TestEntityPosition: trace.endpos detected to be in solid. NOT using it.\n");
                else

-                       VectorCopy(org, ent->fields.server->origin);
+                       VectorCopy(org, PRVM_serveredictvector(ent, origin));

 #endif
        }
        return false;
 #endif
        }
        return false;


@@ -984,10 +984,10 @@ void SV_CheckAllEnts (void)
        {
                if (check->priv.server->free)
                        continue;
        {
                if (check->priv.server->free)
                        continue;

-               if (check->fields.server->movetype == MOVETYPE_PUSH
-                || check->fields.server->movetype == MOVETYPE_NONE
-                || check->fields.server->movetype == MOVETYPE_FOLLOW
-                || check->fields.server->movetype == MOVETYPE_NOCLIP)
+               if (PRVM_serveredictfloat(check, movetype) == MOVETYPE_PUSH
+                || PRVM_serveredictfloat(check, movetype) == MOVETYPE_NONE
+                || PRVM_serveredictfloat(check, movetype) == MOVETYPE_FOLLOW
+                || PRVM_serveredictfloat(check, movetype) == MOVETYPE_NOCLIP)

                        continue;
 
                if (SV_TestEntityPosition (check, vec3_origin))
                        continue;
 
                if (SV_TestEntityPosition (check, vec3_origin))


@@ -1010,7 +1010,7 @@ int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
        // Default Valid Function Call to False
        bValidFunctionCall = false;
 
        // Default Valid Function Call to False
        bValidFunctionCall = false;
 

-       if(ent->fields.server->watertype != nContents)
+       if(PRVM_serveredictfloat(ent, watertype) != nContents)

        { // Changed Contents
                // Acquire Contents Transition Function from QC
                if(PRVM_serveredictfunction(ent, contentstransition))
        { // Changed Contents
                // Acquire Contents Transition Function from QC
                if(PRVM_serveredictfunction(ent, contentstransition))


@@ -1019,11 +1019,11 @@ int SV_CheckContentsTransition(prvm_edict_t *ent, const int nContents)
                        bValidFunctionCall = true;
                        // Prepare Parameters (Original Contents, New Contents)
                                // Original Contents
                        bValidFunctionCall = true;
                        // Prepare Parameters (Original Contents, New Contents)
                                // Original Contents

-                               PRVM_G_FLOAT(OFS_PARM0) = ent->fields.server->watertype;
+                               PRVM_G_FLOAT(OFS_PARM0) = PRVM_serveredictfloat(ent, watertype);

                                // New Contents
                                PRVM_G_FLOAT(OFS_PARM1) = nContents;
                                // Assign Self
                                // New Contents
                                PRVM_G_FLOAT(OFS_PARM1) = nContents;
                                // Assign Self

-                               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+                               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                        // Execute VM Function
                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, contentstransition), "contentstransition: NULL function");
                }
                        // Execute VM Function
                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, contentstransition), "contentstransition: NULL function");
                }


@@ -1049,32 +1049,32 @@ void SV_CheckVelocity (prvm_edict_t *ent)
 //
        for (i=0 ; i<3 ; i++)
        {
 //
        for (i=0 ; i<3 ; i++)
        {

-               if (IS_NAN(ent->fields.server->velocity[i]))
+               if (IS_NAN(PRVM_serveredictvector(ent, velocity)[i]))

                {
                {

-                       Con_Printf("Got a NaN velocity on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(ent->fields.server->classname));
-                       ent->fields.server->velocity[i] = 0;
+                       Con_Printf("Got a NaN velocity on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)));
+                       PRVM_serveredictvector(ent, velocity)[i] = 0;

                }
                }

-               if (IS_NAN(ent->fields.server->origin[i]))
+               if (IS_NAN(PRVM_serveredictvector(ent, origin)[i]))

                {
                {

-                       Con_Printf("Got a NaN origin on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(ent->fields.server->classname));
-                       ent->fields.server->origin[i] = 0;
+                       Con_Printf("Got a NaN origin on entity #%i (%s)\n", PRVM_NUM_FOR_EDICT(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)));
+                       PRVM_serveredictvector(ent, origin)[i] = 0;

                }
        }
 
        // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
        // player_run/player_stand1 does not horribly malfunction if the
        // velocity becomes a denormalized float
                }
        }
 
        // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
        // player_run/player_stand1 does not horribly malfunction if the
        // velocity becomes a denormalized float

-       if (VectorLength2(ent->fields.server->velocity) < 0.0001)
-               VectorClear(ent->fields.server->velocity);
+       if (VectorLength2(PRVM_serveredictvector(ent, velocity)) < 0.0001)
+               VectorClear(PRVM_serveredictvector(ent, velocity));

 
        // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster
 
        // LordHavoc: max velocity fix, inspired by Maddes's source fixes, but this is faster

-       wishspeed = DotProduct(ent->fields.server->velocity, ent->fields.server->velocity);
+       wishspeed = DotProduct(PRVM_serveredictvector(ent, velocity), PRVM_serveredictvector(ent, velocity));

        if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
        {
                wishspeed = sv_maxvelocity.value / sqrt(wishspeed);
        if (wishspeed > sv_maxvelocity.value * sv_maxvelocity.value)
        {
                wishspeed = sv_maxvelocity.value / sqrt(wishspeed);

-               ent->fields.server->velocity[0] *= wishspeed;
-               ent->fields.server->velocity[1] *= wishspeed;
-               ent->fields.server->velocity[2] *= wishspeed;
+               PRVM_serveredictvector(ent, velocity)[0] *= wishspeed;
+               PRVM_serveredictvector(ent, velocity)[1] *= wishspeed;
+               PRVM_serveredictvector(ent, velocity)[2] *= wishspeed;

        }
 }
 
        }
 }
 


@@ -1094,21 +1094,21 @@ qboolean SV_RunThink (prvm_edict_t *ent)
 
        // don't let things stay in the past.
        // it is possible to start that way by a trigger with a local time.
 
        // don't let things stay in the past.
        // it is possible to start that way by a trigger with a local time.

-       if (ent->fields.server->nextthink <= 0 || ent->fields.server->nextthink > sv.time + sv.frametime)
+       if (PRVM_serveredictfloat(ent, nextthink) <= 0 || PRVM_serveredictfloat(ent, nextthink) > sv.time + sv.frametime)

                return true;
 
        for (iterations = 0;iterations < 128  && !ent->priv.server->free;iterations++)
        {
                return true;
 
        for (iterations = 0;iterations < 128  && !ent->priv.server->free;iterations++)
        {

-               prog->globals.server->time = max(sv.time, ent->fields.server->nextthink);
-               ent->fields.server->nextthink = 0;
-               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-               prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
-               PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
+               PRVM_serverglobalfloat(time) = max(sv.time, PRVM_serveredictfloat(ent, nextthink));
+               PRVM_serveredictfloat(ent, nextthink) = 0;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
+               PRVM_ExecuteProgram (PRVM_serveredictfunction(ent, think), "QC function self.think is missing");

                // mods often set nextthink to time to cause a think every frame,
                // we don't want to loop in that case, so exit if the new nextthink is
                // <= the time the qc was told, also exit if it is past the end of the
                // frame
                // mods often set nextthink to time to cause a think every frame,
                // we don't want to loop in that case, so exit if the new nextthink is
                // <= the time the qc was told, also exit if it is past the end of the
                // frame

-               if (ent->fields.server->nextthink <= prog->globals.server->time || ent->fields.server->nextthink > sv.time + sv.frametime || !sv_gameplayfix_multiplethinksperframe.integer)
+               if (PRVM_serveredictfloat(ent, nextthink) <= PRVM_serverglobalfloat(time) || PRVM_serveredictfloat(ent, nextthink) > sv.time + sv.frametime || !sv_gameplayfix_multiplethinksperframe.integer)

                        break;
        }
        return !ent->priv.server->free;
                        break;
        }
        return !ent->priv.server->free;


@@ -1129,37 +1129,37 @@ void SV_Impact (prvm_edict_t *e1, trace_t *trace)
        int old_self, old_other;
        prvm_edict_t *e2 = (prvm_edict_t *)trace->ent;
 
        int old_self, old_other;
        prvm_edict_t *e2 = (prvm_edict_t *)trace->ent;
 

-       old_self = prog->globals.server->self;
-       old_other = prog->globals.server->other;
+       old_self = PRVM_serverglobaledict(self);
+       old_other = PRVM_serverglobaledict(other);

        restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
 
        VM_SetTraceGlobals(trace);
 
        restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
 
        VM_SetTraceGlobals(trace);
 

-       prog->globals.server->time = sv.time;
-       if (!e1->priv.server->free && !e2->priv.server->free && e1->fields.server->touch && e1->fields.server->solid != SOLID_NOT)
+       PRVM_serverglobalfloat(time) = sv.time;
+       if (!e1->priv.server->free && !e2->priv.server->free && PRVM_serveredictfunction(e1, touch) && PRVM_serveredictfloat(e1, solid) != SOLID_NOT)

        {
        {

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(e1);
-               prog->globals.server->other = PRVM_EDICT_TO_PROG(e2);
-               PRVM_ExecuteProgram (e1->fields.server->touch, "QC function self.touch is missing");
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(e1);
+               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(e2);
+               PRVM_ExecuteProgram (PRVM_serveredictfunction(e1, touch), "QC function self.touch is missing");

        }
 
        }
 

-       if (!e1->priv.server->free && !e2->priv.server->free && e2->fields.server->touch && e2->fields.server->solid != SOLID_NOT)
+       if (!e1->priv.server->free && !e2->priv.server->free && PRVM_serveredictfunction(e2, touch) && PRVM_serveredictfloat(e2, solid) != SOLID_NOT)

        {
        {

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(e2);
-               prog->globals.server->other = PRVM_EDICT_TO_PROG(e1);
-               VectorCopy(e2->fields.server->origin, prog->globals.server->trace_endpos);
-               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_serverglobaledict(self) = PRVM_EDICT_TO_PROG(e2);
+               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(e1);
+               VectorCopy(PRVM_serveredictvector(e2, origin), PRVM_serverglobalvector(trace_endpos));
+               VectorNegate(trace->plane.normal, PRVM_serverglobalvector(trace_plane_normal));
+               PRVM_serverglobalfloat(trace_plane_dist) = -trace->plane.dist;
+               PRVM_serverglobaledict(trace_ent) = PRVM_EDICT_TO_PROG(e1);

                PRVM_serverglobalfloat(trace_dpstartcontents) = 0;
                PRVM_serverglobalfloat(trace_dphitcontents) = 0;
                PRVM_serverglobalfloat(trace_dphitq3surfaceflags) = 0;
                PRVM_serverglobalstring(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 (PRVM_serveredictfunction(e2, touch), "QC function self.touch is missing");

        }
 
        }
 

-       prog->globals.server->self = old_self;
-       prog->globals.server->other = old_other;
+       PRVM_serverglobaledict(self) = old_self;
+       PRVM_serverglobaledict(other) = old_other;

        vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
 }
 
        vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
 }
 


@@ -1218,7 +1218,7 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
        gravity = 0;
 
        if(sv_gameplayfix_nogravityonground.integer)
        gravity = 0;
 
        if(sv_gameplayfix_nogravityonground.integer)

-               if((int)ent->fields.server->flags & FL_ONGROUND)
+               if((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)

                        applygravity = false;
 
        if (applygravity)
                        applygravity = false;
 
        if (applygravity)


@@ -1226,25 +1226,25 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                if (sv_gameplayfix_gravityunaffectedbyticrate.integer)
                {
                        gravity = SV_Gravity(ent) * 0.5f;
                if (sv_gameplayfix_gravityunaffectedbyticrate.integer)
                {
                        gravity = SV_Gravity(ent) * 0.5f;

-                       ent->fields.server->velocity[2] -= gravity;
+                       PRVM_serveredictvector(ent, velocity)[2] -= gravity;

                }
                else
                {
                        applygravity = false;
                }
                else
                {
                        applygravity = false;

-                       ent->fields.server->velocity[2] -= SV_Gravity(ent);
+                       PRVM_serveredictvector(ent, velocity)[2] -= SV_Gravity(ent);

                }
        }
        blocked = 0;
                }
        }
        blocked = 0;

-       VectorCopy(ent->fields.server->velocity, original_velocity);
-       VectorCopy(ent->fields.server->velocity, primal_velocity);
+       VectorCopy(PRVM_serveredictvector(ent, velocity), original_velocity);
+       VectorCopy(PRVM_serveredictvector(ent, velocity), primal_velocity);

        numplanes = 0;
        time_left = time;
        for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
        {
        numplanes = 0;
        time_left = time;
        for (bumpcount = 0;bumpcount < MAX_CLIP_PLANES;bumpcount++)
        {

-               if (!ent->fields.server->velocity[0] && !ent->fields.server->velocity[1] && !ent->fields.server->velocity[2])
+               if (!PRVM_serveredictvector(ent, velocity)[0] && !PRVM_serveredictvector(ent, velocity)[1] && !PRVM_serveredictvector(ent, velocity)[2])

                        break;
 
                        break;
 

-               VectorScale(ent->fields.server->velocity, time_left, push);
+               VectorScale(PRVM_serveredictvector(ent, velocity), time_left, push);

                if(!SV_PushEntity(&trace, ent, push, false, false))
                {
                        // we got teleported by a touch function
                if(!SV_PushEntity(&trace, ent, push, false, false))
                {
                        // we got teleported by a touch function


@@ -1268,8 +1268,8 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                                        trace.ent = prog->edicts;
                                }
 
                                        trace.ent = prog->edicts;
                                }
 

-                               ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                               ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                               PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                               PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);

                        }
                }
                else if (stepheight)
                        }
                }
                else if (stepheight)


@@ -1280,42 +1280,42 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                        trace_t steptrace;
                        trace_t steptrace2;
                        trace_t steptrace3;
                        trace_t steptrace;
                        trace_t steptrace2;
                        trace_t steptrace3;

-                       //Con_Printf("step %f %f %f : ", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
+                       //Con_Printf("step %f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);

                        VectorSet(steppush, 0, 0, stepheight);
                        VectorSet(steppush, 0, 0, stepheight);

-                       VectorCopy(ent->fields.server->origin, org);
+                       VectorCopy(PRVM_serveredictvector(ent, origin), org);

                        if(!SV_PushEntity(&steptrace, ent, steppush, false, false))
                        {
                                blocked |= 8;
                                break;
                        }
                        if(!SV_PushEntity(&steptrace, ent, steppush, false, false))
                        {
                                blocked |= 8;
                                break;
                        }

-                       //Con_Printf("%f %f %f : ", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
+                       //Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);

                        if(!SV_PushEntity(&steptrace2, ent, push, false, false))
                        {
                                blocked |= 8;
                                break;
                        }
                        if(!SV_PushEntity(&steptrace2, ent, push, false, false))
                        {
                                blocked |= 8;
                                break;
                        }

-                       //Con_Printf("%f %f %f : ", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
-                       VectorSet(steppush, 0, 0, org[2] - ent->fields.server->origin[2]);
+                       //Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
+                       VectorSet(steppush, 0, 0, org[2] - PRVM_serveredictvector(ent, origin)[2]);

                        if(!SV_PushEntity(&steptrace3, ent, steppush, false, false))
                        {
                                blocked |= 8;
                                break;
                        }
                        if(!SV_PushEntity(&steptrace3, ent, steppush, false, false))
                        {
                                blocked |= 8;
                                break;
                        }

-                       //Con_Printf("%f %f %f : ", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
+                       //Con_Printf("%f %f %f : ", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);

                        // accept the new position if it made some progress...
                        // accept the new position if it made some progress...

-                       if (fabs(ent->fields.server->origin[0] - org[0]) >= 0.03125 || fabs(ent->fields.server->origin[1] - org[1]) >= 0.03125)
+                       if (fabs(PRVM_serveredictvector(ent, origin)[0] - org[0]) >= 0.03125 || fabs(PRVM_serveredictvector(ent, origin)[1] - org[1]) >= 0.03125)

                        {
                        {

-                               //Con_Printf("accepted (delta %f %f %f)\n", ent->fields.server->origin[0] - org[0], ent->fields.server->origin[1] - org[1], ent->fields.server->origin[2] - org[2]);
+                               //Con_Printf("accepted (delta %f %f %f)\n", PRVM_serveredictvector(ent, origin)[0] - org[0], PRVM_serveredictvector(ent, origin)[1] - org[1], PRVM_serveredictvector(ent, origin)[2] - org[2]);

                                trace = steptrace2;
                                trace = steptrace2;

-                               VectorCopy(ent->fields.server->origin, trace.endpos);
+                               VectorCopy(PRVM_serveredictvector(ent, origin), trace.endpos);

                                time_left *= 1 - trace.fraction;
                                numplanes = 0;
                                continue;
                        }
                        else
                        {
                                time_left *= 1 - trace.fraction;
                                numplanes = 0;
                                continue;
                        }
                        else
                        {

-                               //Con_Printf("REJECTED (delta %f %f %f)\n", ent->fields.server->origin[0] - org[0], ent->fields.server->origin[1] - org[1], ent->fields.server->origin[2] - org[2]);
-                               VectorCopy(org, ent->fields.server->origin);
+                               //Con_Printf("REJECTED (delta %f %f %f)\n", PRVM_serveredictvector(ent, origin)[0] - org[0], PRVM_serveredictvector(ent, origin)[1] - org[1], PRVM_serveredictvector(ent, origin)[2] - org[2]);
+                               VectorCopy(org, PRVM_serveredictvector(ent, origin));

                        }
                }
                else
                        }
                }
                else


@@ -1329,7 +1329,7 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                if (trace.fraction >= 0.001)
                {
                        // actually covered some distance
                if (trace.fraction >= 0.001)
                {
                        // actually covered some distance

-                       VectorCopy(ent->fields.server->velocity, original_velocity);
+                       VectorCopy(PRVM_serveredictvector(ent, velocity), original_velocity);

                        numplanes = 0;
                }
 
                        numplanes = 0;
                }
 


@@ -1339,7 +1339,7 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                if (numplanes >= MAX_CLIP_PLANES)
                {
                        // this shouldn't really happen
                if (numplanes >= MAX_CLIP_PLANES)
                {
                        // this shouldn't really happen

-                       VectorClear(ent->fields.server->velocity);
+                       VectorClear(PRVM_serveredictvector(ent, velocity));

                        blocked = 3;
                        break;
                }
                        blocked = 3;
                        break;
                }


@@ -1350,7 +1350,7 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                                break;
                if (i < numplanes)
                {
                                break;
                if (i < numplanes)
                {

-                       VectorAdd(ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity);
+                       VectorAdd(PRVM_serveredictvector(ent, velocity), trace.plane.normal, PRVM_serveredictvector(ent, velocity));

                        continue;
                }
                */
                        continue;
                }
                */


@@ -1378,49 +1378,49 @@ static int SV_FlyMove (prvm_edict_t *ent, float time, qboolean applygravity, flo
                if (i != numplanes)
                {
                        // go along this plane
                if (i != numplanes)
                {
                        // go along this plane

-                       VectorCopy(new_velocity, ent->fields.server->velocity);
+                       VectorCopy(new_velocity, PRVM_serveredictvector(ent, velocity));

                }
                else
                {
                        // go along the crease
                        if (numplanes != 2)
                        {
                }
                else
                {
                        // go along the crease
                        if (numplanes != 2)
                        {

-                               VectorClear(ent->fields.server->velocity);
+                               VectorClear(PRVM_serveredictvector(ent, velocity));

                                blocked = 7;
                                break;
                        }
                        CrossProduct(planes[0], planes[1], dir);
                        // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
                        VectorNormalize(dir);
                                blocked = 7;
                                break;
                        }
                        CrossProduct(planes[0], planes[1], dir);
                        // LordHavoc: thanks to taniwha of QuakeForge for pointing out this fix for slowed falling in corners
                        VectorNormalize(dir);

-                       d = DotProduct(dir, ent->fields.server->velocity);
-                       VectorScale(dir, d, ent->fields.server->velocity);
+                       d = DotProduct(dir, PRVM_serveredictvector(ent, velocity));
+                       VectorScale(dir, d, PRVM_serveredictvector(ent, velocity));

                }
 
                // if current velocity is against the original velocity,
                // stop dead to avoid tiny occilations in sloping corners
                }
 
                // if current velocity is against the original velocity,
                // stop dead to avoid tiny occilations in sloping corners

-               if (DotProduct(ent->fields.server->velocity, primal_velocity) <= 0)
+               if (DotProduct(PRVM_serveredictvector(ent, velocity), primal_velocity) <= 0)

                {
                {

-                       VectorClear(ent->fields.server->velocity);
+                       VectorClear(PRVM_serveredictvector(ent, velocity));

                        break;
                }
        }
 
                        break;
                }
        }
 

-       //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - prog->edicts, blocked, ent->fields.server->velocity[0], ent->fields.server->velocity[1], ent->fields.server->velocity[2]);
+       //Con_Printf("entity %i final: blocked %i velocity %f %f %f\n", ent - prog->edicts, blocked, PRVM_serveredictvector(ent, velocity)[0], PRVM_serveredictvector(ent, velocity)[1], PRVM_serveredictvector(ent, velocity)[2]);

 
        /*
        if ((blocked & 1) == 0 && bumpcount > 1)
        {
                // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
                // flag ONGROUND if there's ground under it
 
        /*
        if ((blocked & 1) == 0 && bumpcount > 1)
        {
                // LordHavoc: fix the 'fall to your death in a wedge corner' glitch
                // flag ONGROUND if there's ground under it

-               trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, hitsupercontentsmask);
+               trace = SV_TraceBox(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), end, MOVE_NORMAL, ent, hitsupercontentsmask);

        }
        */
 
        // LordHavoc: this came from QW and allows you to get out of water more easily
        }
        */
 
        // LordHavoc: this came from QW and allows you to get out of water more easily

-       if (sv_gameplayfix_easierwaterjump.integer && ((int)ent->fields.server->flags & FL_WATERJUMP) && !(blocked & 8))
-               VectorCopy(primal_velocity, ent->fields.server->velocity);
-       if (applygravity && !((int)ent->fields.server->flags & FL_ONGROUND))
-               ent->fields.server->velocity[2] -= gravity;
+       if (sv_gameplayfix_easierwaterjump.integer && ((int)PRVM_serveredictfloat(ent, flags) & FL_WATERJUMP) && !(blocked & 8))
+               VectorCopy(primal_velocity, PRVM_serveredictvector(ent, velocity));
+       if (applygravity && !((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND))
+               PRVM_serveredictvector(ent, velocity)[2] -= gravity;

        return blocked;
 }
 
        return blocked;
 }
 


@@ -1469,10 +1469,10 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
        vec3_t start;
        vec3_t end;
 
        vec3_t start;
        vec3_t end;
 

-       solid = (int)ent->fields.server->solid;
-       movetype = (int)ent->fields.server->movetype;
-       VectorCopy(ent->fields.server->mins, mins);
-       VectorCopy(ent->fields.server->maxs, maxs);
+       solid = (int)PRVM_serveredictfloat(ent, solid);
+       movetype = (int)PRVM_serveredictfloat(ent, movetype);
+       VectorCopy(PRVM_serveredictvector(ent, mins), mins);
+       VectorCopy(PRVM_serveredictvector(ent, maxs), maxs);

 
        // move start position out of solids
        if (sv_gameplayfix_nudgeoutofsolid.integer && sv_gameplayfix_nudgeoutofsolid_separation.value >= 0)
 
        // move start position out of solids
        if (sv_gameplayfix_nudgeoutofsolid.integer && sv_gameplayfix_nudgeoutofsolid_separation.value >= 0)


@@ -1484,7 +1484,7 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
                vec_t separation = sv_gameplayfix_nudgeoutofsolid_separation.value;
                if (sv.worldmodel && sv.worldmodel->brushq1.numclipnodes)
                        separation = 0.0f; // when using hulls, it can not be enlarged
                vec_t separation = sv_gameplayfix_nudgeoutofsolid_separation.value;
                if (sv.worldmodel && sv.worldmodel->brushq1.numclipnodes)
                        separation = 0.0f; // when using hulls, it can not be enlarged

-               VectorCopy(ent->fields.server->origin, stuckorigin);
+               VectorCopy(PRVM_serveredictvector(ent, origin), stuckorigin);

                VectorCopy(mins, stuckmins);
                VectorCopy(maxs, stuckmaxs);
                stuckmins[0] -= separation;
                VectorCopy(mins, stuckmins);
                VectorCopy(maxs, stuckmaxs);
                stuckmins[0] -= separation;


@@ -1499,7 +1499,7 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
                        if (!stucktrace.bmodelstartsolid || stucktrace.startdepth >= 0)
                        {
                                // found a good location, use it
                        if (!stucktrace.bmodelstartsolid || stucktrace.startdepth >= 0)
                        {
                                // found a good location, use it

-                               VectorCopy(stuckorigin, ent->fields.server->origin);
+                               VectorCopy(stuckorigin, PRVM_serveredictvector(ent, origin));

                                break;
                        }
                        nudge = -stucktrace.startdepth;
                                break;
                        }
                        nudge = -stucktrace.startdepth;


@@ -1507,7 +1507,7 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
                }
        }
 
                }
        }
 

-       VectorCopy(ent->fields.server->origin, start);
+       VectorCopy(PRVM_serveredictvector(ent, origin), start);

        VectorAdd(start, push, end);
 
        if (movetype == MOVETYPE_FLYMISSILE)
        VectorAdd(start, push, end);
 
        if (movetype == MOVETYPE_FLYMISSILE)


@@ -1521,16 +1521,16 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
        if (trace->bmodelstartsolid && failonbmodelstartsolid)
                return true;
 
        if (trace->bmodelstartsolid && failonbmodelstartsolid)
                return true;
 

-       VectorCopy(trace->endpos, ent->fields.server->origin);
+       VectorCopy(trace->endpos, PRVM_serveredictvector(ent, origin));

 
 

-       VectorCopy(ent->fields.server->origin, original);
-       VectorCopy(ent->fields.server->velocity, original_velocity);
+       VectorCopy(PRVM_serveredictvector(ent, origin), original);
+       VectorCopy(PRVM_serveredictvector(ent, velocity), original_velocity);

 
        SV_LinkEdict(ent);
 
 #if 0
        if(!trace->startsolid)
 
        SV_LinkEdict(ent);
 
 #if 0
        if(!trace->startsolid)

-       if(SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, ent->fields.server->origin, type, ent, SV_GenericHitSuperContentsMask(ent)).startsolid)
+       if(SV_TraceBox(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), PRVM_serveredictvector(ent, origin), type, ent, SV_GenericHitSuperContentsMask(ent)).startsolid)

        {
                Con_Printf("something eeeeevil happened\n");
        }
        {
                Con_Printf("something eeeeevil happened\n");
        }


@@ -1539,10 +1539,10 @@ static qboolean SV_PushEntity (trace_t *trace, prvm_edict_t *ent, vec3_t push, q
        if (dolink)
                SV_LinkEdict_TouchAreaGrid(ent);
 
        if (dolink)
                SV_LinkEdict_TouchAreaGrid(ent);
 

-       if((ent->fields.server->solid >= SOLID_TRIGGER && trace->ent && (!((int)ent->fields.server->flags & FL_ONGROUND) || ent->fields.server->groundentity != PRVM_EDICT_TO_PROG(trace->ent))))
+       if((PRVM_serveredictfloat(ent, solid) >= SOLID_TRIGGER && trace->ent && (!((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND) || PRVM_serveredictedict(ent, groundentity) != PRVM_EDICT_TO_PROG(trace->ent))))

                SV_Impact (ent, trace);
 
                SV_Impact (ent, trace);
 

-       return VectorCompare(ent->fields.server->origin, original) && VectorCompare(ent->fields.server->velocity, original_velocity);
+       return VectorCompare(PRVM_serveredictvector(ent, origin), original) && VectorCompare(PRVM_serveredictvector(ent, velocity), original_velocity);

 }
 
 
 }
 
 


@@ -1568,13 +1568,13 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        matrix4x4_t pusherfinalmatrix, pusherfinalimatrix;
        static unsigned short moved_edicts[MAX_EDICTS];
 
        matrix4x4_t pusherfinalmatrix, pusherfinalimatrix;
        static unsigned short moved_edicts[MAX_EDICTS];
 

-       if (!pusher->fields.server->velocity[0] && !pusher->fields.server->velocity[1] && !pusher->fields.server->velocity[2] && !pusher->fields.server->avelocity[0] && !pusher->fields.server->avelocity[1] && !pusher->fields.server->avelocity[2])
+       if (!PRVM_serveredictvector(pusher, velocity)[0] && !PRVM_serveredictvector(pusher, velocity)[1] && !PRVM_serveredictvector(pusher, velocity)[2] && !PRVM_serveredictvector(pusher, avelocity)[0] && !PRVM_serveredictvector(pusher, avelocity)[1] && !PRVM_serveredictvector(pusher, avelocity)[2])

        {
        {

-               pusher->fields.server->ltime += movetime;
+               PRVM_serveredictfloat(pusher, ltime) += movetime;

                return;
        }
 
                return;
        }
 

-       switch ((int) pusher->fields.server->solid)
+       switch ((int) PRVM_serveredictfloat(pusher, solid))

        {
        // LordHavoc: valid pusher types
        case SOLID_BSP:
        {
        // LordHavoc: valid pusher types
        case SOLID_BSP:


@@ -1585,46 +1585,46 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        // LordHavoc: no collisions
        case SOLID_NOT:
        case SOLID_TRIGGER:
        // LordHavoc: no collisions
        case SOLID_NOT:
        case SOLID_TRIGGER:

-               VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
-               VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
-               pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
-               pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
-               pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
-               pusher->fields.server->ltime += movetime;
+               VectorMA (PRVM_serveredictvector(pusher, origin), movetime, PRVM_serveredictvector(pusher, velocity), PRVM_serveredictvector(pusher, origin));
+               VectorMA (PRVM_serveredictvector(pusher, angles), movetime, PRVM_serveredictvector(pusher, avelocity), PRVM_serveredictvector(pusher, angles));
+               PRVM_serveredictvector(pusher, angles)[0] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[0] * (1.0 / 360.0));
+               PRVM_serveredictvector(pusher, angles)[1] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[1] * (1.0 / 360.0));
+               PRVM_serveredictvector(pusher, angles)[2] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[2] * (1.0 / 360.0));
+               PRVM_serveredictfloat(pusher, ltime) += movetime;

                SV_LinkEdict(pusher);
                return;
        default:
                SV_LinkEdict(pusher);
                return;
        default:

-               Con_Printf("SV_PushMove: entity #%i, unrecognized solid type %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->solid);
+               Con_Printf("SV_PushMove: entity #%i, unrecognized solid type %f\n", PRVM_NUM_FOR_EDICT(pusher), PRVM_serveredictfloat(pusher, solid));

                return;
        }
                return;
        }

-       index = (int) pusher->fields.server->modelindex;
+       index = (int) PRVM_serveredictfloat(pusher, modelindex);

        if (index < 1 || index >= MAX_MODELS)
        {
        if (index < 1 || index >= MAX_MODELS)
        {

-               Con_Printf("SV_PushMove: entity #%i has an invalid modelindex %f\n", PRVM_NUM_FOR_EDICT(pusher), pusher->fields.server->modelindex);
+               Con_Printf("SV_PushMove: entity #%i has an invalid modelindex %f\n", PRVM_NUM_FOR_EDICT(pusher), PRVM_serveredictfloat(pusher, modelindex));

                return;
        }
        pushermodel = SV_GetModelByIndex(index);
                return;
        }
        pushermodel = SV_GetModelByIndex(index);

-       pusherowner = pusher->fields.server->owner;
+       pusherowner = PRVM_serveredictedict(pusher, owner);

        pusherprog = PRVM_EDICT_TO_PROG(pusher);
 
        pusherprog = PRVM_EDICT_TO_PROG(pusher);
 

-       rotated = VectorLength2(pusher->fields.server->angles) + VectorLength2(pusher->fields.server->avelocity) > 0;
+       rotated = VectorLength2(PRVM_serveredictvector(pusher, angles)) + VectorLength2(PRVM_serveredictvector(pusher, avelocity)) > 0;

 
        movetime2 = movetime;
 
        movetime2 = movetime;

-       VectorScale(pusher->fields.server->velocity, movetime2, move1);
-       VectorScale(pusher->fields.server->avelocity, movetime2, moveangle);
+       VectorScale(PRVM_serveredictvector(pusher, velocity), movetime2, move1);
+       VectorScale(PRVM_serveredictvector(pusher, avelocity), movetime2, moveangle);

        if (moveangle[0] || moveangle[2])
        {
                for (i = 0;i < 3;i++)
                {
                        if (move1[i] > 0)
                        {
        if (moveangle[0] || moveangle[2])
        {
                for (i = 0;i < 3;i++)
                {
                        if (move1[i] > 0)
                        {

-                               mins[i] = pushermodel->rotatedmins[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->rotatedmins[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->rotatedmaxs[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                        else
                        {
                        }
                        else
                        {

-                               mins[i] = pushermodel->rotatedmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->rotatedmaxs[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->rotatedmins[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->rotatedmaxs[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                }
        }
                        }
                }
        }


@@ -1634,13 +1634,13 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                {
                        if (move1[i] > 0)
                        {
                {
                        if (move1[i] > 0)
                        {

-                               mins[i] = pushermodel->yawmins[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->yawmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->yawmins[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->yawmaxs[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                        else
                        {
                        }
                        else
                        {

-                               mins[i] = pushermodel->yawmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->yawmaxs[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->yawmins[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->yawmaxs[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                }
        }
                        }
                }
        }


@@ -1650,13 +1650,13 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                {
                        if (move1[i] > 0)
                        {
                {
                        if (move1[i] > 0)
                        {

-                               mins[i] = pushermodel->normalmins[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->normalmaxs[i] + move1[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->normalmins[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->normalmaxs[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                        else
                        {
                        }
                        else
                        {

-                               mins[i] = pushermodel->normalmins[i] + move1[i] + pusher->fields.server->origin[i] - 1;
-                               maxs[i] = pushermodel->normalmaxs[i] + pusher->fields.server->origin[i] + 1;
+                               mins[i] = pushermodel->normalmins[i] + move1[i] + PRVM_serveredictvector(pusher, origin)[i] - 1;
+                               maxs[i] = pushermodel->normalmaxs[i] + PRVM_serveredictvector(pusher, origin)[i] + 1;

                        }
                }
        }
                        }
                }
        }


@@ -1664,22 +1664,22 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        VectorNegate (moveangle, a);
        AngleVectorsFLU (a, forward, left, up);
 
        VectorNegate (moveangle, a);
        AngleVectorsFLU (a, forward, left, up);
 

-       VectorCopy (pusher->fields.server->origin, pushorig);
-       VectorCopy (pusher->fields.server->angles, pushang);
-       pushltime = pusher->fields.server->ltime;
+       VectorCopy (PRVM_serveredictvector(pusher, origin), pushorig);
+       VectorCopy (PRVM_serveredictvector(pusher, angles), pushang);
+       pushltime = PRVM_serveredictfloat(pusher, ltime);

 
 // move the pusher to its final position
 
 
 // move the pusher to its final position
 

-       VectorMA (pusher->fields.server->origin, movetime, pusher->fields.server->velocity, pusher->fields.server->origin);
-       VectorMA (pusher->fields.server->angles, movetime, pusher->fields.server->avelocity, pusher->fields.server->angles);
-       pusher->fields.server->ltime += movetime;
+       VectorMA (PRVM_serveredictvector(pusher, origin), movetime, PRVM_serveredictvector(pusher, velocity), PRVM_serveredictvector(pusher, origin));
+       VectorMA (PRVM_serveredictvector(pusher, angles), movetime, PRVM_serveredictvector(pusher, avelocity), PRVM_serveredictvector(pusher, angles));
+       PRVM_serveredictfloat(pusher, ltime) += movetime;

        SV_LinkEdict(pusher);
 
        pushermodel = SV_GetModelFromEdict(pusher);
        SV_LinkEdict(pusher);
 
        pushermodel = SV_GetModelFromEdict(pusher);

-       Matrix4x4_CreateFromQuakeEntity(&pusherfinalmatrix, pusher->fields.server->origin[0], pusher->fields.server->origin[1], pusher->fields.server->origin[2], pusher->fields.server->angles[0], pusher->fields.server->angles[1], pusher->fields.server->angles[2], 1);
+       Matrix4x4_CreateFromQuakeEntity(&pusherfinalmatrix, PRVM_serveredictvector(pusher, origin)[0], PRVM_serveredictvector(pusher, origin)[1], PRVM_serveredictvector(pusher, origin)[2], PRVM_serveredictvector(pusher, angles)[0], PRVM_serveredictvector(pusher, angles)[1], PRVM_serveredictvector(pusher, angles)[2], 1);

        Matrix4x4_Invert_Simple(&pusherfinalimatrix, &pusherfinalmatrix);
 
        Matrix4x4_Invert_Simple(&pusherfinalimatrix, &pusherfinalmatrix);
 

-       savesolid = pusher->fields.server->solid;
+       savesolid = PRVM_serveredictfloat(pusher, solid);

 
 // see if any solid entities are inside the final position
        num_moved = 0;
 
 // see if any solid entities are inside the final position
        num_moved = 0;


@@ -1688,7 +1688,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
        for (e = 0;e < numcheckentities;e++)
        {
                prvm_edict_t *check = checkentities[e];
        for (e = 0;e < numcheckentities;e++)
        {
                prvm_edict_t *check = checkentities[e];

-               int movetype = (int)check->fields.server->movetype;
+               int movetype = (int)PRVM_serveredictfloat(check, movetype);

                switch(movetype)
                {
                case MOVETYPE_NONE:
                switch(movetype)
                {
                case MOVETYPE_NONE:


@@ -1701,13 +1701,13 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                        break;
                }
 
                        break;
                }
 

-               if (check->fields.server->owner == pusherprog)
+               if (PRVM_serveredictedict(check, owner) == pusherprog)

                        continue;
 
                if (pusherowner == PRVM_EDICT_TO_PROG(check))
                        continue;
 
                        continue;
 
                if (pusherowner == PRVM_EDICT_TO_PROG(check))
                        continue;
 

-               //Con_Printf("%i %s ", PRVM_NUM_FOR_EDICT(check), PRVM_GetString(check->fields.server->classname));
+               //Con_Printf("%i %s ", PRVM_NUM_FOR_EDICT(check), PRVM_GetString(PRVM_serveredictstring(check, classname)));

 
                // tell any MOVETYPE_STEP entity that it may need to check for water transitions
                check->priv.server->waterposition_forceupdate = true;
 
                // tell any MOVETYPE_STEP entity that it may need to check for water transitions
                check->priv.server->waterposition_forceupdate = true;


@@ -1717,10 +1717,10 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                // if the entity is standing on the pusher, it will definitely be moved
                // if the entity is not standing on the pusher, but is in the pusher's
                // final position, move it
                // if the entity is standing on the pusher, it will definitely be moved
                // if the entity is not standing on the pusher, but is in the pusher's
                // final position, move it

-               if (!((int)check->fields.server->flags & FL_ONGROUND) || PRVM_PROG_TO_EDICT(check->fields.server->groundentity) != pusher)
+               if (!((int)PRVM_serveredictfloat(check, flags) & FL_ONGROUND) || PRVM_PROG_TO_EDICT(PRVM_serveredictedict(check, groundentity)) != pusher)

                {
                {

-                       Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, pusher->fields.server->mins, pusher->fields.server->maxs, SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, checkcontents);
-                       //trace = SV_TraceBox(check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, MOVE_NOMONSTERS, check, checkcontents);
+                       Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, PRVM_serveredictvector(pusher, mins), PRVM_serveredictvector(pusher, maxs), SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, PRVM_serveredictvector(check, origin), PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs), PRVM_serveredictvector(check, origin), checkcontents);
+                       //trace = SV_TraceBox(PRVM_serveredictvector(check, origin), PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs), PRVM_serveredictvector(check, origin), MOVE_NOMONSTERS, check, checkcontents);

                        if (!trace.startsolid)
                        {
                                //Con_Printf("- not in solid\n");
                        if (!trace.startsolid)
                        {
                                //Con_Printf("- not in solid\n");


@@ -1731,7 +1731,7 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
                if (rotated)
                {
                        vec3_t org2;
                if (rotated)
                {
                        vec3_t org2;

-                       VectorSubtract (check->fields.server->origin, pusher->fields.server->origin, org);
+                       VectorSubtract (PRVM_serveredictvector(check, origin), PRVM_serveredictvector(pusher, origin), org);

                        org2[0] = DotProduct (org, forward);
                        org2[1] = DotProduct (org, left);
                        org2[2] = DotProduct (org, up);
                        org2[0] = DotProduct (org, forward);
                        org2[1] = DotProduct (org, left);
                        org2[2] = DotProduct (org, up);


@@ -1743,114 +1743,114 @@ void SV_PushMove (prvm_edict_t *pusher, float movetime)
 
                //Con_Printf("- pushing %f %f %f\n", move[0], move[1], move[2]);
 
 
                //Con_Printf("- pushing %f %f %f\n", move[0], move[1], move[2]);
 

-               VectorCopy (check->fields.server->origin, check->priv.server->moved_from);
-               VectorCopy (check->fields.server->angles, check->priv.server->moved_fromangles);
+               VectorCopy (PRVM_serveredictvector(check, origin), check->priv.server->moved_from);
+               VectorCopy (PRVM_serveredictvector(check, angles), check->priv.server->moved_fromangles);

                moved_edicts[num_moved++] = PRVM_NUM_FOR_EDICT(check);
 
                // physics objects need better collisions than this code can do
                if (movetype == MOVETYPE_PHYSICS)
                {
                moved_edicts[num_moved++] = PRVM_NUM_FOR_EDICT(check);
 
                // physics objects need better collisions than this code can do
                if (movetype == MOVETYPE_PHYSICS)
                {

-                       VectorAdd(check->fields.server->origin, move, check->fields.server->origin);
+                       VectorAdd(PRVM_serveredictvector(check, origin), move, PRVM_serveredictvector(check, origin));

                        SV_LinkEdict(check);
                        SV_LinkEdict_TouchAreaGrid(check);
                        continue;
                }
 
                // try moving the contacted entity
                        SV_LinkEdict(check);
                        SV_LinkEdict_TouchAreaGrid(check);
                        continue;
                }
 
                // try moving the contacted entity

-               pusher->fields.server->solid = SOLID_NOT;
+               PRVM_serveredictfloat(pusher, solid) = SOLID_NOT;

                if(!SV_PushEntity (&trace, check, move, true, true))
                {
                        // entity "check" got teleported
                if(!SV_PushEntity (&trace, check, move, true, true))
                {
                        // entity "check" got teleported

-                       check->fields.server->angles[1] += trace.fraction * moveangle[1];
-                       pusher->fields.server->solid = savesolid; // was SOLID_BSP
+                       PRVM_serveredictvector(check, angles)[1] += trace.fraction * moveangle[1];
+                       PRVM_serveredictfloat(pusher, solid) = savesolid; // was SOLID_BSP

                        continue; // pushed enough
                }
                // FIXME: turn players specially
                        continue; // pushed enough
                }
                // FIXME: turn players specially

-               check->fields.server->angles[1] += trace.fraction * moveangle[1];
-               pusher->fields.server->solid = savesolid; // was SOLID_BSP
+               PRVM_serveredictvector(check, angles)[1] += trace.fraction * moveangle[1];
+               PRVM_serveredictfloat(pusher, solid) = savesolid; // was SOLID_BSP

                //Con_Printf("%s:%d frac %f startsolid %d bmodelstartsolid %d allsolid %d\n", __FILE__, __LINE__, trace.fraction, trace.startsolid, trace.bmodelstartsolid, trace.allsolid);
 
                // this trace.fraction < 1 check causes items to fall off of pushers
                // if they pass under or through a wall
                // the groundentity check causes items to fall off of ledges
                //Con_Printf("%s:%d frac %f startsolid %d bmodelstartsolid %d allsolid %d\n", __FILE__, __LINE__, trace.fraction, trace.startsolid, trace.bmodelstartsolid, trace.allsolid);
 
                // this trace.fraction < 1 check causes items to fall off of pushers
                // if they pass under or through a wall
                // the groundentity check causes items to fall off of ledges

-               if (check->fields.server->movetype != MOVETYPE_WALK && (trace.fraction < 1 || PRVM_PROG_TO_EDICT(check->fields.server->groundentity) != pusher))
-                       check->fields.server->flags = (int)check->fields.server->flags & ~FL_ONGROUND;
+               if (PRVM_serveredictfloat(check, movetype) != MOVETYPE_WALK && (trace.fraction < 1 || PRVM_PROG_TO_EDICT(PRVM_serveredictedict(check, groundentity)) != pusher))
+                       PRVM_serveredictfloat(check, flags) = (int)PRVM_serveredictfloat(check, flags) & ~FL_ONGROUND;

 
                // if it is still inside the pusher, block
 
                // if it is still inside the pusher, block

-               Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, pusher->fields.server->mins, pusher->fields.server->maxs, SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, checkcontents);
+               Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, PRVM_serveredictvector(pusher, mins), PRVM_serveredictvector(pusher, maxs), SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, PRVM_serveredictvector(check, origin), PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs), PRVM_serveredictvector(check, origin), checkcontents);

                if (trace.startsolid)
                {
                        // try moving the contacted entity a tiny bit further to account for precision errors
                        vec3_t move2;
                if (trace.startsolid)
                {
                        // try moving the contacted entity a tiny bit further to account for precision errors
                        vec3_t move2;

-                       pusher->fields.server->solid = SOLID_NOT;
+                       PRVM_serveredictfloat(pusher, solid) = SOLID_NOT;

                        VectorScale(move, 1.1, move2);
                        VectorScale(move, 1.1, move2);

-                       VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
-                       VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+                       VectorCopy (check->priv.server->moved_from, PRVM_serveredictvector(check, origin));
+                       VectorCopy (check->priv.server->moved_fromangles, PRVM_serveredictvector(check, angles));

                        if(!SV_PushEntity (&trace2, check, move2, true, true))
                        {
                                // entity "check" got teleported
                                continue;
                        }
                        if(!SV_PushEntity (&trace2, check, move2, true, true))
                        {
                                // entity "check" got teleported
                                continue;
                        }

-                       pusher->fields.server->solid = savesolid;
-                       Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, pusher->fields.server->mins, pusher->fields.server->maxs, SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, checkcontents);
+                       PRVM_serveredictfloat(pusher, solid) = savesolid;
+                       Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, PRVM_serveredictvector(pusher, mins), PRVM_serveredictvector(pusher, maxs), SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, PRVM_serveredictvector(check, origin), PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs), PRVM_serveredictvector(check, origin), checkcontents);

                        if (trace.startsolid)
                        {
                                // try moving the contacted entity a tiny bit less to account for precision errors
                        if (trace.startsolid)
                        {
                                // try moving the contacted entity a tiny bit less to account for precision errors

-                               pusher->fields.server->solid = SOLID_NOT;
+                               PRVM_serveredictfloat(pusher, solid) = SOLID_NOT;

                                VectorScale(move, 0.9, move2);
                                VectorScale(move, 0.9, move2);

-                               VectorCopy (check->priv.server->moved_from, check->fields.server->origin);
-                               VectorCopy (check->priv.server->moved_fromangles, check->fields.server->angles);
+                               VectorCopy (check->priv.server->moved_from, PRVM_serveredictvector(check, origin));
+                               VectorCopy (check->priv.server->moved_fromangles, PRVM_serveredictvector(check, angles));

                                if(!SV_PushEntity (&trace2, check, move2, true, true))
                                {
                                        // entity "check" got teleported
                                        continue;
                                }
                                if(!SV_PushEntity (&trace2, check, move2, true, true))
                                {
                                        // entity "check" got teleported
                                        continue;
                                }

-                               pusher->fields.server->solid = savesolid;
-                               Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, pusher->fields.server->mins, pusher->fields.server->maxs, SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, check->fields.server->origin, check->fields.server->mins, check->fields.server->maxs, check->fields.server->origin, checkcontents);
+                               PRVM_serveredictfloat(pusher, solid) = savesolid;
+                               Collision_ClipToGenericEntity(&trace, pushermodel, pusher->priv.server->frameblend, &pusher->priv.server->skeleton, PRVM_serveredictvector(pusher, mins), PRVM_serveredictvector(pusher, maxs), SUPERCONTENTS_BODY, &pusherfinalmatrix, &pusherfinalimatrix, PRVM_serveredictvector(check, origin), PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs), PRVM_serveredictvector(check, origin), checkcontents);

                                if (trace.startsolid)
                                {
                                        // still inside pusher, so it's really blocked
 
                                        // fail the move
                                if (trace.startsolid)
                                {
                                        // still inside pusher, so it's really blocked
 
                                        // fail the move

-                                       if (check->fields.server->mins[0] == check->fields.server->maxs[0])
+                                       if (PRVM_serveredictvector(check, mins)[0] == PRVM_serveredictvector(check, maxs)[0])

                                                continue;
                                                continue;

-                                       if (check->fields.server->solid == SOLID_NOT || check->fields.server->solid == SOLID_TRIGGER)
+                                       if (PRVM_serveredictfloat(check, solid) == SOLID_NOT || PRVM_serveredictfloat(check, solid) == SOLID_TRIGGER)

                                        {
                                                // corpse
                                        {
                                                // corpse

-                                               check->fields.server->mins[0] = check->fields.server->mins[1] = 0;
-                                               VectorCopy (check->fields.server->mins, check->fields.server->maxs);
+                                               PRVM_serveredictvector(check, mins)[0] = PRVM_serveredictvector(check, mins)[1] = 0;
+                                               VectorCopy (PRVM_serveredictvector(check, mins), PRVM_serveredictvector(check, maxs));

                                                continue;
                                        }
 
                                                continue;
                                        }
 

-                                       VectorCopy (pushorig, pusher->fields.server->origin);
-                                       VectorCopy (pushang, pusher->fields.server->angles);
-                                       pusher->fields.server->ltime = pushltime;
+                                       VectorCopy (pushorig, PRVM_serveredictvector(pusher, origin));
+                                       VectorCopy (pushang, PRVM_serveredictvector(pusher, angles));
+                                       PRVM_serveredictfloat(pusher, ltime) = pushltime;

                                        SV_LinkEdict(pusher);
 
                                        // move back any entities we already moved
                                        for (i = 0;i < num_moved;i++)
                                        {
                                                prvm_edict_t *ed = PRVM_EDICT_NUM(moved_edicts[i]);
                                        SV_LinkEdict(pusher);
 
                                        // move back any entities we already moved
                                        for (i = 0;i < num_moved;i++)
                                        {
                                                prvm_edict_t *ed = PRVM_EDICT_NUM(moved_edicts[i]);

-                                               VectorCopy (ed->priv.server->moved_from, ed->fields.server->origin);
-                                               VectorCopy (ed->priv.server->moved_fromangles, ed->fields.server->angles);
+                                               VectorCopy (ed->priv.server->moved_from, PRVM_serveredictvector(ed, origin));
+                                               VectorCopy (ed->priv.server->moved_fromangles, PRVM_serveredictvector(ed, angles));

                                                SV_LinkEdict(ed);
                                        }
 
                                        // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone
                                                SV_LinkEdict(ed);
                                        }
 
                                        // if the pusher has a "blocked" function, call it, otherwise just stay in place until the obstacle is gone

-                                       if (pusher->fields.server->blocked)
+                                       if (PRVM_serveredictfunction(pusher, blocked))

                                        {
                                        {

-                                               prog->globals.server->self = PRVM_EDICT_TO_PROG(pusher);
-                                               prog->globals.server->other = PRVM_EDICT_TO_PROG(check);
-                                               PRVM_ExecuteProgram (pusher->fields.server->blocked, "QC function self.blocked is missing");
+                                               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(pusher);
+                                               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(check);
+                                               PRVM_ExecuteProgram (PRVM_serveredictfunction(pusher, blocked), "QC function self.blocked is missing");

                                        }
                                        break;
                                }
                        }
                }
        }
                                        }
                                        break;
                                }
                        }
                }
        }

-       pusher->fields.server->angles[0] -= 360.0 * floor(pusher->fields.server->angles[0] * (1.0 / 360.0));
-       pusher->fields.server->angles[1] -= 360.0 * floor(pusher->fields.server->angles[1] * (1.0 / 360.0));
-       pusher->fields.server->angles[2] -= 360.0 * floor(pusher->fields.server->angles[2] * (1.0 / 360.0));
+       PRVM_serveredictvector(pusher, angles)[0] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[0] * (1.0 / 360.0));
+       PRVM_serveredictvector(pusher, angles)[1] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[1] * (1.0 / 360.0));
+       PRVM_serveredictvector(pusher, angles)[2] -= 360.0 * floor(PRVM_serveredictvector(pusher, angles)[2] * (1.0 / 360.0));

 }
 
 /*
 }
 
 /*


@@ -1863,12 +1863,12 @@ void SV_Physics_Pusher (prvm_edict_t *ent)
 {
        float thinktime, oldltime, movetime;
 
 {
        float thinktime, oldltime, movetime;
 

-       oldltime = ent->fields.server->ltime;
+       oldltime = PRVM_serveredictfloat(ent, ltime);

 
 

-       thinktime = ent->fields.server->nextthink;
-       if (thinktime < ent->fields.server->ltime + sv.frametime)
+       thinktime = PRVM_serveredictfloat(ent, nextthink);
+       if (thinktime < PRVM_serveredictfloat(ent, ltime) + sv.frametime)

        {
        {

-               movetime = thinktime - ent->fields.server->ltime;
+               movetime = thinktime - PRVM_serveredictfloat(ent, ltime);

                if (movetime < 0)
                        movetime = 0;
        }
                if (movetime < 0)
                        movetime = 0;
        }


@@ -1876,16 +1876,16 @@ void SV_Physics_Pusher (prvm_edict_t *ent)
                movetime = sv.frametime;
 
        if (movetime)
                movetime = sv.frametime;
 
        if (movetime)

-               // advances ent->fields.server->ltime if not blocked
+               // advances PRVM_serveredictfloat(ent, ltime) if not blocked

                SV_PushMove (ent, movetime);
 
                SV_PushMove (ent, movetime);
 

-       if (thinktime > oldltime && thinktime <= ent->fields.server->ltime)
+       if (thinktime > oldltime && thinktime <= PRVM_serveredictfloat(ent, ltime))

        {
        {

-               ent->fields.server->nextthink = 0;
-               prog->globals.server->time = sv.time;
-               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-               prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
-               PRVM_ExecuteProgram (ent->fields.server->think, "QC function self.think is missing");
+               PRVM_serveredictfloat(ent, nextthink) = 0;
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
+               PRVM_ExecuteProgram (PRVM_serveredictfunction(ent, think), "QC function self.think is missing");

        }
 }
 
        }
 }
 


@@ -1942,7 +1942,7 @@ unstickresult_t SV_UnstickEntityReturnOffset (prvm_edict_t *ent, vec3_t offset)
                }
        }
 
                }
        }
 

-       maxunstick = (int) ((ent->fields.server->maxs[2] - ent->fields.server->mins[2]) * 0.36);
+       maxunstick = (int) ((PRVM_serveredictvector(ent, maxs)[2] - PRVM_serveredictvector(ent, mins)[2]) * 0.36);

        // magic number 0.36 allows unsticking by up to 17 units with the largest supported bbox
 
        for(i = 2; i <= maxunstick; ++i)
        // magic number 0.36 allows unsticking by up to 17 units with the largest supported bbox
 
        for(i = 2; i <= maxunstick; ++i)


@@ -1975,11 +1975,11 @@ qboolean SV_UnstickEntity (prvm_edict_t *ent)
                case UNSTICK_GOOD:
                        return true;
                case UNSTICK_UNSTUCK:
                case UNSTICK_GOOD:
                        return true;
                case UNSTICK_UNSTUCK:

-                       Con_DPrintf("Unstuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname), offset[0], offset[1], offset[2]);
+                       Con_DPrintf("Unstuck entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);

                        return true;
                case UNSTICK_STUCK:
                        if (developer_extra.integer)
                        return true;
                case UNSTICK_STUCK:
                        if (developer_extra.integer)

-                               Con_DPrintf("Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
+                               Con_DPrintf("Stuck entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)));

                        return false;
                default:
                        Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
                        return false;
                default:
                        Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");


@@ -2002,21 +2002,21 @@ void SV_CheckStuck (prvm_edict_t *ent)
        switch(SV_UnstickEntityReturnOffset(ent, offset))
        {
                case UNSTICK_GOOD:
        switch(SV_UnstickEntityReturnOffset(ent, offset))
        {
                case UNSTICK_GOOD:

-                       VectorCopy (ent->fields.server->origin, ent->fields.server->oldorigin);
+                       VectorCopy (PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, oldorigin));

                        break;
                case UNSTICK_UNSTUCK:
                        break;
                case UNSTICK_UNSTUCK:

-                       Con_DPrintf("Unstuck player entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname), offset[0], offset[1], offset[2]);
+                       Con_DPrintf("Unstuck player entity %i (classname \"%s\") with offset %f %f %f.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)), offset[0], offset[1], offset[2]);

                        break;
                case UNSTICK_STUCK:
                        break;
                case UNSTICK_STUCK:

-                       VectorSubtract(ent->fields.server->oldorigin, ent->fields.server->origin, offset);
+                       VectorSubtract(PRVM_serveredictvector(ent, oldorigin), PRVM_serveredictvector(ent, origin), offset);

                        if (!SV_TestEntityPosition(ent, offset))
                        {
                        if (!SV_TestEntityPosition(ent, offset))
                        {

-                               Con_DPrintf("Unstuck player entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
+                               Con_DPrintf("Unstuck player entity %i (classname \"%s\") by restoring oldorigin.\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)));

                                SV_LinkEdict(ent);
                                //SV_LinkEdict_TouchAreaGrid(ent);
                        }
                        else
                                SV_LinkEdict(ent);
                                //SV_LinkEdict_TouchAreaGrid(ent);
                        }
                        else

-                               Con_DPrintf("Stuck player entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(ent->fields.server->classname));
+                               Con_DPrintf("Stuck player entity %i (classname \"%s\").\n", (int)PRVM_EDICT_TO_PROG(ent), PRVM_GetString(PRVM_serveredictstring(ent, classname)));

                        break;
                default:
                        Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");
                        break;
                default:
                        Con_Printf("SV_UnstickEntityReturnOffset returned a value outside its enum.\n");


@@ -2035,9 +2035,9 @@ qboolean SV_CheckWater (prvm_edict_t *ent)
        int nNativeContents;
        vec3_t point;
 
        int nNativeContents;
        vec3_t point;
 

-       point[0] = ent->fields.server->origin[0];
-       point[1] = ent->fields.server->origin[1];
-       point[2] = ent->fields.server->origin[2] + ent->fields.server->mins[2] + 1;
+       point[0] = PRVM_serveredictvector(ent, origin)[0];
+       point[1] = PRVM_serveredictvector(ent, origin)[1];
+       point[2] = PRVM_serveredictvector(ent, origin)[2] + PRVM_serveredictvector(ent, mins)[2] + 1;

 
        // DRESK - Support for Entity Contents Transition Event
        // NOTE: Some logic needed to be slightly re-ordered
 
        // DRESK - Support for Entity Contents Transition Event
        // NOTE: Some logic needed to be slightly re-ordered


@@ -2049,29 +2049,29 @@ qboolean SV_CheckWater (prvm_edict_t *ent)
        nNativeContents = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
 
        // DRESK - Support for Entity Contents Transition Event
        nNativeContents = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, cont);
 
        // DRESK - Support for Entity Contents Transition Event

-       if(ent->fields.server->watertype)
+       if(PRVM_serveredictfloat(ent, watertype))

                // Entity did NOT Spawn; Check
                SV_CheckContentsTransition(ent, nNativeContents);
 
 
                // Entity did NOT Spawn; Check
                SV_CheckContentsTransition(ent, nNativeContents);
 
 

-       ent->fields.server->waterlevel = 0;
-       ent->fields.server->watertype = CONTENTS_EMPTY;
+       PRVM_serveredictfloat(ent, waterlevel) = 0;
+       PRVM_serveredictfloat(ent, watertype) = CONTENTS_EMPTY;

        cont = SV_PointSuperContents(point);
        if (cont & (SUPERCONTENTS_LIQUIDSMASK))
        {
        cont = SV_PointSuperContents(point);
        if (cont & (SUPERCONTENTS_LIQUIDSMASK))
        {

-               ent->fields.server->watertype = nNativeContents;
-               ent->fields.server->waterlevel = 1;
-               point[2] = ent->fields.server->origin[2] + (ent->fields.server->mins[2] + ent->fields.server->maxs[2])*0.5;
+               PRVM_serveredictfloat(ent, watertype) = nNativeContents;
+               PRVM_serveredictfloat(ent, waterlevel) = 1;
+               point[2] = PRVM_serveredictvector(ent, origin)[2] + (PRVM_serveredictvector(ent, mins)[2] + PRVM_serveredictvector(ent, maxs)[2])*0.5;

                if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
                {
                if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
                {

-                       ent->fields.server->waterlevel = 2;
-                       point[2] = ent->fields.server->origin[2] + ent->fields.server->view_ofs[2];
+                       PRVM_serveredictfloat(ent, waterlevel) = 2;
+                       point[2] = PRVM_serveredictvector(ent, origin)[2] + PRVM_serveredictvector(ent, view_ofs)[2];

                        if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))
                        if (SV_PointSuperContents(point) & (SUPERCONTENTS_LIQUIDSMASK))

-                               ent->fields.server->waterlevel = 3;
+                               PRVM_serveredictfloat(ent, waterlevel) = 3;

                }
        }
 
                }
        }
 

-       return ent->fields.server->waterlevel > 1;
+       return PRVM_serveredictfloat(ent, waterlevel) > 1;

 }
 
 /*
 }
 
 /*


@@ -2085,15 +2085,15 @@ void SV_WallFriction (prvm_edict_t *ent, float *stepnormal)
        float d, i;
        vec3_t forward, into, side;
 
        float d, i;
        vec3_t forward, into, side;
 

-       AngleVectors (ent->fields.server->v_angle, forward, NULL, NULL);
+       AngleVectors (PRVM_serveredictvector(ent, v_angle), forward, NULL, NULL);

        if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
        {
                // cut the tangential velocity
        if ((d = DotProduct (stepnormal, forward) + 0.5) < 0)
        {
                // cut the tangential velocity

-               i = DotProduct (stepnormal, ent->fields.server->velocity);
+               i = DotProduct (stepnormal, PRVM_serveredictvector(ent, velocity));

                VectorScale (stepnormal, i, into);
                VectorScale (stepnormal, i, into);

-               VectorSubtract (ent->fields.server->velocity, into, side);
-               ent->fields.server->velocity[0] = side[0] * (1 + d);
-               ent->fields.server->velocity[1] = side[1] * (1 + d);
+               VectorSubtract (PRVM_serveredictvector(ent, velocity), into, side);
+               PRVM_serveredictvector(ent, velocity)[0] = side[0] * (1 + d);
+               PRVM_serveredictvector(ent, velocity)[1] = side[1] * (1 + d);

        }
 }
 
        }
 }
 


@@ -2115,7 +2115,7 @@ int SV_TryUnstick (prvm_edict_t *ent, vec3_t oldvel)
        int i, clip;
        vec3_t oldorg, dir;
 
        int i, clip;
        vec3_t oldorg, dir;
 

-       VectorCopy (ent->fields.server->origin, oldorg);
+       VectorCopy (PRVM_serveredictvector(ent, origin), oldorg);

        VectorClear (dir);
 
        for (i=0 ; i<8 ; i++)
        VectorClear (dir);
 
        for (i=0 ; i<8 ; i++)


@@ -2136,24 +2136,24 @@ int SV_TryUnstick (prvm_edict_t *ent, vec3_t oldvel)
                SV_PushEntity (&trace, ent, dir, false, true);
 
                // retry the original move
                SV_PushEntity (&trace, ent, dir, false, true);
 
                // retry the original move

-               ent->fields.server->velocity[0] = oldvel[0];
-               ent->fields.server->velocity[1] = oldvel[1];
-               ent->fields.server->velocity[2] = 0;
+               PRVM_serveredictvector(ent, velocity)[0] = oldvel[0];
+               PRVM_serveredictvector(ent, velocity)[1] = oldvel[1];
+               PRVM_serveredictvector(ent, velocity)[2] = 0;

                clip = SV_FlyMove (ent, 0.1, NULL, SV_GenericHitSuperContentsMask(ent));
 
                clip = SV_FlyMove (ent, 0.1, NULL, SV_GenericHitSuperContentsMask(ent));
 

-               if (fabs(oldorg[1] - ent->fields.server->origin[1]) > 4
-                || fabs(oldorg[0] - ent->fields.server->origin[0]) > 4)
+               if (fabs(oldorg[1] - PRVM_serveredictvector(ent, origin)[1]) > 4
+                || fabs(oldorg[0] - PRVM_serveredictvector(ent, origin)[0]) > 4)

                {
                        Con_DPrint("TryUnstick - success.\n");
                        return clip;
                }
 
                // go back to the original pos and try again
                {
                        Con_DPrint("TryUnstick - success.\n");
                        return clip;
                }
 
                // go back to the original pos and try again

-               VectorCopy (oldorg, ent->fields.server->origin);
+               VectorCopy (oldorg, PRVM_serveredictvector(ent, origin));

        }
 
        // still not moving
        }
 
        // still not moving

-       VectorClear (ent->fields.server->velocity);
+       VectorClear (PRVM_serveredictvector(ent, velocity));

        Con_DPrint("TryUnstick - failure.\n");
        return 7;
 }
        Con_DPrint("TryUnstick - failure.\n");
        return 7;
 }


@@ -2186,17 +2186,17 @@ void SV_WalkMove (prvm_edict_t *ent)
 
        SV_CheckStuck (ent);
 
 
        SV_CheckStuck (ent);
 

-       applygravity = !SV_CheckWater (ent) && ent->fields.server->movetype == MOVETYPE_WALK && ! ((int)ent->fields.server->flags & FL_WATERJUMP);
+       applygravity = !SV_CheckWater (ent) && PRVM_serveredictfloat(ent, movetype) == MOVETYPE_WALK && ! ((int)PRVM_serveredictfloat(ent, flags) & FL_WATERJUMP);

 
        hitsupercontentsmask = SV_GenericHitSuperContentsMask(ent);
 
        SV_CheckVelocity(ent);
 
        // do a regular slide move unless it looks like you ran into a step
 
        hitsupercontentsmask = SV_GenericHitSuperContentsMask(ent);
 
        SV_CheckVelocity(ent);
 
        // do a regular slide move unless it looks like you ran into a step

-       oldonground = (int)ent->fields.server->flags & FL_ONGROUND;
+       oldonground = (int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND;

 
 

-       VectorCopy (ent->fields.server->origin, start_origin);
-       VectorCopy (ent->fields.server->velocity, start_velocity);
+       VectorCopy (PRVM_serveredictvector(ent, origin), start_origin);
+       VectorCopy (PRVM_serveredictvector(ent, velocity), start_velocity);

 
        clip = SV_FlyMove (ent, sv.frametime, applygravity, NULL, hitsupercontentsmask, sv_gameplayfix_stepmultipletimes.integer ? sv_stepheight.value : 0);
 
 
        clip = SV_FlyMove (ent, sv.frametime, applygravity, NULL, hitsupercontentsmask, sv_gameplayfix_stepmultipletimes.integer ? sv_stepheight.value : 0);
 


@@ -2206,22 +2206,22 @@ void SV_WalkMove (prvm_edict_t *ent)
                // only try this if there was no floor in the way in the trace (no,
                // this check seems to be not REALLY necessary, because if clip & 1,
                // our trace will hit that thing too)
                // only try this if there was no floor in the way in the trace (no,
                // this check seems to be not REALLY necessary, because if clip & 1,
                // our trace will hit that thing too)

-               VectorSet(upmove, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] + 1);
-               VectorSet(downmove, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] - 1);
-               if (ent->fields.server->movetype == MOVETYPE_FLYMISSILE)
+               VectorSet(upmove, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2] + 1);
+               VectorSet(downmove, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2] - 1);
+               if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_FLYMISSILE)

                        type = MOVE_MISSILE;
                        type = MOVE_MISSILE;

-               else if (ent->fields.server->solid == SOLID_TRIGGER || ent->fields.server->solid == SOLID_NOT)
+               else if (PRVM_serveredictfloat(ent, solid) == SOLID_TRIGGER || PRVM_serveredictfloat(ent, solid) == SOLID_NOT)

                        type = MOVE_NOMONSTERS; // only clip against bmodels
                else
                        type = MOVE_NORMAL;
                        type = MOVE_NOMONSTERS; // only clip against bmodels
                else
                        type = MOVE_NORMAL;

-               trace = SV_TraceBox(upmove, ent->fields.server->mins, ent->fields.server->maxs, downmove, type, ent, SV_GenericHitSuperContentsMask(ent));
+               trace = SV_TraceBox(upmove, PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), downmove, type, ent, SV_GenericHitSuperContentsMask(ent));

                if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
                        clip |= 1; // but we HAVE found a floor
        }
 
        // if the move did not hit the ground at any point, we're not on ground
        if(!(clip & 1))
                if(trace.fraction < 1 && trace.plane.normal[2] > 0.7)
                        clip |= 1; // but we HAVE found a floor
        }
 
        // if the move did not hit the ground at any point, we're not on ground
        if(!(clip & 1))

-               ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+               PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

 
        SV_CheckVelocity(ent);
        SV_LinkEdict(ent);
 
        SV_CheckVelocity(ent);
        SV_LinkEdict(ent);


@@ -2230,17 +2230,17 @@ void SV_WalkMove (prvm_edict_t *ent)
        if(clip & 8) // teleport
                return;
 
        if(clip & 8) // teleport
                return;
 

-       if ((int)ent->fields.server->flags & FL_WATERJUMP)
+       if ((int)PRVM_serveredictfloat(ent, flags) & FL_WATERJUMP)

                return;
 
        if (sv_nostep.integer)
                return;
 
                return;
 
        if (sv_nostep.integer)
                return;
 

-       VectorCopy(ent->fields.server->origin, originalmove_origin);
-       VectorCopy(ent->fields.server->velocity, originalmove_velocity);
+       VectorCopy(PRVM_serveredictvector(ent, origin), originalmove_origin);
+       VectorCopy(PRVM_serveredictvector(ent, velocity), originalmove_velocity);

        //originalmove_clip = clip;
        //originalmove_clip = clip;

-       originalmove_flags = (int)ent->fields.server->flags;
-       originalmove_groundentity = ent->fields.server->groundentity;
+       originalmove_flags = (int)PRVM_serveredictfloat(ent, flags);
+       originalmove_groundentity = PRVM_serveredictedict(ent, groundentity);

 
        // if move didn't block on a step, return
        if (clip & 2)
 
        // if move didn't block on a step, return
        if (clip & 2)


@@ -2249,22 +2249,22 @@ void SV_WalkMove (prvm_edict_t *ent)
                if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
                        return;
 
                if (fabs(start_velocity[0]) < 0.03125 && fabs(start_velocity[1]) < 0.03125)
                        return;
 

-               if (ent->fields.server->movetype != MOVETYPE_FLY)
+               if (PRVM_serveredictfloat(ent, movetype) != MOVETYPE_FLY)

                {
                        // return if gibbed by a trigger
                {
                        // return if gibbed by a trigger

-                       if (ent->fields.server->movetype != MOVETYPE_WALK)
+                       if (PRVM_serveredictfloat(ent, movetype) != MOVETYPE_WALK)

                                return;
 
                        // only step up while jumping if that is enabled
                        if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))
                                return;
 
                        // only step up while jumping if that is enabled
                        if (!(sv_jumpstep.integer && sv_gameplayfix_stepwhilejumping.integer))

-                               if (!oldonground && ent->fields.server->waterlevel == 0)
+                               if (!oldonground && PRVM_serveredictfloat(ent, waterlevel) == 0)

                                        return;
                }
 
                // try moving up and forward to go up a step
                // back to start pos
                                        return;
                }
 
                // try moving up and forward to go up a step
                // back to start pos

-               VectorCopy (start_origin, ent->fields.server->origin);
-               VectorCopy (start_velocity, ent->fields.server->velocity);
+               VectorCopy (start_origin, PRVM_serveredictvector(ent, origin));
+               VectorCopy (start_velocity, PRVM_serveredictvector(ent, velocity));

 
                // move up
                VectorClear (upmove);
 
                // move up
                VectorClear (upmove);


@@ -2276,9 +2276,9 @@ void SV_WalkMove (prvm_edict_t *ent)
                }
 
                // move forward
                }
 
                // move forward

-               ent->fields.server->velocity[2] = 0;
+               PRVM_serveredictvector(ent, velocity)[2] = 0;

                clip = SV_FlyMove (ent, sv.frametime, applygravity, stepnormal, hitsupercontentsmask, 0);
                clip = SV_FlyMove (ent, sv.frametime, applygravity, stepnormal, hitsupercontentsmask, 0);

-               ent->fields.server->velocity[2] += start_velocity[2];
+               PRVM_serveredictvector(ent, velocity)[2] += start_velocity[2];

                if(clip & 8)
                {
                        // we got teleported when upstepping... must abort the move
                if(clip & 8)
                {
                        // we got teleported when upstepping... must abort the move


@@ -2293,16 +2293,16 @@ void SV_WalkMove (prvm_edict_t *ent)
                // check for stuckness, possibly due to the limited precision of floats
                // in the clipping hulls
                if (clip
                // check for stuckness, possibly due to the limited precision of floats
                // in the clipping hulls
                if (clip

-                && fabs(originalmove_origin[1] - ent->fields.server->origin[1]) < 0.03125
-                && fabs(originalmove_origin[0] - ent->fields.server->origin[0]) < 0.03125)
+                && fabs(originalmove_origin[1] - PRVM_serveredictvector(ent, origin)[1]) < 0.03125
+                && fabs(originalmove_origin[0] - PRVM_serveredictvector(ent, origin)[0]) < 0.03125)

                {
                        //Con_Printf("wall\n");
                        // stepping up didn't make any progress, revert to original move
                {
                        //Con_Printf("wall\n");
                        // stepping up didn't make any progress, revert to original move

-                       VectorCopy(originalmove_origin, ent->fields.server->origin);
-                       VectorCopy(originalmove_velocity, ent->fields.server->velocity);
+                       VectorCopy(originalmove_origin, PRVM_serveredictvector(ent, origin));
+                       VectorCopy(originalmove_velocity, PRVM_serveredictvector(ent, velocity));

                        //clip = originalmove_clip;
                        //clip = originalmove_clip;

-                       ent->fields.server->flags = originalmove_flags;
-                       ent->fields.server->groundentity = originalmove_groundentity;
+                       PRVM_serveredictfloat(ent, flags) = originalmove_flags;
+                       PRVM_serveredictedict(ent, groundentity) = originalmove_groundentity;

                        // now try to unstick if needed
                        //clip = SV_TryUnstick (ent, oldvel);
                        return;
                        // now try to unstick if needed
                        //clip = SV_TryUnstick (ent, oldvel);
                        return;


@@ -2315,7 +2315,7 @@ void SV_WalkMove (prvm_edict_t *ent)
                        SV_WallFriction (ent, stepnormal);
        }
        // don't do the down move if stepdown is disabled, moving upward, not in water, or the move started offground or ended onground
                        SV_WallFriction (ent, stepnormal);
        }
        // don't do the down move if stepdown is disabled, moving upward, not in water, or the move started offground or ended onground

-       else if (!sv_gameplayfix_stepdown.integer || ent->fields.server->waterlevel >= 3 || start_velocity[2] >= (1.0 / 32.0) || !oldonground || ((int)ent->fields.server->flags & FL_ONGROUND))
+       else if (!sv_gameplayfix_stepdown.integer || PRVM_serveredictfloat(ent, waterlevel) >= 3 || start_velocity[2] >= (1.0 / 32.0) || !oldonground || ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND))

                return;
 
        // move down
                return;
 
        // move down


@@ -2333,11 +2333,11 @@ void SV_WalkMove (prvm_edict_t *ent)
                // up while already jumping (also known as the Quake2 double jump bug)
 #if 0
                // LordHavoc: disabled this check so you can walk on monsters/players
                // up while already jumping (also known as the Quake2 double jump bug)
 #if 0
                // LordHavoc: disabled this check so you can walk on monsters/players

-               //if (ent->fields.server->solid == SOLID_BSP)
+               //if (PRVM_serveredictfloat(ent, solid) == SOLID_BSP)

                {
                        //Con_Printf("onground\n");
                {
                        //Con_Printf("onground\n");

-                       ent->fields.server->flags =     (int)ent->fields.server->flags | FL_ONGROUND;
-                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(downtrace.ent);
+                       PRVM_serveredictfloat(ent, flags) =     (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                       PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(downtrace.ent);

                }
 #endif
        }
                }
 #endif
        }


@@ -2347,11 +2347,11 @@ void SV_WalkMove (prvm_edict_t *ent)
                // if the push down didn't end up on good ground, use the move without
                // the step up.  This happens near wall / slope combinations, and can
                // cause the player to hop up higher on a slope too steep to climb
                // if the push down didn't end up on good ground, use the move without
                // the step up.  This happens near wall / slope combinations, and can
                // cause the player to hop up higher on a slope too steep to climb

-               VectorCopy(originalmove_origin, ent->fields.server->origin);
-               VectorCopy(originalmove_velocity, ent->fields.server->velocity);
+               VectorCopy(originalmove_origin, PRVM_serveredictvector(ent, origin));
+               VectorCopy(originalmove_velocity, PRVM_serveredictvector(ent, velocity));

                //clip = originalmove_clip;
                //clip = originalmove_clip;

-               ent->fields.server->flags = originalmove_flags;
-               ent->fields.server->groundentity = originalmove_groundentity;
+               PRVM_serveredictfloat(ent, flags) = originalmove_flags;
+               PRVM_serveredictedict(ent, groundentity) = originalmove_groundentity;

        }
 
        SV_CheckVelocity(ent);
        }
 
        SV_CheckVelocity(ent);


@@ -2378,30 +2378,30 @@ void SV_Physics_Follow (prvm_edict_t *ent)
                return;
 
        // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects
                return;
 
        // LordHavoc: implemented rotation on MOVETYPE_FOLLOW objects

-       e = PRVM_PROG_TO_EDICT(ent->fields.server->aiment);
-       if (e->fields.server->angles[0] == ent->fields.server->punchangle[0] && e->fields.server->angles[1] == ent->fields.server->punchangle[1] && e->fields.server->angles[2] == ent->fields.server->punchangle[2])
+       e = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, aiment));
+       if (PRVM_serveredictvector(e, angles)[0] == PRVM_serveredictvector(ent, punchangle)[0] && PRVM_serveredictvector(e, angles)[1] == PRVM_serveredictvector(ent, punchangle)[1] && PRVM_serveredictvector(e, angles)[2] == PRVM_serveredictvector(ent, punchangle)[2])

        {
                // quick case for no rotation
        {
                // quick case for no rotation

-               VectorAdd(e->fields.server->origin, ent->fields.server->view_ofs, ent->fields.server->origin);
+               VectorAdd(PRVM_serveredictvector(e, origin), PRVM_serveredictvector(ent, view_ofs), PRVM_serveredictvector(ent, origin));

        }
        else
        {
        }
        else
        {

-               angles[0] = -ent->fields.server->punchangle[0];
-               angles[1] =  ent->fields.server->punchangle[1];
-               angles[2] =  ent->fields.server->punchangle[2];
+               angles[0] = -PRVM_serveredictvector(ent, punchangle)[0];
+               angles[1] =  PRVM_serveredictvector(ent, punchangle)[1];
+               angles[2] =  PRVM_serveredictvector(ent, punchangle)[2];

                AngleVectors (angles, vf, vr, vu);
                AngleVectors (angles, vf, vr, vu);

-               v[0] = ent->fields.server->view_ofs[0] * vf[0] + ent->fields.server->view_ofs[1] * vr[0] + ent->fields.server->view_ofs[2] * vu[0];
-               v[1] = ent->fields.server->view_ofs[0] * vf[1] + ent->fields.server->view_ofs[1] * vr[1] + ent->fields.server->view_ofs[2] * vu[1];
-               v[2] = ent->fields.server->view_ofs[0] * vf[2] + ent->fields.server->view_ofs[1] * vr[2] + ent->fields.server->view_ofs[2] * vu[2];
-               angles[0] = -e->fields.server->angles[0];
-               angles[1] =  e->fields.server->angles[1];
-               angles[2] =  e->fields.server->angles[2];
+               v[0] = PRVM_serveredictvector(ent, view_ofs)[0] * vf[0] + PRVM_serveredictvector(ent, view_ofs)[1] * vr[0] + PRVM_serveredictvector(ent, view_ofs)[2] * vu[0];
+               v[1] = PRVM_serveredictvector(ent, view_ofs)[0] * vf[1] + PRVM_serveredictvector(ent, view_ofs)[1] * vr[1] + PRVM_serveredictvector(ent, view_ofs)[2] * vu[1];
+               v[2] = PRVM_serveredictvector(ent, view_ofs)[0] * vf[2] + PRVM_serveredictvector(ent, view_ofs)[1] * vr[2] + PRVM_serveredictvector(ent, view_ofs)[2] * vu[2];
+               angles[0] = -PRVM_serveredictvector(e, angles)[0];
+               angles[1] =  PRVM_serveredictvector(e, angles)[1];
+               angles[2] =  PRVM_serveredictvector(e, angles)[2];

                AngleVectors (angles, vf, vr, vu);
                AngleVectors (angles, vf, vr, vu);

-               ent->fields.server->origin[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + e->fields.server->origin[0];
-               ent->fields.server->origin[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + e->fields.server->origin[1];
-               ent->fields.server->origin[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + e->fields.server->origin[2];
+               PRVM_serveredictvector(ent, origin)[0] = v[0] * vf[0] + v[1] * vf[1] + v[2] * vf[2] + PRVM_serveredictvector(e, origin)[0];
+               PRVM_serveredictvector(ent, origin)[1] = v[0] * vr[0] + v[1] * vr[1] + v[2] * vr[2] + PRVM_serveredictvector(e, origin)[1];
+               PRVM_serveredictvector(ent, origin)[2] = v[0] * vu[0] + v[1] * vu[1] + v[2] * vu[2] + PRVM_serveredictvector(e, origin)[2];

        }
        }

-       VectorAdd (e->fields.server->angles, ent->fields.server->v_angle, ent->fields.server->angles);
+       VectorAdd (PRVM_serveredictvector(e, angles), PRVM_serveredictvector(ent, v_angle), PRVM_serveredictvector(ent, angles));

        SV_LinkEdict(ent);
        //SV_LinkEdict_TouchAreaGrid(ent);
 }
        SV_LinkEdict(ent);
        //SV_LinkEdict_TouchAreaGrid(ent);
 }


@@ -2423,12 +2423,12 @@ SV_CheckWaterTransition
 void SV_CheckWaterTransition (prvm_edict_t *ent)
 {
        int cont;
 void SV_CheckWaterTransition (prvm_edict_t *ent)
 {
        int cont;

-       cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(ent->fields.server->origin));
-       if (!ent->fields.server->watertype)
+       cont = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, SV_PointSuperContents(PRVM_serveredictvector(ent, origin)));
+       if (!PRVM_serveredictfloat(ent, watertype))

        {
                // just spawned here
        {
                // just spawned here

-               ent->fields.server->watertype = cont;
-               ent->fields.server->waterlevel = 1;
+               PRVM_serveredictfloat(ent, watertype) = cont;
+               PRVM_serveredictfloat(ent, waterlevel) = 1;

                return;
        }
 
                return;
        }
 


@@ -2439,19 +2439,19 @@ void SV_CheckWaterTransition (prvm_edict_t *ent)
        if( !SV_CheckContentsTransition(ent, cont) )
        { // Contents Transition Function Invalid; Potentially Play Water Sound
                // check if the entity crossed into or out of water
        if( !SV_CheckContentsTransition(ent, cont) )
        { // Contents Transition Function Invalid; Potentially Play Water Sound
                // check if the entity crossed into or out of water

-               if (sv_sound_watersplash.string && ((ent->fields.server->watertype == CONTENTS_WATER || ent->fields.server->watertype == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME)))
+               if (sv_sound_watersplash.string && ((PRVM_serveredictfloat(ent, watertype) == CONTENTS_WATER || PRVM_serveredictfloat(ent, watertype) == CONTENTS_SLIME) != (cont == CONTENTS_WATER || cont == CONTENTS_SLIME)))

                        SV_StartSound (ent, 0, sv_sound_watersplash.string, 255, 1);
        }
 
        if (cont <= CONTENTS_WATER)
        {
                        SV_StartSound (ent, 0, sv_sound_watersplash.string, 255, 1);
        }
 
        if (cont <= CONTENTS_WATER)
        {

-               ent->fields.server->watertype = cont;
-               ent->fields.server->waterlevel = 1;
+               PRVM_serveredictfloat(ent, watertype) = cont;
+               PRVM_serveredictfloat(ent, waterlevel) = 1;

        }
        else
        {
        }
        else
        {

-               ent->fields.server->watertype = CONTENTS_EMPTY;
-               ent->fields.server->waterlevel = 0;
+               PRVM_serveredictfloat(ent, watertype) = CONTENTS_EMPTY;
+               PRVM_serveredictfloat(ent, waterlevel) = 0;

        }
 }
 
        }
 }
 


@@ -2471,15 +2471,15 @@ void SV_Physics_Toss (prvm_edict_t *ent)
        prvm_edict_t *groundentity;
 
 // if onground, return without moving
        prvm_edict_t *groundentity;
 
 // if onground, return without moving

-       if ((int)ent->fields.server->flags & FL_ONGROUND)
+       if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)

        {
        {

-               groundentity = PRVM_PROG_TO_EDICT(ent->fields.server->groundentity);
-               if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)
+               groundentity = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, groundentity));
+               if (PRVM_serveredictvector(ent, velocity)[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)

                {
                        // don't stick to ground if onground and moving upward
                {
                        // don't stick to ground if onground and moving upward

-                       ent->fields.server->flags -= FL_ONGROUND;
+                       PRVM_serveredictfloat(ent, flags) -= FL_ONGROUND;

                }
                }

-               else if (!ent->fields.server->groundentity || !sv_gameplayfix_noairborncorpse.integer)
+               else if (!PRVM_serveredictedict(ent, groundentity) || !sv_gameplayfix_noairborncorpse.integer)

                {
                        // we can trust FL_ONGROUND if groundentity is world because it never moves
                        return;
                {
                        // we can trust FL_ONGROUND if groundentity is world because it never moves
                        return;


@@ -2489,7 +2489,7 @@ void SV_Physics_Toss (prvm_edict_t *ent)
                        // if ent was supported by a brush model on previous frame,
                        // and groundentity is now freed, set groundentity to 0 (world)
                        // which leaves it suspended in the air
                        // if ent was supported by a brush model on previous frame,
                        // and groundentity is now freed, set groundentity to 0 (world)
                        // which leaves it suspended in the air

-                       ent->fields.server->groundentity = 0;
+                       PRVM_serveredictedict(ent, groundentity) = 0;

                        if (sv_gameplayfix_noairborncorpse_allowsuspendeditems.integer)
                                return;
                }
                        if (sv_gameplayfix_noairborncorpse_allowsuspendeditems.integer)
                                return;
                }


@@ -2504,17 +2504,17 @@ void SV_Physics_Toss (prvm_edict_t *ent)
        SV_CheckVelocity (ent);
 
 // add gravity
        SV_CheckVelocity (ent);
 
 // add gravity

-       if (ent->fields.server->movetype == MOVETYPE_TOSS || ent->fields.server->movetype == MOVETYPE_BOUNCE)
-               ent->fields.server->velocity[2] -= SV_Gravity(ent);
+       if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_TOSS || PRVM_serveredictfloat(ent, movetype) == MOVETYPE_BOUNCE)
+               PRVM_serveredictvector(ent, velocity)[2] -= SV_Gravity(ent);

 
 // move angles
 
 // move angles

-       VectorMA (ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
+       VectorMA (PRVM_serveredictvector(ent, angles), sv.frametime, PRVM_serveredictvector(ent, avelocity), PRVM_serveredictvector(ent, angles));

 
        movetime = sv.frametime;
        for (bump = 0;bump < MAX_CLIP_PLANES && movetime > 0;bump++)
        {
        // move origin
 
        movetime = sv.frametime;
        for (bump = 0;bump < MAX_CLIP_PLANES && movetime > 0;bump++)
        {
        // move origin

-               VectorScale (ent->fields.server->velocity, movetime, move);
+               VectorScale (PRVM_serveredictvector(ent, velocity), movetime, move);

                if(!SV_PushEntity (&trace, ent, move, true, true))
                        return; // teleported
                if (ent->priv.server->free)
                if(!SV_PushEntity (&trace, ent, move, true, true))
                        return; // teleported
                if (ent->priv.server->free)


@@ -2531,17 +2531,17 @@ void SV_Physics_Toss (prvm_edict_t *ent)
                if (trace.fraction == 1)
                        break;
                movetime *= 1 - min(1, trace.fraction);
                if (trace.fraction == 1)
                        break;
                movetime *= 1 - min(1, trace.fraction);

-               if (ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE)
+               if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_BOUNCEMISSILE)

                {
                        float bouncefactor;
                        bouncefactor = PRVM_serveredictfloat(ent, bouncefactor);
                        if (!bouncefactor)
                                bouncefactor = 1.0f;
 
                {
                        float bouncefactor;
                        bouncefactor = PRVM_serveredictfloat(ent, bouncefactor);
                        if (!bouncefactor)
                                bouncefactor = 1.0f;
 

-                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);
-                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                       ClipVelocity (PRVM_serveredictvector(ent, velocity), trace.plane.normal, PRVM_serveredictvector(ent, velocity), 1 + bouncefactor);
+                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

                }
                }

-               else if (ent->fields.server->movetype == MOVETYPE_BOUNCE)
+               else if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_BOUNCE)

                {
                        float d, ent_gravity;
                        float bouncefactor;
                {
                        float d, ent_gravity;
                        float bouncefactor;


@@ -2555,53 +2555,53 @@ void SV_Physics_Toss (prvm_edict_t *ent)
                        if (!bouncestop)
                                bouncestop = 60.0f / 800.0f;
 
                        if (!bouncestop)
                                bouncestop = 60.0f / 800.0f;
 

-                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1 + bouncefactor);
+                       ClipVelocity (PRVM_serveredictvector(ent, velocity), trace.plane.normal, PRVM_serveredictvector(ent, velocity), 1 + bouncefactor);

                        ent_gravity = PRVM_serveredictfloat(ent, gravity);
                        if (!ent_gravity)
                                ent_gravity = 1.0f;
                        // LordHavoc: fixed grenades not bouncing when fired down a slope
                        if (sv_gameplayfix_grenadebouncedownslopes.integer)
                        {
                        ent_gravity = PRVM_serveredictfloat(ent, gravity);
                        if (!ent_gravity)
                                ent_gravity = 1.0f;
                        // LordHavoc: fixed grenades not bouncing when fired down a slope
                        if (sv_gameplayfix_grenadebouncedownslopes.integer)
                        {

-                               d = DotProduct(trace.plane.normal, ent->fields.server->velocity);
+                               d = DotProduct(trace.plane.normal, PRVM_serveredictvector(ent, velocity));

                                if (trace.plane.normal[2] > 0.7 && fabs(d) < sv_gravity.value * bouncestop * ent_gravity)
                                {
                                if (trace.plane.normal[2] > 0.7 && fabs(d) < sv_gravity.value * bouncestop * ent_gravity)
                                {

-                                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
-                                       VectorClear (ent->fields.server->velocity);
-                                       VectorClear (ent->fields.server->avelocity);
+                                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                                       PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+                                       VectorClear (PRVM_serveredictvector(ent, velocity));
+                                       VectorClear (PRVM_serveredictvector(ent, avelocity));

                                }
                                else
                                }
                                else

-                                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

                        }
                        else
                        {
                        }
                        else
                        {

-                               if (trace.plane.normal[2] > 0.7 && ent->fields.server->velocity[2] < sv_gravity.value * bouncestop * ent_gravity)
+                               if (trace.plane.normal[2] > 0.7 && PRVM_serveredictvector(ent, velocity)[2] < sv_gravity.value * bouncestop * ent_gravity)

                                {
                                {

-                                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
-                                       VectorClear (ent->fields.server->velocity);
-                                       VectorClear (ent->fields.server->avelocity);
+                                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                                       PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+                                       VectorClear (PRVM_serveredictvector(ent, velocity));
+                                       VectorClear (PRVM_serveredictvector(ent, avelocity));

                                }
                                else
                                }
                                else

-                                       ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

                        }
                }
                else
                {
                        }
                }
                else
                {

-                       ClipVelocity (ent->fields.server->velocity, trace.plane.normal, ent->fields.server->velocity, 1.0);
+                       ClipVelocity (PRVM_serveredictvector(ent, velocity), trace.plane.normal, PRVM_serveredictvector(ent, velocity), 1.0);

                        if (trace.plane.normal[2] > 0.7)
                        {
                        if (trace.plane.normal[2] > 0.7)
                        {

-                               ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                               ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
-                               if (((prvm_edict_t *)trace.ent)->fields.server->solid == SOLID_BSP)
+                               PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                               PRVM_serveredictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
+                               if (PRVM_serveredictfloat(((prvm_edict_t *)trace.ent), solid) == SOLID_BSP)

                                        ent->priv.server->suspendedinairflag = true;
                                        ent->priv.server->suspendedinairflag = true;

-                               VectorClear (ent->fields.server->velocity);
-                               VectorClear (ent->fields.server->avelocity);
+                               VectorClear (PRVM_serveredictvector(ent, velocity));
+                               VectorClear (PRVM_serveredictvector(ent, avelocity));

                        }
                        else
                        }
                        else

-                               ent->fields.server->flags = (int)ent->fields.server->flags & ~FL_ONGROUND;
+                               PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) & ~FL_ONGROUND;

                }
                }

-               if (!sv_gameplayfix_slidemoveprojectiles.integer || (ent->fields.server->movetype != MOVETYPE_BOUNCE && ent->fields.server->movetype == MOVETYPE_BOUNCEMISSILE) || ((int)ent->fields.server->flags & FL_ONGROUND))
+               if (!sv_gameplayfix_slidemoveprojectiles.integer || (PRVM_serveredictfloat(ent, movetype) != MOVETYPE_BOUNCE && PRVM_serveredictfloat(ent, movetype) == MOVETYPE_BOUNCEMISSILE) || ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND))

                        break;
        }
 
                        break;
        }
 


@@ -2630,13 +2630,13 @@ will fall if the floor is pulled out from under them.
 */
 void SV_Physics_Step (prvm_edict_t *ent)
 {
 */
 void SV_Physics_Step (prvm_edict_t *ent)
 {

-       int flags = (int)ent->fields.server->flags;
+       int flags = (int)PRVM_serveredictfloat(ent, flags);

 
        // DRESK
        // Backup Velocity in the event that movetypesteplandevent is called,
        // to provide a parameter with the entity's velocity at impact.
        vec3_t backupVelocity;
 
        // DRESK
        // Backup Velocity in the event that movetypesteplandevent is called,
        // to provide a parameter with the entity's velocity at impact.
        vec3_t backupVelocity;

-       VectorCopy(ent->fields.server->velocity, backupVelocity);
+       VectorCopy(PRVM_serveredictvector(ent, velocity), backupVelocity);

        // don't fall at all if fly/swim
        if (!(flags & (FL_FLY | FL_SWIM)))
        {
        // don't fall at all if fly/swim
        if (!(flags & (FL_FLY | FL_SWIM)))
        {


@@ -2644,9 +2644,9 @@ void SV_Physics_Step (prvm_edict_t *ent)
                {
                        // freefall if onground and moving upward
                        // freefall if not standing on a world surface (it may be a lift or trap door)
                {
                        // freefall if onground and moving upward
                        // freefall if not standing on a world surface (it may be a lift or trap door)

-                       if (ent->fields.server->velocity[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)
+                       if (PRVM_serveredictvector(ent, velocity)[2] >= (1.0 / 32.0) && sv_gameplayfix_upwardvelocityclearsongroundflag.integer)

                        {
                        {

-                               ent->fields.server->flags -= FL_ONGROUND;
+                               PRVM_serveredictfloat(ent, flags) -= FL_ONGROUND;

                                SV_CheckVelocity(ent);
                                SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent), 0);
                                SV_LinkEdict(ent);
                                SV_CheckVelocity(ent);
                                SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent), 0);
                                SV_LinkEdict(ent);


@@ -2657,7 +2657,7 @@ void SV_Physics_Step (prvm_edict_t *ent)
                else
                {
                        // freefall if not onground
                else
                {
                        // freefall if not onground

-                       int hitsound = ent->fields.server->velocity[2] < sv_gravity.value * -0.1;
+                       int hitsound = PRVM_serveredictvector(ent, velocity)[2] < sv_gravity.value * -0.1;

 
                        SV_CheckVelocity(ent);
                        SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent), 0);
 
                        SV_CheckVelocity(ent);
                        SV_FlyMove(ent, sv.frametime, true, NULL, SV_GenericHitSuperContentsMask(ent), 0);


@@ -2665,7 +2665,7 @@ void SV_Physics_Step (prvm_edict_t *ent)
                        SV_LinkEdict_TouchAreaGrid(ent);
 
                        // just hit ground
                        SV_LinkEdict_TouchAreaGrid(ent);
 
                        // just hit ground

-                       if (hitsound && (int)ent->fields.server->flags & FL_ONGROUND)
+                       if (hitsound && (int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)

                        {
                                // DRESK - Check for Entity Land Event Function
                                if(PRVM_serveredictfunction(ent, movetypesteplandevent))
                        {
                                // DRESK - Check for Entity Land Event Function
                                if(PRVM_serveredictfunction(ent, movetypesteplandevent))


@@ -2676,7 +2676,7 @@ void SV_Physics_Step (prvm_edict_t *ent)
                                                PRVM_G_VECTOR(OFS_PARM0)[1] = backupVelocity[1];
                                                PRVM_G_VECTOR(OFS_PARM0)[2] = backupVelocity[2];
                                                // Assign Self
                                                PRVM_G_VECTOR(OFS_PARM0)[1] = backupVelocity[1];
                                                PRVM_G_VECTOR(OFS_PARM0)[2] = backupVelocity[2];
                                                // Assign Self

-                                               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+                                               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);

                                        // Execute VM Function
                                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, movetypesteplandevent), "movetypesteplandevent: NULL function");
                                }
                                        // Execute VM Function
                                        PRVM_ExecuteProgram(PRVM_serveredictfunction(ent, movetypesteplandevent), "movetypesteplandevent: NULL function");
                                }


@@ -2693,10 +2693,10 @@ void SV_Physics_Step (prvm_edict_t *ent)
        if (!SV_RunThink(ent))
                return;
 
        if (!SV_RunThink(ent))
                return;
 

-       if (ent->priv.server->waterposition_forceupdate || !VectorCompare(ent->fields.server->origin, ent->priv.server->waterposition_origin))
+       if (ent->priv.server->waterposition_forceupdate || !VectorCompare(PRVM_serveredictvector(ent, origin), ent->priv.server->waterposition_origin))

        {
                ent->priv.server->waterposition_forceupdate = false;
        {
                ent->priv.server->waterposition_forceupdate = false;

-               VectorCopy(ent->fields.server->origin, ent->priv.server->waterposition_origin);
+               VectorCopy(PRVM_serveredictvector(ent, origin), ent->priv.server->waterposition_origin);

                SV_CheckWaterTransition(ent);
        }
 }
                SV_CheckWaterTransition(ent);
        }
 }


@@ -2715,7 +2715,7 @@ static void SV_Physics_Entity (prvm_edict_t *ent)
        ent->priv.server->move = true;
        if (!runmove && sv_gameplayfix_delayprojectiles.integer > 0)
                return;
        ent->priv.server->move = true;
        if (!runmove && sv_gameplayfix_delayprojectiles.integer > 0)
                return;

-       switch ((int) ent->fields.server->movetype)
+       switch ((int) PRVM_serveredictfloat(ent, movetype))

        {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:
        {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:


@@ -2723,7 +2723,7 @@ static void SV_Physics_Entity (prvm_edict_t *ent)
                break;
        case MOVETYPE_NONE:
                // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
                break;
        case MOVETYPE_NONE:
                // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects

-               if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
+               if (PRVM_serveredictfloat(ent, nextthink) > 0 && PRVM_serveredictfloat(ent, nextthink) <= sv.time + sv.frametime)

                        SV_RunThink (ent);
                break;
        case MOVETYPE_FOLLOW:
                        SV_RunThink (ent);
                break;
        case MOVETYPE_FOLLOW:


@@ -2733,8 +2733,8 @@ static void SV_Physics_Entity (prvm_edict_t *ent)
                if (SV_RunThink(ent))
                {
                        SV_CheckWater(ent);
                if (SV_RunThink(ent))
                {
                        SV_CheckWater(ent);

-                       VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
-                       VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
+                       VectorMA(PRVM_serveredictvector(ent, origin), sv.frametime, PRVM_serveredictvector(ent, velocity), PRVM_serveredictvector(ent, origin));
+                       VectorMA(PRVM_serveredictvector(ent, angles), sv.frametime, PRVM_serveredictvector(ent, avelocity), PRVM_serveredictvector(ent, angles));

                }
                SV_LinkEdict(ent);
                break;
                }
                SV_LinkEdict(ent);
                break;


@@ -2762,7 +2762,7 @@ static void SV_Physics_Entity (prvm_edict_t *ent)
                }
                break;
        default:
                }
                break;
        default:

-               Con_Printf ("SV_Physics: bad movetype %i\n", (int)ent->fields.server->movetype);
+               Con_Printf ("SV_Physics: bad movetype %i\n", (int)PRVM_serveredictfloat(ent, movetype));

                break;
        }
 }
                break;
        }
 }


@@ -2773,15 +2773,15 @@ void SV_Physics_ClientMove(void)
        ent = host_client->edict;
 
        // call player physics, this needs the proper frametime
        ent = host_client->edict;
 
        // call player physics, this needs the proper frametime

-       prog->globals.server->frametime = sv.frametime;
+       PRVM_serverglobalfloat(frametime) = sv.frametime;

        SV_ClientThink();
 
        // call standard client pre-think, with frametime = 0
        SV_ClientThink();
 
        // call standard client pre-think, with frametime = 0

-       prog->globals.server->time = sv.time;
-       prog->globals.server->frametime = 0;
-       prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-       PRVM_ExecuteProgram (prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
-       prog->globals.server->frametime = sv.frametime;
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobalfloat(frametime) = 0;
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+       PRVM_ExecuteProgram (PRVM_serverfunction(PlayerPreThink), "QC function PlayerPreThink is missing");
+       PRVM_serverglobalfloat(frametime) = sv.frametime;

 
        // make sure the velocity is sane (not a NaN)
        SV_CheckVelocity(ent);
 
        // make sure the velocity is sane (not a NaN)
        SV_CheckVelocity(ent);


@@ -2790,21 +2790,21 @@ void SV_Physics_ClientMove(void)
        SV_WalkMove (ent);
 
        // call standard player post-think, with frametime = 0
        SV_WalkMove (ent);
 
        // call standard player post-think, with frametime = 0

-       prog->globals.server->time = sv.time;
-       prog->globals.server->frametime = 0;
-       prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-       PRVM_ExecuteProgram (prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
-       prog->globals.server->frametime = sv.frametime;
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobalfloat(frametime) = 0;
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+       PRVM_ExecuteProgram (PRVM_serverfunction(PlayerPostThink), "QC function PlayerPostThink is missing");
+       PRVM_serverglobalfloat(frametime) = sv.frametime;

 
 

-       if(ent->fields.server->fixangle)
+       if(PRVM_serveredictfloat(ent, fixangle))

        {
                // angle fixing was requested by physics code...
                // so store the current angles for later use
        {
                // angle fixing was requested by physics code...
                // so store the current angles for later use

-               memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
+               memcpy(host_client->fixangle_angles, PRVM_serveredictvector(ent, angles), sizeof(host_client->fixangle_angles));

                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame
                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame

-               ent->fields.server->fixangle = 0;
+               PRVM_serveredictfloat(ent, fixangle) = 0;

        }
 }
 
        }
 }
 


@@ -2828,9 +2828,9 @@ static void SV_Physics_ClientEntity_PreThink(prvm_edict_t *ent)
        SV_CheckVelocity(ent);
 
        // call standard client pre-think
        SV_CheckVelocity(ent);
 
        // call standard client pre-think

-       prog->globals.server->time = sv.time;
-       prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-       PRVM_ExecuteProgram(prog->globals.server->PlayerPreThink, "QC function PlayerPreThink is missing");
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+       PRVM_ExecuteProgram(PRVM_serverfunction(PlayerPreThink), "QC function PlayerPreThink is missing");

 
        // make sure the velocity is still sane (not a NaN)
        SV_CheckVelocity(ent);
 
        // make sure the velocity is still sane (not a NaN)
        SV_CheckVelocity(ent);


@@ -2846,22 +2846,22 @@ static void SV_Physics_ClientEntity_PostThink(prvm_edict_t *ent)
        SV_CheckVelocity(ent);
 
        // call standard player post-think
        SV_CheckVelocity(ent);
 
        // call standard player post-think

-       prog->globals.server->time = sv.time;
-       prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
-       PRVM_ExecuteProgram(prog->globals.server->PlayerPostThink, "QC function PlayerPostThink is missing");
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
+       PRVM_ExecuteProgram(PRVM_serverfunction(PlayerPostThink), "QC function PlayerPostThink is missing");

 
        // make sure the velocity is still sane (not a NaN)
        SV_CheckVelocity(ent);
 
 
        // make sure the velocity is still sane (not a NaN)
        SV_CheckVelocity(ent);
 

-       if(ent->fields.server->fixangle)
+       if(PRVM_serveredictfloat(ent, fixangle))

        {
                // angle fixing was requested by physics code...
                // so store the current angles for later use
        {
                // angle fixing was requested by physics code...
                // so store the current angles for later use

-               memcpy(host_client->fixangle_angles, ent->fields.server->angles, sizeof(host_client->fixangle_angles));
+               memcpy(host_client->fixangle_angles, PRVM_serveredictvector(ent, angles), sizeof(host_client->fixangle_angles));

                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame
                host_client->fixangle_angles_set = TRUE;
 
                // and clear fixangle for the next frame

-               ent->fields.server->fixangle = 0;
+               PRVM_serveredictfloat(ent, fixangle) = 0;

        }
 
        // decrement the countdown variable used to decide when to go back to
        }
 
        // decrement the countdown variable used to decide when to go back to


@@ -2884,7 +2884,7 @@ static void SV_Physics_ClientEntity(prvm_edict_t *ent)
        // make sure the velocity is sane (not a NaN)
        SV_CheckVelocity(ent);
 
        // make sure the velocity is sane (not a NaN)
        SV_CheckVelocity(ent);
 

-       switch ((int) ent->fields.server->movetype)
+       switch ((int) PRVM_serveredictfloat(ent, movetype))

        {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:
        {
        case MOVETYPE_PUSH:
        case MOVETYPE_FAKEPUSH:


@@ -2892,7 +2892,7 @@ static void SV_Physics_ClientEntity(prvm_edict_t *ent)
                break;
        case MOVETYPE_NONE:
                // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects
                break;
        case MOVETYPE_NONE:
                // LordHavoc: manually inlined the thinktime check here because MOVETYPE_NONE is used on so many objects

-               if (ent->fields.server->nextthink > 0 && ent->fields.server->nextthink <= sv.time + sv.frametime)
+               if (PRVM_serveredictfloat(ent, nextthink) > 0 && PRVM_serveredictfloat(ent, nextthink) <= sv.time + sv.frametime)

                        SV_RunThink (ent);
                break;
        case MOVETYPE_FOLLOW:
                        SV_RunThink (ent);
                break;
        case MOVETYPE_FOLLOW:


@@ -2901,8 +2901,8 @@ static void SV_Physics_ClientEntity(prvm_edict_t *ent)
        case MOVETYPE_NOCLIP:
                SV_RunThink(ent);
                SV_CheckWater(ent);
        case MOVETYPE_NOCLIP:
                SV_RunThink(ent);
                SV_CheckWater(ent);

-               VectorMA(ent->fields.server->origin, sv.frametime, ent->fields.server->velocity, ent->fields.server->origin);
-               VectorMA(ent->fields.server->angles, sv.frametime, ent->fields.server->avelocity, ent->fields.server->angles);
+               VectorMA(PRVM_serveredictvector(ent, origin), sv.frametime, PRVM_serveredictvector(ent, velocity), PRVM_serveredictvector(ent, origin));
+               VectorMA(PRVM_serveredictvector(ent, angles), sv.frametime, PRVM_serveredictvector(ent, avelocity), PRVM_serveredictvector(ent, angles));

                break;
        case MOVETYPE_STEP:
                SV_Physics_Step (ent);
                break;
        case MOVETYPE_STEP:
                SV_Physics_Step (ent);


@@ -2929,7 +2929,7 @@ static void SV_Physics_ClientEntity(prvm_edict_t *ent)
                SV_RunThink (ent);
                break;
        default:
                SV_RunThink (ent);
                break;
        default:

-               Con_Printf ("SV_Physics_ClientEntity: bad movetype %i\n", (int)ent->fields.server->movetype);
+               Con_Printf ("SV_Physics_ClientEntity: bad movetype %i\n", (int)PRVM_serveredictfloat(ent, movetype));

                break;
        }
 
                break;
        }
 


@@ -2953,11 +2953,11 @@ void SV_Physics (void)
        prvm_edict_t *ent;
 
 // let the progs know that a new frame has started
        prvm_edict_t *ent;
 
 // let the progs know that a new frame has started

-       prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
-       prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
-       prog->globals.server->time = sv.time;
-       prog->globals.server->frametime = sv.frametime;
-       PRVM_ExecuteProgram (prog->globals.server->StartFrame, "QC function StartFrame is missing");
+       PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
+       PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
+       PRVM_serverglobalfloat(time) = sv.time;
+       PRVM_serverglobalfloat(frametime) = sv.frametime;
+       PRVM_ExecuteProgram (PRVM_serverfunction(StartFrame), "QC function StartFrame is missing");

 
        // run physics engine
        World_Physics_Frame(&sv.world, sv.frametime, sv_gravity.value);
 
        // run physics engine
        World_Physics_Frame(&sv.world, sv.frametime, sv_gravity.value);


@@ -2967,7 +2967,7 @@ void SV_Physics (void)
 //
 
        // if force_retouch, relink all the entities
 //
 
        // if force_retouch, relink all the entities

-       if (prog->globals.server->force_retouch > 0)
+       if (PRVM_serverglobalfloat(force_retouch) > 0)

                for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
                        if (!ent->priv.server->free)
                                SV_LinkEdict_TouchAreaGrid(ent); // force retouch even for stationary
                for (i = 1, ent = PRVM_EDICT_NUM(i);i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
                        if (!ent->priv.server->free)
                                SV_LinkEdict_TouchAreaGrid(ent); // force retouch even for stationary


@@ -3015,15 +3015,15 @@ void SV_Physics (void)
                                        SV_Physics_Entity(ent);
        }
 
                                        SV_Physics_Entity(ent);
        }
 

-       if (prog->globals.server->force_retouch > 0)
-               prog->globals.server->force_retouch = max(0, prog->globals.server->force_retouch - 1);
+       if (PRVM_serverglobalfloat(force_retouch) > 0)
+               PRVM_serverglobalfloat(force_retouch) = max(0, PRVM_serverglobalfloat(force_retouch) - 1);

 
        // LordHavoc: endframe support
        if (PRVM_serverfunction(EndFrame))
        {
 
        // LordHavoc: endframe support
        if (PRVM_serverfunction(EndFrame))
        {

-               prog->globals.server->self = PRVM_EDICT_TO_PROG(prog->edicts);
-               prog->globals.server->other = PRVM_EDICT_TO_PROG(prog->edicts);
-               prog->globals.server->time = sv.time;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(prog->edicts);
+               PRVM_serverglobaledict(other) = PRVM_EDICT_TO_PROG(prog->edicts);
+               PRVM_serverglobalfloat(time) = sv.time;

                PRVM_ExecuteProgram (PRVM_serverfunction(EndFrame), "QC function EndFrame is missing");
        }
 
                PRVM_ExecuteProgram (PRVM_serverfunction(EndFrame), "QC function EndFrame is missing");
        }
 

diff --git a/sv_user.c b/sv_user.c
index 8dec4ecbe91dc3f65a19f87ec413bd079df2907a..7b59de998cae788d0c60b2b9b9536c710ff650d6 100644 (file)
--- a/sv_user.c
+++ b/sv_user.c
@@ -41,18 +41,18 @@ void SV_SetIdealPitch (void)
        int             i, j;
        int             steps;
 
        int             i, j;
        int             steps;
 

-       if (!((int)host_client->edict->fields.server->flags & FL_ONGROUND))
+       if (!((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_ONGROUND))

                return;
 
                return;
 

-       angleval = host_client->edict->fields.server->angles[YAW] * M_PI*2 / 360;
+       angleval = PRVM_serveredictvector(host_client->edict, angles)[YAW] * M_PI*2 / 360;

        sinval = sin(angleval);
        cosval = cos(angleval);
 
        for (i=0 ; i<MAX_FORWARD ; i++)
        {
        sinval = sin(angleval);
        cosval = cos(angleval);
 
        for (i=0 ; i<MAX_FORWARD ; i++)
        {

-               top[0] = host_client->edict->fields.server->origin[0] + cosval*(i+3)*12;
-               top[1] = host_client->edict->fields.server->origin[1] + sinval*(i+3)*12;
-               top[2] = host_client->edict->fields.server->origin[2] + host_client->edict->fields.server->view_ofs[2];
+               top[0] = PRVM_serveredictvector(host_client->edict, origin)[0] + cosval*(i+3)*12;
+               top[1] = PRVM_serveredictvector(host_client->edict, origin)[1] + sinval*(i+3)*12;
+               top[2] = PRVM_serveredictvector(host_client->edict, origin)[2] + PRVM_serveredictvector(host_client->edict, view_ofs)[2];

 
                bottom[0] = top[0];
                bottom[1] = top[1];
 
                bottom[0] = top[0];
                bottom[1] = top[1];


@@ -88,13 +88,13 @@ void SV_SetIdealPitch (void)
 
        if (!dir)
        {
 
        if (!dir)
        {

-               host_client->edict->fields.server->idealpitch = 0;
+               PRVM_serveredictfloat(host_client->edict, idealpitch) = 0;

                return;
        }
 
        if (steps < 2)
                return;
                return;
        }
 
        if (steps < 2)
                return;

-       host_client->edict->fields.server->idealpitch = -dir * sv_idealpitchscale.value;
+       PRVM_serveredictfloat(host_client->edict, idealpitch) = -dir * sv_idealpitchscale.value;

 }
 
 static vec3_t wishdir, forward, right, up;
 }
 
 static vec3_t wishdir, forward, right, up;


@@ -114,14 +114,14 @@ void SV_UserFriction (void)
        vec3_t start, stop;
        trace_t trace;
 
        vec3_t start, stop;
        trace_t trace;
 

-       speed = sqrt(host_client->edict->fields.server->velocity[0]*host_client->edict->fields.server->velocity[0]+host_client->edict->fields.server->velocity[1]*host_client->edict->fields.server->velocity[1]);
+       speed = sqrt(PRVM_serveredictvector(host_client->edict, velocity)[0]*PRVM_serveredictvector(host_client->edict, velocity)[0]+PRVM_serveredictvector(host_client->edict, velocity)[1]*PRVM_serveredictvector(host_client->edict, velocity)[1]);

        if (!speed)
                return;
 
        // if the leading edge is over a dropoff, increase friction
        if (!speed)
                return;
 
        // if the leading edge is over a dropoff, increase friction

-       start[0] = stop[0] = host_client->edict->fields.server->origin[0] + host_client->edict->fields.server->velocity[0]/speed*16;
-       start[1] = stop[1] = host_client->edict->fields.server->origin[1] + host_client->edict->fields.server->velocity[1]/speed*16;
-       start[2] = host_client->edict->fields.server->origin[2] + host_client->edict->fields.server->mins[2];
+       start[0] = stop[0] = PRVM_serveredictvector(host_client->edict, origin)[0] + PRVM_serveredictvector(host_client->edict, velocity)[0]/speed*16;
+       start[1] = stop[1] = PRVM_serveredictvector(host_client->edict, origin)[1] + PRVM_serveredictvector(host_client->edict, velocity)[1]/speed*16;
+       start[2] = PRVM_serveredictvector(host_client->edict, origin)[2] + PRVM_serveredictvector(host_client->edict, mins)[2];

        stop[2] = start[2] - 34;
 
        trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, host_client->edict, SV_GenericHitSuperContentsMask(host_client->edict));
        stop[2] = start[2] - 34;
 
        trace = SV_TraceLine(start, stop, MOVE_NOMONSTERS, host_client->edict, SV_GenericHitSuperContentsMask(host_client->edict));


@@ -140,7 +140,7 @@ void SV_UserFriction (void)
        else
                newspeed /= speed;
 
        else
                newspeed /= speed;
 

-       VectorScale(host_client->edict->fields.server->velocity, newspeed, host_client->edict->fields.server->velocity);
+       VectorScale(PRVM_serveredictvector(host_client->edict, velocity), newspeed, PRVM_serveredictvector(host_client->edict, velocity));

 }
 
 /*
 }
 
 /*


@@ -153,7 +153,7 @@ void SV_Accelerate (void)
        int i;
        float addspeed, accelspeed, currentspeed;
 
        int i;
        float addspeed, accelspeed, currentspeed;
 

-       currentspeed = DotProduct (host_client->edict->fields.server->velocity, wishdir);
+       currentspeed = DotProduct (PRVM_serveredictvector(host_client->edict, velocity), wishdir);

        addspeed = wishspeed - currentspeed;
        if (addspeed <= 0)
                return;
        addspeed = wishspeed - currentspeed;
        if (addspeed <= 0)
                return;


@@ -162,7 +162,7 @@ void SV_Accelerate (void)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)

-               host_client->edict->fields.server->velocity[i] += accelspeed*wishdir[i];
+               PRVM_serveredictvector(host_client->edict, velocity)[i] += accelspeed*wishdir[i];

 }
 
 extern cvar_t sv_gameplayfix_q2airaccelerate;
 }
 
 extern cvar_t sv_gameplayfix_q2airaccelerate;


@@ -174,7 +174,7 @@ void SV_AirAccelerate (vec3_t wishveloc)
        wishspd = VectorNormalizeLength (wishveloc);
        if (wishspd > sv_maxairspeed.value)
                wishspd = sv_maxairspeed.value;
        wishspd = VectorNormalizeLength (wishveloc);
        if (wishspd > sv_maxairspeed.value)
                wishspd = sv_maxairspeed.value;

-       currentspeed = DotProduct (host_client->edict->fields.server->velocity, wishveloc);
+       currentspeed = DotProduct (PRVM_serveredictvector(host_client->edict, velocity), wishveloc);

        addspeed = wishspd - currentspeed;
        if (addspeed <= 0)
                return;
        addspeed = wishspd - currentspeed;
        if (addspeed <= 0)
                return;


@@ -183,7 +183,7 @@ void SV_AirAccelerate (vec3_t wishveloc)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)

-               host_client->edict->fields.server->velocity[i] += accelspeed*wishveloc[i];
+               PRVM_serveredictvector(host_client->edict, velocity)[i] += accelspeed*wishveloc[i];

 }
 
 
 }
 
 


@@ -192,12 +192,12 @@ void DropPunchAngle (void)
        float len;
        vec3_t v;
 
        float len;
        vec3_t v;
 

-       len = VectorNormalizeLength (host_client->edict->fields.server->punchangle);
+       len = VectorNormalizeLength (PRVM_serveredictvector(host_client->edict, punchangle));

 
        len -= 10*sv.frametime;
        if (len < 0)
                len = 0;
 
        len -= 10*sv.frametime;
        if (len < 0)
                len = 0;

-       VectorScale (host_client->edict->fields.server->punchangle, len, host_client->edict->fields.server->punchangle);
+       VectorScale (PRVM_serveredictvector(host_client->edict, punchangle), len, PRVM_serveredictvector(host_client->edict, punchangle));

 
        VectorCopy(PRVM_serveredictvector(host_client->edict, punchvector), v);
        len = VectorNormalizeLength(v);
 
        VectorCopy(PRVM_serveredictvector(host_client->edict, punchvector), v);
        len = VectorNormalizeLength(v);


@@ -221,16 +221,16 @@ void SV_FreeMove (void)
        int i;
        float wishspeed;
 
        int i;
        float wishspeed;
 

-       AngleVectors (host_client->edict->fields.server->v_angle, forward, right, up);
+       AngleVectors (PRVM_serveredictvector(host_client->edict, v_angle), forward, right, up);

 
        for (i = 0; i < 3; i++)
 
        for (i = 0; i < 3; i++)

-               host_client->edict->fields.server->velocity[i] = forward[i] * cmd.forwardmove + right[i] * cmd.sidemove;
+               PRVM_serveredictvector(host_client->edict, velocity)[i] = forward[i] * cmd.forwardmove + right[i] * cmd.sidemove;

 
 

-       host_client->edict->fields.server->velocity[2] += cmd.upmove;
+       PRVM_serveredictvector(host_client->edict, velocity)[2] += cmd.upmove;

 
 

-       wishspeed = VectorLength(host_client->edict->fields.server->velocity);
+       wishspeed = VectorLength(PRVM_serveredictvector(host_client->edict, velocity));

        if (wishspeed > sv_maxspeed.value)
        if (wishspeed > sv_maxspeed.value)

-               VectorScale(host_client->edict->fields.server->velocity, sv_maxspeed.value / wishspeed, host_client->edict->fields.server->velocity);
+               VectorScale(PRVM_serveredictvector(host_client->edict, velocity), sv_maxspeed.value / wishspeed, PRVM_serveredictvector(host_client->edict, velocity));

 }
 
 /*
 }
 
 /*


@@ -246,7 +246,7 @@ void SV_WaterMove (void)
        float speed, newspeed, wishspeed, addspeed, accelspeed, temp;
 
        // user intentions
        float speed, newspeed, wishspeed, addspeed, accelspeed, temp;
 
        // user intentions

-       AngleVectors (host_client->edict->fields.server->v_angle, forward, right, up);
+       AngleVectors (PRVM_serveredictvector(host_client->edict, v_angle), forward, right, up);

 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*cmd.forwardmove + right[i]*cmd.sidemove;
 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*cmd.forwardmove + right[i]*cmd.sidemove;


@@ -266,14 +266,14 @@ void SV_WaterMove (void)
        wishspeed *= 0.7;
 
        // water friction
        wishspeed *= 0.7;
 
        // water friction

-       speed = VectorLength(host_client->edict->fields.server->velocity);
+       speed = VectorLength(PRVM_serveredictvector(host_client->edict, velocity));

        if (speed)
        {
                newspeed = speed - sv.frametime * speed * (sv_waterfriction.value < 0 ? sv_friction.value : sv_waterfriction.value);
                if (newspeed < 0)
                        newspeed = 0;
                temp = newspeed/speed;
        if (speed)
        {
                newspeed = speed - sv.frametime * speed * (sv_waterfriction.value < 0 ? sv_friction.value : sv_waterfriction.value);
                if (newspeed < 0)
                        newspeed = 0;
                temp = newspeed/speed;

-               VectorScale(host_client->edict->fields.server->velocity, temp, host_client->edict->fields.server->velocity);
+               VectorScale(PRVM_serveredictvector(host_client->edict, velocity), temp, PRVM_serveredictvector(host_client->edict, velocity));

        }
        else
                newspeed = 0;
        }
        else
                newspeed = 0;


@@ -292,18 +292,18 @@ void SV_WaterMove (void)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)

-               host_client->edict->fields.server->velocity[i] += accelspeed * wishvel[i];
+               PRVM_serveredictvector(host_client->edict, velocity)[i] += accelspeed * wishvel[i];

 }
 
 void SV_WaterJump (void)
 {
 }
 
 void SV_WaterJump (void)
 {

-       if (sv.time > host_client->edict->fields.server->teleport_time || !host_client->edict->fields.server->waterlevel)
+       if (sv.time > PRVM_serveredictfloat(host_client->edict, teleport_time) || !PRVM_serveredictfloat(host_client->edict, waterlevel))

        {
        {

-               host_client->edict->fields.server->flags = (int)host_client->edict->fields.server->flags & ~FL_WATERJUMP;
-               host_client->edict->fields.server->teleport_time = 0;
+               PRVM_serveredictfloat(host_client->edict, flags) = (int)PRVM_serveredictfloat(host_client->edict, flags) & ~FL_WATERJUMP;
+               PRVM_serveredictfloat(host_client->edict, teleport_time) = 0;

        }
        }

-       host_client->edict->fields.server->velocity[0] = host_client->edict->fields.server->movedir[0];
-       host_client->edict->fields.server->velocity[1] = host_client->edict->fields.server->movedir[1];
+       PRVM_serveredictvector(host_client->edict, velocity)[0] = PRVM_serveredictvector(host_client->edict, movedir)[0];
+       PRVM_serveredictvector(host_client->edict, velocity)[1] = PRVM_serveredictvector(host_client->edict, movedir)[1];

 }
 
 
 }
 
 


@@ -321,20 +321,20 @@ void SV_AirMove (void)
 
        // LordHavoc: correct quake movement speed bug when looking up/down
        wishvel[0] = wishvel[2] = 0;
 
        // LordHavoc: correct quake movement speed bug when looking up/down
        wishvel[0] = wishvel[2] = 0;

-       wishvel[1] = host_client->edict->fields.server->angles[1];
+       wishvel[1] = PRVM_serveredictvector(host_client->edict, angles)[1];

        AngleVectors (wishvel, forward, right, up);
 
        fmove = cmd.forwardmove;
        smove = cmd.sidemove;
 
 // hack to not let you back into teleporter
        AngleVectors (wishvel, forward, right, up);
 
        fmove = cmd.forwardmove;
        smove = cmd.sidemove;
 
 // hack to not let you back into teleporter

-       if (sv.time < host_client->edict->fields.server->teleport_time && fmove < 0)
+       if (sv.time < PRVM_serveredictfloat(host_client->edict, teleport_time) && fmove < 0)

                fmove = 0;
 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*fmove + right[i]*smove;
 
                fmove = 0;
 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*fmove + right[i]*smove;
 

-       if ((int)host_client->edict->fields.server->movetype != MOVETYPE_WALK)
+       if ((int)PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_WALK)

                wishvel[2] += cmd.upmove;
 
        VectorCopy (wishvel, wishdir);
                wishvel[2] += cmd.upmove;
 
        VectorCopy (wishvel, wishdir);


@@ -346,10 +346,10 @@ void SV_AirMove (void)
                wishspeed = sv_maxspeed.value;
        }
 
                wishspeed = sv_maxspeed.value;
        }
 

-       if (host_client->edict->fields.server->movetype == MOVETYPE_NOCLIP)
+       if (PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_NOCLIP)

        {
                // noclip
        {
                // noclip

-               VectorCopy (wishvel, host_client->edict->fields.server->velocity);
+               VectorCopy (wishvel, PRVM_serveredictvector(host_client->edict, velocity));

        }
        else if (onground)
        {
        }
        else if (onground)
        {


@@ -384,37 +384,37 @@ void SV_ClientThink (void)
        // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
        if (PRVM_serverfunction(SV_PlayerPhysics) && sv_playerphysicsqc.integer)
        {
        // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
        if (PRVM_serverfunction(SV_PlayerPhysics) && sv_playerphysicsqc.integer)
        {

-               prog->globals.server->time = sv.time;
-               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_serverglobalfloat(time) = sv.time;
+               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);

                PRVM_ExecuteProgram (PRVM_serverfunction(SV_PlayerPhysics), "QC function SV_PlayerPhysics is missing");
                SV_CheckVelocity(host_client->edict);
                return;
        }
 
                PRVM_ExecuteProgram (PRVM_serverfunction(SV_PlayerPhysics), "QC function SV_PlayerPhysics is missing");
                SV_CheckVelocity(host_client->edict);
                return;
        }
 

-       if (host_client->edict->fields.server->movetype == MOVETYPE_NONE)
+       if (PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_NONE)

                return;
 
                return;
 

-       onground = ((int)host_client->edict->fields.server->flags & FL_ONGROUND) != 0;
+       onground = ((int)PRVM_serveredictfloat(host_client->edict, flags) & FL_ONGROUND) != 0;

 
        DropPunchAngle ();
 
        // if dead, behave differently
 
        DropPunchAngle ();
 
        // if dead, behave differently

-       if (host_client->edict->fields.server->health <= 0)
+       if (PRVM_serveredictfloat(host_client->edict, health) <= 0)

                return;
 
        cmd = host_client->cmd;
 
        // angles
        // show 1/3 the pitch angle and all the roll angle
                return;
 
        cmd = host_client->cmd;
 
        // angles
        // show 1/3 the pitch angle and all the roll angle

-       VectorAdd (host_client->edict->fields.server->v_angle, host_client->edict->fields.server->punchangle, v_angle);
-       host_client->edict->fields.server->angles[ROLL] = V_CalcRoll (host_client->edict->fields.server->angles, host_client->edict->fields.server->velocity)*4;
-       if (!host_client->edict->fields.server->fixangle)
+       VectorAdd (PRVM_serveredictvector(host_client->edict, v_angle), PRVM_serveredictvector(host_client->edict, punchangle), v_angle);
+       PRVM_serveredictvector(host_client->edict, angles)[ROLL] = V_CalcRoll (PRVM_serveredictvector(host_client->edict, angles), PRVM_serveredictvector(host_client->edict, velocity))*4;
+       if (!PRVM_serveredictfloat(host_client->edict, fixangle))

        {
        {

-               host_client->edict->fields.server->angles[PITCH] = -v_angle[PITCH]/3;
-               host_client->edict->fields.server->angles[YAW] = v_angle[YAW];
+               PRVM_serveredictvector(host_client->edict, angles)[PITCH] = -v_angle[PITCH]/3;
+               PRVM_serveredictvector(host_client->edict, angles)[YAW] = v_angle[YAW];

        }
 
        }
 

-       if ( (int)host_client->edict->fields.server->flags & FL_WATERJUMP )
+       if ( (int)PRVM_serveredictfloat(host_client->edict, flags) & FL_WATERJUMP )

        {
                SV_WaterJump ();
                SV_CheckVelocity(host_client->edict);
        {
                SV_WaterJump ();
                SV_CheckVelocity(host_client->edict);


@@ -423,8 +423,8 @@ void SV_ClientThink (void)
 
        /*
        // Player is (somehow) outside of the map, or flying, or noclipping
 
        /*
        // Player is (somehow) outside of the map, or flying, or noclipping

-       if (host_client->edict->fields.server->movetype != MOVETYPE_NOCLIP && (host_client->edict->fields.server->movetype == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict)))
-       //if (host_client->edict->fields.server->movetype == MOVETYPE_NOCLIP || host_client->edict->fields.server->movetype == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict))
+       if (PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_NOCLIP && (PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict)))
+       //if (PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_NOCLIP || PRVM_serveredictfloat(host_client->edict, movetype) == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict))

        {
                SV_FreeMove ();
                return;
        {
                SV_FreeMove ();
                return;


@@ -432,7 +432,7 @@ void SV_ClientThink (void)
        */
 
        // walk
        */
 
        // walk

-       if ((host_client->edict->fields.server->waterlevel >= 2) && (host_client->edict->fields.server->movetype != MOVETYPE_NOCLIP))
+       if ((PRVM_serveredictfloat(host_client->edict, waterlevel) >= 2) && (PRVM_serveredictfloat(host_client->edict, movetype) != MOVETYPE_NOCLIP))

        {
                SV_WaterMove ();
                SV_CheckVelocity(host_client->edict);
        {
                SV_WaterMove ();
                SV_CheckVelocity(host_client->edict);


@@ -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_serveredictfloat(host_client->edict, disableclientprediction)))
+       if (sv_readmoves[sv_numreadmoves-1].sequence && sv_clmovement_enable.integer && sv_clmovement_inputtimeout.value > 0 && host_client->clmovement_disabletimeout <= realtime && PRVM_serveredictfloat(host_client->edict, 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


@@ -646,21 +646,21 @@ void SV_ExecuteClientMoves(void)
                                //  determined by the sv_clmovement_inputtimeout cvar)
                                if (moveframetime <= 0)
                                        continue;
                                //  determined by the sv_clmovement_inputtimeout cvar)
                                if (moveframetime <= 0)
                                        continue;

-                               oldframetime = prog->globals.server->frametime;
+                               oldframetime = PRVM_serverglobalfloat(frametime);

                                oldframetime2 = sv.frametime;
                                // update ping time for qc to see while executing this move
                                host_client->ping = host_client->cmd.receivetime - host_client->cmd.time;
                                // the server and qc frametime values must be changed temporarily
                                oldframetime2 = sv.frametime;
                                // update ping time for qc to see while executing this move
                                host_client->ping = host_client->cmd.receivetime - host_client->cmd.time;
                                // the server and qc frametime values must be changed temporarily

-                               prog->globals.server->frametime = sv.frametime = moveframetime;
+                               PRVM_serverglobalfloat(frametime) = sv.frametime = moveframetime;

                                // if move is more than 50ms, split it into two moves (this matches QWSV behavior and the client prediction)
                                if (sv.frametime > 0.05)
                                {
                                // if move is more than 50ms, split it into two moves (this matches QWSV behavior and the client prediction)
                                if (sv.frametime > 0.05)
                                {

-                                       prog->globals.server->frametime = sv.frametime = moveframetime * 0.5f;
+                                       PRVM_serverglobalfloat(frametime) = sv.frametime = moveframetime * 0.5f;

                                        SV_Physics_ClientMove();
                                }
                                SV_Physics_ClientMove();
                                sv.frametime = oldframetime2;
                                        SV_Physics_ClientMove();
                                }
                                SV_Physics_ClientMove();
                                sv.frametime = oldframetime2;

-                               prog->globals.server->frametime = oldframetime;
+                               PRVM_serverglobalfloat(frametime) = oldframetime;

                                host_client->clmovement_inputtimeout = sv_clmovement_inputtimeout.value;
                        }
                }
                                host_client->clmovement_inputtimeout = sv_clmovement_inputtimeout.value;
                        }
                }


@@ -719,10 +719,10 @@ void SV_ApplyClientMove (void)
        move->applied = true;
 
        // set the edict fields
        move->applied = true;
 
        // set the edict fields

-       host_client->edict->fields.server->button0 = move->buttons & 1;
-       host_client->edict->fields.server->button2 = (move->buttons & 2)>>1;
+       PRVM_serveredictfloat(host_client->edict, button0) = move->buttons & 1;
+       PRVM_serveredictfloat(host_client->edict, button2) = (move->buttons & 2)>>1;

        if (move->impulse)
        if (move->impulse)

-               host_client->edict->fields.server->impulse = move->impulse;
+               PRVM_serveredictfloat(host_client->edict, impulse) = move->impulse;

        // only send the impulse to qc once
        move->impulse = 0;
 
        // only send the impulse to qc once
        move->impulse = 0;
 


@@ -737,7 +737,7 @@ void SV_ApplyClientMove (void)
                                movementloss++;
        }
 
                                movementloss++;
        }
 

-       VectorCopy(move->viewangles, host_client->edict->fields.server->v_angle);
+       VectorCopy(move->viewangles, PRVM_serveredictvector(host_client->edict, v_angle));

        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, 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);


@@ -868,7 +868,7 @@ void SV_ReadClientMessage(void)
                                int restorevm_tempstringsbuf_cursize;
                                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(s);
                                int restorevm_tempstringsbuf_cursize;
                                restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
                                PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(s);

-                               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+                               PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(host_client->edict);

                                PRVM_ExecuteProgram (PRVM_serverfunction(SV_ParseClientCommand), "QC function SV_ParseClientCommand is missing");
                                vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
                        }
                                PRVM_ExecuteProgram (PRVM_serverfunction(SV_ParseClientCommand), "QC function SV_ParseClientCommand is missing");
                                vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
                        }

diff --git a/svvm_cmds.c b/svvm_cmds.c
index fc7feddee325e56c5ef490394840c1e5d2646a78..243978e6e576c5bfbb5f1ee23420232f5380d7f6 100644 (file)
--- a/svvm_cmds.c
+++ b/svvm_cmds.c
@@ -242,7 +242,7 @@ static void VM_SV_setorigin (void)
                return;
        }
        org = PRVM_G_VECTOR(OFS_PARM1);
                return;
        }
        org = PRVM_G_VECTOR(OFS_PARM1);

-       VectorCopy (org, e->fields.server->origin);
+       VectorCopy (org, PRVM_serveredictvector(e, origin));

        SV_LinkEdict(e);
 }
 
        SV_LinkEdict(e);
 }
 


@@ -256,9 +256,9 @@ static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max, qboolean rot
                        PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
 
 // set derived values
                        PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
 
 // set derived values

-       VectorCopy (min, e->fields.server->mins);
-       VectorCopy (max, e->fields.server->maxs);
-       VectorSubtract (max, min, e->fields.server->size);
+       VectorCopy (min, PRVM_serveredictvector(e, mins));
+       VectorCopy (max, PRVM_serveredictvector(e, maxs));
+       VectorSubtract (max, min, PRVM_serveredictvector(e, size));

 
        SV_LinkEdict(e);
 }
 
        SV_LinkEdict(e);
 }


@@ -325,8 +325,8 @@ static void VM_SV_setmodel (void)
                return;
        }
        i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
                return;
        }
        i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);

-       e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
-       e->fields.server->modelindex = i;
+       PRVM_serveredictstring(e, model) = PRVM_SetEngineString(sv.model_precache[i]);
+       PRVM_serveredictfloat(e, modelindex) = i;

 
        mod = SV_GetModelByIndex(i);
 
 
        mod = SV_GetModelByIndex(i);
 


@@ -669,10 +669,10 @@ static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
        vec3_t original_avelocity;
        trace_t trace;
 
        vec3_t original_avelocity;
        trace_t trace;
 

-       VectorCopy(tossent->fields.server->origin   , original_origin   );
-       VectorCopy(tossent->fields.server->velocity , original_velocity );
-       VectorCopy(tossent->fields.server->angles   , original_angles   );
-       VectorCopy(tossent->fields.server->avelocity, original_avelocity);
+       VectorCopy(PRVM_serveredictvector(tossent, origin)   , original_origin   );
+       VectorCopy(PRVM_serveredictvector(tossent, velocity) , original_velocity );
+       VectorCopy(PRVM_serveredictvector(tossent, angles)   , original_angles   );
+       VectorCopy(PRVM_serveredictvector(tossent, avelocity), original_avelocity);

 
        gravity = PRVM_serveredictfloat(tossent, gravity);
        if (!gravity)
 
        gravity = PRVM_serveredictfloat(tossent, gravity);
        if (!gravity)


@@ -682,22 +682,22 @@ static trace_t SV_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore)
        for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
        {
                SV_CheckVelocity (tossent);
        for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
        {
                SV_CheckVelocity (tossent);

-               tossent->fields.server->velocity[2] -= gravity;
-               VectorMA (tossent->fields.server->angles, 0.05, tossent->fields.server->avelocity, tossent->fields.server->angles);
-               VectorScale (tossent->fields.server->velocity, 0.05, move);
-               VectorAdd (tossent->fields.server->origin, move, end);
-               trace = SV_TraceBox(tossent->fields.server->origin, tossent->fields.server->mins, tossent->fields.server->maxs, end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent));
-               VectorCopy (trace.endpos, tossent->fields.server->origin);
-               tossent->fields.server->velocity[2] -= gravity;
+               PRVM_serveredictvector(tossent, velocity)[2] -= gravity;
+               VectorMA (PRVM_serveredictvector(tossent, angles), 0.05, PRVM_serveredictvector(tossent, avelocity), PRVM_serveredictvector(tossent, angles));
+               VectorScale (PRVM_serveredictvector(tossent, velocity), 0.05, move);
+               VectorAdd (PRVM_serveredictvector(tossent, origin), move, end);
+               trace = SV_TraceBox(PRVM_serveredictvector(tossent, origin), PRVM_serveredictvector(tossent, mins), PRVM_serveredictvector(tossent, maxs), end, MOVE_NORMAL, tossent, SV_GenericHitSuperContentsMask(tossent));
+               VectorCopy (trace.endpos, PRVM_serveredictvector(tossent, origin));
+               PRVM_serveredictvector(tossent, velocity)[2] -= gravity;

 
                if (trace.fraction < 1)
                        break;
        }
 
 
                if (trace.fraction < 1)
                        break;
        }
 

-       VectorCopy(original_origin   , tossent->fields.server->origin   );
-       VectorCopy(original_velocity , tossent->fields.server->velocity );
-       VectorCopy(original_angles   , tossent->fields.server->angles   );
-       VectorCopy(original_avelocity, tossent->fields.server->avelocity);
+       VectorCopy(original_origin   , PRVM_serveredictvector(tossent, origin)   );
+       VectorCopy(original_velocity , PRVM_serveredictvector(tossent, velocity) );
+       VectorCopy(original_angles   , PRVM_serveredictvector(tossent, angles)   );
+       VectorCopy(original_avelocity, PRVM_serveredictvector(tossent, avelocity));

 
        return trace;
 }
 
        return trace;
 }


@@ -754,14 +754,14 @@ static int VM_SV_newcheckclient (int check)
                // look up the client's edict
                ent = PRVM_EDICT_NUM(i);
                // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)
                // look up the client's edict
                ent = PRVM_EDICT_NUM(i);
                // check if it is to be ignored, but never ignore the one we started on (prevent infinite loop)

-               if (i != check && (ent->priv.server->free || ent->fields.server->health <= 0 || ((int)ent->fields.server->flags & FL_NOTARGET)))
+               if (i != check && (ent->priv.server->free || PRVM_serveredictfloat(ent, health) <= 0 || ((int)PRVM_serveredictfloat(ent, flags) & FL_NOTARGET)))

                        continue;
                // found a valid client (possibly the same one again)
                break;
        }
 
 // get the PVS for the entity
                        continue;
                // found a valid client (possibly the same one again)
                break;
        }
 
 // get the PVS for the entity

-       VectorAdd(ent->fields.server->origin, ent->fields.server->view_ofs, org);
+       VectorAdd(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, view_ofs), org);

        checkpvsbytes = 0;
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
                checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);
        checkpvsbytes = 0;
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
                checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs), false);


@@ -801,15 +801,15 @@ static void VM_SV_checkclient (void)
 
        // return check if it might be visible
        ent = PRVM_EDICT_NUM(sv.lastcheck);
 
        // return check if it might be visible
        ent = PRVM_EDICT_NUM(sv.lastcheck);

-       if (ent->priv.server->free || ent->fields.server->health <= 0)
+       if (ent->priv.server->free || PRVM_serveredictfloat(ent, health) <= 0)

        {
                VM_RETURN_EDICT(prog->edicts);
                return;
        }
 
        // if current entity can't possibly see the check entity, return 0
        {
                VM_RETURN_EDICT(prog->edicts);
                return;
        }
 
        // if current entity can't possibly see the check entity, return 0

-       self = PRVM_PROG_TO_EDICT(prog->globals.server->self);
-       VectorAdd(self->fields.server->origin, self->fields.server->view_ofs, view);
+       self = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));
+       VectorAdd(PRVM_serveredictvector(self, origin), PRVM_serveredictvector(self, view_ofs), view);

        if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
        {
                c_notvis++;
        if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
        {
                c_notvis++;


@@ -870,7 +870,7 @@ static void VM_SV_checkpvs (void)
                PRVM_G_FLOAT(OFS_RETURN) = 2;
                return;
        }
                PRVM_G_FLOAT(OFS_RETURN) = 2;
                return;
        }

-       PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, viewee->fields.server->absmin, viewee->fields.server->absmax);
+       PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, PRVM_serveredictvector(viewee, absmin), PRVM_serveredictvector(viewee, absmax));

 #else
        // using fat PVS like FTEQW does (slow)
        if(!sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)
 #else
        // using fat PVS like FTEQW does (slow)
        if(!sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)


@@ -886,7 +886,7 @@ static void VM_SV_checkpvs (void)
                PRVM_G_FLOAT(OFS_RETURN) = 2;
                return;
        }
                PRVM_G_FLOAT(OFS_RETURN) = 2;
                return;
        }

-       PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, viewee->fields.server->absmin, viewee->fields.server->absmax);
+       PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, PRVM_serveredictvector(viewee, absmin), PRVM_serveredictvector(viewee, absmax));

 #endif
 }
 
 #endif
 }
 


@@ -976,20 +976,20 @@ static void VM_SV_findradius (void)
                prog->xfunction->builtinsprofile++;
                // Quake did not return non-solid entities but darkplaces does
                // (note: this is the reason you can't blow up fallen zombies)
                prog->xfunction->builtinsprofile++;
                // Quake did not return non-solid entities but darkplaces does
                // (note: this is the reason you can't blow up fallen zombies)

-               if (ent->fields.server->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
+               if (PRVM_serveredictfloat(ent, solid) == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)

                        continue;
                // LordHavoc: compare against bounding box rather than center so it
                // doesn't miss large objects, and use DotProduct instead of Length
                // for a major speedup
                        continue;
                // LordHavoc: compare against bounding box rather than center so it
                // doesn't miss large objects, and use DotProduct instead of Length
                // for a major speedup

-               VectorSubtract(org, ent->fields.server->origin, eorg);
+               VectorSubtract(org, PRVM_serveredictvector(ent, origin), eorg);

                if (sv_gameplayfix_findradiusdistancetobox.integer)
                {
                if (sv_gameplayfix_findradiusdistancetobox.integer)
                {

-                       eorg[0] -= bound(ent->fields.server->mins[0], eorg[0], ent->fields.server->maxs[0]);
-                       eorg[1] -= bound(ent->fields.server->mins[1], eorg[1], ent->fields.server->maxs[1]);
-                       eorg[2] -= bound(ent->fields.server->mins[2], eorg[2], ent->fields.server->maxs[2]);
+                       eorg[0] -= bound(PRVM_serveredictvector(ent, mins)[0], eorg[0], PRVM_serveredictvector(ent, maxs)[0]);
+                       eorg[1] -= bound(PRVM_serveredictvector(ent, mins)[1], eorg[1], PRVM_serveredictvector(ent, maxs)[1]);
+                       eorg[2] -= bound(PRVM_serveredictvector(ent, mins)[2], eorg[2], PRVM_serveredictvector(ent, maxs)[2]);

                }
                else
                }
                else

-                       VectorMAMAM(1, eorg, -0.5f, ent->fields.server->mins, -0.5f, ent->fields.server->maxs, eorg);
+                       VectorMAMAM(1, eorg, -0.5f, PRVM_serveredictvector(ent, mins), -0.5f, PRVM_serveredictvector(ent, maxs), eorg);

                if (DotProduct(eorg, eorg) < radius2)
                {
                        PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_EDICT_TO_PROG(chain);
                if (DotProduct(eorg, eorg) < radius2)
                {
                        PRVM_EDICTFIELDEDICT(ent,chainfield) = PRVM_EDICT_TO_PROG(chain);


@@ -1034,7 +1034,7 @@ static void VM_SV_walkmove (void)
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 

-       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));

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


@@ -1049,7 +1049,7 @@ static void VM_SV_walkmove (void)
        dist = PRVM_G_FLOAT(OFS_PARM1);
        settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
 
        dist = PRVM_G_FLOAT(OFS_PARM1);
        settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
 

-       if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
+       if ( !( (int)PRVM_serveredictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )

                return;
 
        yaw = yaw*M_PI*2 / 360;
                return;
 
        yaw = yaw*M_PI*2 / 360;


@@ -1060,14 +1060,14 @@ static void VM_SV_walkmove (void)
 
 // save program state, because SV_movestep may call other progs
        oldf = prog->xfunction;
 
 // save program state, because SV_movestep may call other progs
        oldf = prog->xfunction;

-       oldself = prog->globals.server->self;
+       oldself = PRVM_serverglobaledict(self);

 
        PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
 
 
 // restore program state
        prog->xfunction = oldf;
 
        PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true, false, settrace);
 
 
 // restore program state
        prog->xfunction = oldf;

-       prog->globals.server->self = oldself;
+       PRVM_serverglobaledict(self) = oldself;

 }
 
 /*
 }
 
 /*


@@ -1088,7 +1088,7 @@ static void VM_SV_droptofloor (void)
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 
        // assume failure if it returns early
        PRVM_G_FLOAT(OFS_RETURN) = 0;
 

-       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));

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


@@ -1100,37 +1100,37 @@ static void VM_SV_droptofloor (void)
                return;
        }
 
                return;
        }
 

-       VectorCopy (ent->fields.server->origin, end);
+       VectorCopy (PRVM_serveredictvector(ent, origin), end);

        end[2] -= 256;
 
        if (sv_gameplayfix_droptofloorstartsolid_nudgetocorrect.integer)
                SV_UnstickEntity(ent);
 
        end[2] -= 256;
 
        if (sv_gameplayfix_droptofloorstartsolid_nudgetocorrect.integer)
                SV_UnstickEntity(ent);
 

-       trace = SV_TraceBox(ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
+       trace = SV_TraceBox(PRVM_serveredictvector(ent, origin), PRVM_serveredictvector(ent, mins), PRVM_serveredictvector(ent, maxs), end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));

        if (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer)
        {
                vec3_t offset, org;
        if (trace.startsolid && sv_gameplayfix_droptofloorstartsolid.integer)
        {
                vec3_t offset, org;

-               VectorSet(offset, 0.5f * (ent->fields.server->mins[0] + ent->fields.server->maxs[0]), 0.5f * (ent->fields.server->mins[1] + ent->fields.server->maxs[1]), ent->fields.server->mins[2]);
-               VectorAdd(ent->fields.server->origin, offset, org);
+               VectorSet(offset, 0.5f * (PRVM_serveredictvector(ent, mins)[0] + PRVM_serveredictvector(ent, maxs)[0]), 0.5f * (PRVM_serveredictvector(ent, mins)[1] + PRVM_serveredictvector(ent, maxs)[1]), PRVM_serveredictvector(ent, mins)[2]);
+               VectorAdd(PRVM_serveredictvector(ent, origin), offset, org);

                trace = SV_TraceLine(org, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
                VectorSubtract(trace.endpos, offset, trace.endpos);
                if (trace.startsolid)
                {
                trace = SV_TraceLine(org, end, MOVE_NORMAL, ent, SV_GenericHitSuperContentsMask(ent));
                VectorSubtract(trace.endpos, offset, trace.endpos);
                if (trace.startsolid)
                {

-                       Con_DPrintf("droptofloor at %f %f %f - COULD NOT FIX BADLY PLACED ENTITY\n", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
+                       Con_DPrintf("droptofloor at %f %f %f - COULD NOT FIX BADLY PLACED ENTITY\n", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);

                        SV_UnstickEntity(ent);
                        SV_LinkEdict(ent);
                        SV_UnstickEntity(ent);
                        SV_LinkEdict(ent);

-                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                       ent->fields.server->groundentity = 0;
+                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                       PRVM_serveredictedict(ent, groundentity) = 0;

                        PRVM_G_FLOAT(OFS_RETURN) = 1;
                }
                else if (trace.fraction < 1)
                {
                        PRVM_G_FLOAT(OFS_RETURN) = 1;
                }
                else if (trace.fraction < 1)
                {

-                       Con_DPrintf("droptofloor at %f %f %f - FIXED BADLY PLACED ENTITY\n", ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2]);
-                       VectorCopy (trace.endpos, ent->fields.server->origin);
+                       Con_DPrintf("droptofloor at %f %f %f - FIXED BADLY PLACED ENTITY\n", PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2]);
+                       VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));

                        SV_UnstickEntity(ent);
                        SV_LinkEdict(ent);
                        SV_UnstickEntity(ent);
                        SV_LinkEdict(ent);

-                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                       PRVM_serveredictedict(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;


@@ -1141,10 +1141,10 @@ static void VM_SV_droptofloor (void)
                if (trace.fraction != 1)
                {
                        if (trace.fraction < 1)
                if (trace.fraction != 1)
                {
                        if (trace.fraction < 1)

-                               VectorCopy (trace.endpos, ent->fields.server->origin);
+                               VectorCopy (trace.endpos, PRVM_serveredictvector(ent, origin));

                        SV_LinkEdict(ent);
                        SV_LinkEdict(ent);

-                       ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
-                       ent->fields.server->groundentity = PRVM_EDICT_TO_PROG(trace.ent);
+                       PRVM_serveredictfloat(ent, flags) = (int)PRVM_serveredictfloat(ent, flags) | FL_ONGROUND;
+                       PRVM_serveredictedict(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;


@@ -1235,7 +1235,7 @@ static void VM_SV_aim (void)
        VM_SAFEPARMCOUNT(2, VM_SV_aim);
 
        // assume failure if it returns early
        VM_SAFEPARMCOUNT(2, VM_SV_aim);
 
        // assume failure if it returns early

-       VectorCopy(prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
+       VectorCopy(PRVM_serverglobalvector(v_forward), PRVM_G_VECTOR(OFS_RETURN));

        // if sv_aim is so high it can't possibly accept anything, skip out early
        if (sv_aim.value >= 1)
                return;
        // if sv_aim is so high it can't possibly accept anything, skip out early
        if (sv_aim.value >= 1)
                return;


@@ -1253,17 +1253,17 @@ static void VM_SV_aim (void)
        }
        //speed = PRVM_G_FLOAT(OFS_PARM1);
 
        }
        //speed = PRVM_G_FLOAT(OFS_PARM1);
 

-       VectorCopy (ent->fields.server->origin, start);
+       VectorCopy (PRVM_serveredictvector(ent, origin), start);

        start[2] += 20;
 
 // try sending a trace straight
        start[2] += 20;
 
 // try sending a trace straight

-       VectorCopy (prog->globals.server->v_forward, dir);
+       VectorCopy (PRVM_serverglobalvector(v_forward), dir);

        VectorMA (start, 2048, dir, end);
        tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
        VectorMA (start, 2048, dir, end);
        tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);

-       if (tr.ent && ((prvm_edict_t *)tr.ent)->fields.server->takedamage == DAMAGE_AIM
-       && (!teamplay.integer || ent->fields.server->team <=0 || ent->fields.server->team != ((prvm_edict_t *)tr.ent)->fields.server->team) )
+       if (tr.ent && PRVM_serveredictfloat(((prvm_edict_t *)tr.ent), takedamage) == DAMAGE_AIM
+       && (!teamplay.integer || PRVM_serveredictfloat(ent, team) <=0 || PRVM_serveredictfloat(ent, team) != PRVM_serveredictfloat(((prvm_edict_t *)tr.ent), team)) )

        {
        {

-               VectorCopy (prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
+               VectorCopy (PRVM_serverglobalvector(v_forward), PRVM_G_VECTOR(OFS_RETURN));

                return;
        }
 
                return;
        }
 


@@ -1277,18 +1277,18 @@ static void VM_SV_aim (void)
        for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
        {
                prog->xfunction->builtinsprofile++;
        for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
        {
                prog->xfunction->builtinsprofile++;

-               if (check->fields.server->takedamage != DAMAGE_AIM)
+               if (PRVM_serveredictfloat(check, takedamage) != DAMAGE_AIM)

                        continue;
                if (check == ent)
                        continue;
                        continue;
                if (check == ent)
                        continue;

-               if (teamplay.integer && ent->fields.server->team > 0 && ent->fields.server->team == check->fields.server->team)
+               if (teamplay.integer && PRVM_serveredictfloat(ent, team) > 0 && PRVM_serveredictfloat(ent, team) == PRVM_serveredictfloat(check, team))

                        continue;       // don't aim at teammate
                for (j=0 ; j<3 ; j++)
                        continue;       // don't aim at teammate
                for (j=0 ; j<3 ; j++)

-                       end[j] = check->fields.server->origin[j]
-                       + 0.5*(check->fields.server->mins[j] + check->fields.server->maxs[j]);
+                       end[j] = PRVM_serveredictvector(check, origin)[j]
+                       + 0.5*(PRVM_serveredictvector(check, mins)[j] + PRVM_serveredictvector(check, maxs)[j]);

                VectorSubtract (end, start, dir);
                VectorNormalize (dir);
                VectorSubtract (end, start, dir);
                VectorNormalize (dir);

-               dist = DotProduct (dir, prog->globals.server->v_forward);
+               dist = DotProduct (dir, PRVM_serverglobalvector(v_forward));

                if (dist < bestdist)
                        continue;       // to far to turn
                tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);
                if (dist < bestdist)
                        continue;       // to far to turn
                tr = SV_TraceLine(start, end, MOVE_NORMAL, ent, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY);


@@ -1301,9 +1301,9 @@ static void VM_SV_aim (void)
 
        if (bestent)
        {
 
        if (bestent)
        {

-               VectorSubtract (bestent->fields.server->origin, ent->fields.server->origin, dir);
-               dist = DotProduct (dir, prog->globals.server->v_forward);
-               VectorScale (prog->globals.server->v_forward, dist, end);
+               VectorSubtract (PRVM_serveredictvector(bestent, origin), PRVM_serveredictvector(ent, origin), dir);
+               dist = DotProduct (dir, PRVM_serverglobalvector(v_forward));
+               VectorScale (PRVM_serverglobalvector(v_forward), dist, end);

                end[2] = dir[2];
                VectorNormalize (end);
                VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
                end[2] = dir[2];
                VectorNormalize (end);
                VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));


@@ -1341,7 +1341,7 @@ sizebuf_t *WriteDest (void)
                return &sv.datagram;
 
        case MSG_ONE:
                return &sv.datagram;
 
        case MSG_ONE:

-               ent = PRVM_PROG_TO_EDICT(prog->globals.server->msg_entity);
+               ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(msg_entity));

                entnum = PRVM_NUM_FOR_EDICT(ent);
                if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
                {
                entnum = PRVM_NUM_FOR_EDICT(ent);
                if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active || !svs.clients[entnum-1].netconnection)
                {


@@ -1468,7 +1468,7 @@ static void VM_SV_makestatic (void)
        if (prog->argc >= 1)
                ent = PRVM_G_EDICT(OFS_PARM0);
        else
        if (prog->argc >= 1)
                ent = PRVM_G_EDICT(OFS_PARM0);
        else

-               ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+               ent = PRVM_PROG_TO_EDICT(PRVM_serverglobaledict(self));

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


@@ -1481,34 +1481,34 @@ static void VM_SV_makestatic (void)
        }
 
        large = false;
        }
 
        large = false;

-       if (ent->fields.server->modelindex >= 256 || ent->fields.server->frame >= 256)
+       if (PRVM_serveredictfloat(ent, modelindex) >= 256 || PRVM_serveredictfloat(ent, frame) >= 256)

                large = true;
 
        if (large)
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic2);
                large = true;
 
        if (large)
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic2);

-               MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
-               MSG_WriteShort (&sv.signon, (int)ent->fields.server->frame);
+               MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
+               MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));

        }
        else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic);
        }
        else if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic);

-               MSG_WriteShort (&sv.signon, (int)ent->fields.server->modelindex);
-               MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
+               MSG_WriteShort (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
+               MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));

        }
        else
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic);
        }
        else
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic);

-               MSG_WriteByte (&sv.signon, (int)ent->fields.server->modelindex);
-               MSG_WriteByte (&sv.signon, (int)ent->fields.server->frame);
+               MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, modelindex));
+               MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, frame));

        }
 
        }
 

-       MSG_WriteByte (&sv.signon, (int)ent->fields.server->colormap);
-       MSG_WriteByte (&sv.signon, (int)ent->fields.server->skin);
+       MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, colormap));
+       MSG_WriteByte (&sv.signon, (int)PRVM_serveredictfloat(ent, skin));

        for (i=0 ; i<3 ; i++)
        {
        for (i=0 ; i<3 ; i++)
        {

-               MSG_WriteCoord(&sv.signon, ent->fields.server->origin[i], sv.protocol);
-               MSG_WriteAngle(&sv.signon, ent->fields.server->angles[i], sv.protocol);
+               MSG_WriteCoord(&sv.signon, PRVM_serveredictvector(ent, origin)[i], sv.protocol);
+               MSG_WriteAngle(&sv.signon, PRVM_serveredictvector(ent, angles)[i], sv.protocol);

        }
 
 // throw the entity away now
        }
 
 // throw the entity away now


@@ -1541,7 +1541,7 @@ static void VM_SV_setspawnparms (void)
        // copy spawn parms out of the client_t
        client = svs.clients + i-1;
        for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
        // copy spawn parms out of the client_t
        client = svs.clients + i-1;
        for (i=0 ; i< NUM_SPAWN_PARMS ; i++)

-               (&prog->globals.server->parm1)[i] = client->spawn_parms[i];
+               (&PRVM_serverglobalfloat(parm1))[i] = client->spawn_parms[i];

 }
 
 /*
 }
 
 /*


@@ -1743,7 +1743,7 @@ static void VM_SV_setcolor (void)
        if (client->edict)
        {
                PRVM_serveredictfloat(client->edict, clientcolors) = i;
        if (client->edict)
        {
                PRVM_serveredictfloat(client->edict, clientcolors) = i;

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

        }
        client->colors = i;
        if (client->old_colors != client->colors)
        }
        client->colors = i;
        if (client->old_colors != client->colors)


@@ -2316,7 +2316,7 @@ static void VM_SV_setattachment (void)
                model = SV_GetModelFromEdict(tagentity);
                if (model)
                {
                model = SV_GetModelFromEdict(tagentity);
                if (model)
                {

-                       tagindex = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.server->skin, tagname);
+                       tagindex = Mod_Alias_GetTagIndexForName(model, (int)PRVM_serveredictfloat(tagentity, skin), tagname);

                        if (tagindex == 0)
                                Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
                }
                        if (tagindex == 0)
                                Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
                }


@@ -2335,11 +2335,11 @@ int SV_GetTagIndex (prvm_edict_t *e, const char *tagname)
 {
        int i;
 
 {
        int i;
 

-       i = (int)e->fields.server->modelindex;
+       i = (int)PRVM_serveredictfloat(e, modelindex);

        if (i < 1 || i >= MAX_MODELS)
                return -1;
 
        if (i < 1 || i >= MAX_MODELS)
                return -1;
 

-       return Mod_Alias_GetTagIndexForName(SV_GetModelByIndex(i), (int)e->fields.server->skin, tagname);
+       return Mod_Alias_GetTagIndexForName(SV_GetModelByIndex(i), (int)PRVM_serveredictfloat(e, skin), tagname);

 }
 
 int SV_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
 }
 
 int SV_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)


@@ -2353,7 +2353,7 @@ int SV_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, cons
 
        if (tagindex >= 0 && (model = SV_GetModelFromEdict(e)) && model->num_bones)
        {
 
        if (tagindex >= 0 && (model = SV_GetModelFromEdict(e)) && model->num_bones)
        {

-               r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.server->skin, e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
+               r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)PRVM_serveredictfloat(e, skin), e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);

 
                if(!r) // success?
                        *parentindex += 1;
 
                if(!r) // success?
                        *parentindex += 1;


@@ -2374,11 +2374,11 @@ void SV_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatri
                scale = 1.0f;
        
        if (viewmatrix)
                scale = 1.0f;
        
        if (viewmatrix)

-               Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2] + ent->fields.server->view_ofs[2], ent->fields.server->v_angle[0], ent->fields.server->v_angle[1], ent->fields.server->v_angle[2], scale * cl_viewmodel_scale.value);
+               Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2] + PRVM_serveredictvector(ent, view_ofs)[2], PRVM_serveredictvector(ent, v_angle)[0], PRVM_serveredictvector(ent, v_angle)[1], PRVM_serveredictvector(ent, v_angle)[2], scale * cl_viewmodel_scale.value);

        else
        {
                pitchsign = SV_GetPitchSign(ent);
        else
        {
                pitchsign = SV_GetPitchSign(ent);

-               Matrix4x4_CreateFromQuakeEntity(out, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2], pitchsign * ent->fields.server->angles[0], ent->fields.server->angles[1], ent->fields.server->angles[2], scale);
+               Matrix4x4_CreateFromQuakeEntity(out, PRVM_serveredictvector(ent, origin)[0], PRVM_serveredictvector(ent, origin)[1], PRVM_serveredictvector(ent, origin)[2], pitchsign * PRVM_serveredictvector(ent, angles)[0], PRVM_serveredictvector(ent, angles)[1], PRVM_serveredictvector(ent, angles)[2], scale);

        }
 }
 
        }
 }
 


@@ -2420,7 +2420,7 @@ int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
        if (ent->priv.server->free)
                return 2;
 
        if (ent->priv.server->free)
                return 2;
 

-       modelindex = (int)ent->fields.server->modelindex;
+       modelindex = (int)PRVM_serveredictfloat(ent, modelindex);

        if (modelindex <= 0 || modelindex >= MAX_MODELS)
                return 3;
 
        if (modelindex <= 0 || modelindex >= MAX_MODELS)
                return 3;
 


@@ -2467,7 +2467,7 @@ int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 
                /*
                // Cl_bob, ported from rendering code
 
                /*
                // Cl_bob, ported from rendering code

-               if (ent->fields.server->health > 0 && cl_bob.value && cl_bobcycle.value)
+               if (PRVM_serveredictfloat(ent, health) > 0 && cl_bob.value && cl_bobcycle.value)

                {
                        double bob, cycle;
                        // LordHavoc: this code is *weird*, but not replacable (I think it
                {
                        double bob, cycle;
                        // LordHavoc: this code is *weird*, but not replacable (I think it


@@ -2482,7 +2482,7 @@ int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
                                cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
                        // bob is proportional to velocity in the xy plane
                        // (don't count Z, or jumping messes it up)
                                cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
                        // bob is proportional to velocity in the xy plane
                        // (don't count Z, or jumping messes it up)

-                       bob = sqrt(ent->fields.server->velocity[0]*ent->fields.server->velocity[0] + ent->fields.server->velocity[1]*ent->fields.server->velocity[1])*cl_bob.value;
+                       bob = sqrt(PRVM_serveredictvector(ent, velocity)[0]*PRVM_serveredictvector(ent, velocity)[0] + PRVM_serveredictvector(ent, velocity)[1]*PRVM_serveredictvector(ent, velocity)[1])*cl_bob.value;

                        bob = bob*0.3 + bob*0.7*cycle;
                        Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
                }
                        bob = bob*0.3 + bob*0.7*cycle;
                        Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
                }


@@ -2547,8 +2547,8 @@ static void VM_SV_gettaginfo (void)
        tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
 
        returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);
        tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
 
        returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);

-       Matrix4x4_ToVectors(&tag_matrix, prog->globals.server->v_forward, le, prog->globals.server->v_up, PRVM_G_VECTOR(OFS_RETURN));
-       VectorScale(le, -1, prog->globals.server->v_right);
+       Matrix4x4_ToVectors(&tag_matrix, PRVM_serverglobalvector(v_forward), le, PRVM_serverglobalvector(v_up), PRVM_G_VECTOR(OFS_RETURN));
+       VectorScale(le, -1, PRVM_serverglobalvector(v_right));

        model = SV_GetModelFromEdict(e);
        VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
        VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
        model = SV_GetModelFromEdict(e);
        VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
        VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);


@@ -2692,8 +2692,8 @@ static void VM_SV_setmodelindex (void)
                return;
        }
 
                return;
        }
 

-       e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
-       e->fields.server->modelindex = i;
+       PRVM_serveredictstring(e, model) = PRVM_SetEngineString(sv.model_precache[i]);
+       PRVM_serveredictfloat(e, modelindex) = i;

 
        mod = SV_GetModelByIndex(i);
 
 
        mod = SV_GetModelByIndex(i);
 


@@ -2938,18 +2938,18 @@ static void VM_SV_skel_get_bonerel(void)
        matrix4x4_t matrix;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));
        matrix4x4_t matrix;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));

-       VectorClear(prog->globals.client->v_forward);
-       VectorClear(prog->globals.client->v_right);
-       VectorClear(prog->globals.client->v_up);
+       VectorClear(PRVM_clientglobalvector(v_forward));
+       VectorClear(PRVM_clientglobalvector(v_right));
+       VectorClear(PRVM_clientglobalvector(v_up));

        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        matrix = skeleton->relativetransforms[bonenum];
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        matrix = skeleton->relativetransforms[bonenum];
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);

-       VectorCopy(forward, prog->globals.client->v_forward);
-       VectorNegate(left, prog->globals.client->v_right);
-       VectorCopy(up, prog->globals.client->v_up);
+       VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+       VectorNegate(left, PRVM_clientglobalvector(v_right));
+       VectorCopy(up, PRVM_clientglobalvector(v_up));

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


@@ -2963,9 +2963,9 @@ static void VM_SV_skel_get_boneabs(void)
        matrix4x4_t temp;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));
        matrix4x4_t temp;
        vec3_t forward, left, up, origin;
        VectorClear(PRVM_G_VECTOR(OFS_RETURN));

-       VectorClear(prog->globals.client->v_forward);
-       VectorClear(prog->globals.client->v_right);
-       VectorClear(prog->globals.client->v_up);
+       VectorClear(PRVM_clientglobalvector(v_forward));
+       VectorClear(PRVM_clientglobalvector(v_right));
+       VectorClear(PRVM_clientglobalvector(v_up));

        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)


@@ -2978,9 +2978,9 @@ static void VM_SV_skel_get_boneabs(void)
                Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
        }
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
                Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
        }
        Matrix4x4_ToVectors(&matrix, forward, left, up, origin);

-       VectorCopy(forward, prog->globals.client->v_forward);
-       VectorNegate(left, prog->globals.client->v_right);
-       VectorCopy(up, prog->globals.client->v_up);
+       VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+       VectorNegate(left, PRVM_clientglobalvector(v_right));
+       VectorCopy(up, PRVM_clientglobalvector(v_up));

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


@@ -2996,9 +2996,9 @@ static void VM_SV_skel_set_bone(void)
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
                return;
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        skeleton->relativetransforms[bonenum] = matrix;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        skeleton->relativetransforms[bonenum] = matrix;


@@ -3018,9 +3018,9 @@ static void VM_SV_skel_mul_bone(void)
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
        if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        temp = skeleton->relativetransforms[bonenum];
        Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        temp = skeleton->relativetransforms[bonenum];
        Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);


@@ -3040,9 +3040,9 @@ static void VM_SV_skel_mul_bones(void)
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
        if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
                return;
        VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);

-       VectorCopy(prog->globals.client->v_forward, forward);
-       VectorNegate(prog->globals.client->v_right, left);
-       VectorCopy(prog->globals.client->v_up, up);
+       VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+       VectorNegate(PRVM_clientglobalvector(v_right), left);
+       VectorCopy(PRVM_clientglobalvector(v_up), up);

        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        firstbone = max(0, firstbone);
        lastbone = min(lastbone, skeleton->model->num_bones - 1);
        Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
        firstbone = max(0, firstbone);
        lastbone = min(lastbone, skeleton->model->num_bones - 1);

diff --git a/todo b/todo
index 6c608040bc8bb810121e8dc71e0ea61dfc3f8c76..adfa4ebecf3f2e5722cc6a7bc139ab6e7db7caa2 100644 (file)
--- a/todo
+++ b/todo
@@ -1,13 +1,12 @@
 - todo: difficulty ratings are: 0 = trivial, 1 = easy, 2 = easy-moderate, 3 = moderate, 4 = moderate-hard, 5 = hard, 6 = hard++, 7 = nightmare, d = done, -d = done but have not notified the people who asked for it, f = failed, -f = failed but have not notified the people who asked for it
 -d bug darkplaces d3d9: drawsetcliparea not working right - seems to be Y-flipped, this also affects menus in Steelstorm (VorteX)
 -d bug darkplaces d3d9: overbright particles get weird colors (VorteX)
 - todo: difficulty ratings are: 0 = trivial, 1 = easy, 2 = easy-moderate, 3 = moderate, 4 = moderate-hard, 5 = hard, 6 = hard++, 7 = nightmare, d = done, -d = done but have not notified the people who asked for it, f = failed, -f = failed but have not notified the people who asked for it
 -d bug darkplaces d3d9: drawsetcliparea not working right - seems to be Y-flipped, this also affects menus in Steelstorm (VorteX)
 -d bug darkplaces d3d9: overbright particles get weird colors (VorteX)

-0 optimize darkplaces renderer: get rid of attenuation texture on lights because math is faster, add fastpath for no normalmap (Lava_Croft)
-0 bug darkplaces filesystem: -game nehahra does not load properly; menu does not work properly - probably not activating gamemode

 0 bug darkplaces client csqc: CSQC_InputEvent is supposed to handle mouse movement, compare to FTEQW code (avirox)
 0 bug darkplaces client csqc: engine prediction function is not implemented - could just return the engine's current cl.movement_origin (Spike)
 0 bug darkplaces client csqc: entities not being drawn with VF_PERSPECTIVE 0? (daemon)
 0 bug darkplaces client csqc: input queue functions needed for csqc prediction aren't implemented (Spike)
 0 bug darkplaces client csqc: precaches on client don't work, have to precache on server - what's going wrong here? (daemon, Urre)
 0 bug darkplaces client csqc: CSQC_InputEvent is supposed to handle mouse movement, compare to FTEQW code (avirox)
 0 bug darkplaces client csqc: engine prediction function is not implemented - could just return the engine's current cl.movement_origin (Spike)
 0 bug darkplaces client csqc: entities not being drawn with VF_PERSPECTIVE 0? (daemon)
 0 bug darkplaces client csqc: input queue functions needed for csqc prediction aren't implemented (Spike)
 0 bug darkplaces client csqc: precaches on client don't work, have to precache on server - what's going wrong here? (daemon, Urre)

+0 bug darkplaces client csqc: string stats should be sent as a single stat with WriteString (Spike)

 0 bug darkplaces client csqc: there is no WriteFloat, making ReadFloat useless (Urre)
 0 bug darkplaces client csqc: unproject Z handling differs in DP and FTEQW, project also must be directly compatible with unproject (avirox)
 0 bug darkplaces client csqc: world not being drawn with VF_PERSPECTIVE 0? (VorteX)
 0 bug darkplaces client csqc: there is no WriteFloat, making ReadFloat useless (Urre)
 0 bug darkplaces client csqc: unproject Z handling differs in DP and FTEQW, project also must be directly compatible with unproject (avirox)
 0 bug darkplaces client csqc: world not being drawn with VF_PERSPECTIVE 0? (VorteX)


@@ -33,6 +32,7 @@
 0 bug darkplaces effects: add a cvar to disable colored dlights (leileilol)
 0 bug darkplaces effects: dlights don't look anything like quake ones, bring back lightmap dlights as a cvar - with both classic and old dp falloff modes (leileilol)
 0 bug darkplaces effects: quake mode blood trails don't have the appropriate slight gravity - there may be other effects missing this also (leileilol)
 0 bug darkplaces effects: add a cvar to disable colored dlights (leileilol)
 0 bug darkplaces effects: dlights don't look anything like quake ones, bring back lightmap dlights as a cvar - with both classic and old dp falloff modes (leileilol)
 0 bug darkplaces effects: quake mode blood trails don't have the appropriate slight gravity - there may be other effects missing this also (leileilol)

+0 bug darkplaces filesystem: -game nehahra does not load properly; menu does not work properly - probably not activating gamemode

 0 bug darkplaces loader: crash when a mdl model has more replacement skins than the model contains (Lardarse)
 0 bug darkplaces loader: make rtlight entity loader support q3map/q3map2 lights properly, they use a spawnflag for LINEAR mode, by default they use 1/(x*x) falloff (Carni, motorsep)
 0 bug darkplaces loader: mcbsp hull selection is ignoring the custom hulls supported by mcbsp (div0)
 0 bug darkplaces loader: crash when a mdl model has more replacement skins than the model contains (Lardarse)
 0 bug darkplaces loader: make rtlight entity loader support q3map/q3map2 lights properly, they use a spawnflag for LINEAR mode, by default they use 1/(x*x) falloff (Carni, motorsep)
 0 bug darkplaces loader: mcbsp hull selection is ignoring the custom hulls supported by mcbsp (div0)


@@ -57,6 +57,7 @@
 0 bug darkplaces server: SV_PushMove is ignoring model type in its angles_x handling, where as the renderer checks only model type to determine angles_x handling (Urre)
 0 bug darkplaces server: SV_PushMove's call to SV_ClipMoveToEntity should do a trace, not just a point test, to support hollow pusher models (Urre)
 0 bug darkplaces server: X-Men mod has flying enemies that tend to go through the floor, sometimes preventing a level from being completed.  x1m1 has two alcoves that open to reveal Storm and Archangel but often Storm disappears through the ground of hear alcove and then the level can't be completed.  A similar problem with Storm apears in x1m3 in an alcove.  (ewwfq yahoo com)
 0 bug darkplaces server: SV_PushMove is ignoring model type in its angles_x handling, where as the renderer checks only model type to determine angles_x handling (Urre)
 0 bug darkplaces server: SV_PushMove's call to SV_ClipMoveToEntity should do a trace, not just a point test, to support hollow pusher models (Urre)
 0 bug darkplaces server: X-Men mod has flying enemies that tend to go through the floor, sometimes preventing a level from being completed.  x1m1 has two alcoves that open to reveal Storm and Archangel but often Storm disappears through the ground of hear alcove and then the level can't be completed.  A similar problem with Storm apears in x1m3 in an alcove.  (ewwfq yahoo com)

+0 bug darkplaces server: savegames do not contain parms for multiple players, restoring a savegame leaves parms for other players as they were at the time of loading the savegame, clearly wrong (daemon)

 0 bug darkplaces server: savegames do not save precaches, which means that automatic precaching frequently results in invalid modelindex values when reloading the savegame, and this bug also exists in many quake mods that randomly choose multiple variants of a monster, each with separate precaches, resulting in a different precache order when reloading the savegame
 0 bug darkplaces wgl client: during video mode setup, sometimes another application's window becomes permanently top most, not darkplaces' fullscreen window, why? (tZork)
 0 bug darkplaces windows sound: freezing on exit sometimes when freeing sound buffer during sound shutdown (Black)
 0 bug darkplaces server: savegames do not save precaches, which means that automatic precaching frequently results in invalid modelindex values when reloading the savegame, and this bug also exists in many quake mods that randomly choose multiple variants of a monster, each with separate precaches, resulting in a different precache order when reloading the savegame
 0 bug darkplaces wgl client: during video mode setup, sometimes another application's window becomes permanently top most, not darkplaces' fullscreen window, why? (tZork)
 0 bug darkplaces windows sound: freezing on exit sometimes when freeing sound buffer during sound shutdown (Black)


@@ -263,6 +264,7 @@
 0 optimization darkplaces server: implement first unused/last used entity range optimization on entity spawn/remove similar to the client particles (LordHavoc)
 0 optimization darkplaces visibility: R_Q1BSP_BoxTouchingPVS and R_Q3BSP_BoxTouchingPVS should check pvsframe on nodes as well as leafs (Vic)
 0 optimization darkplaces: calculate worldmodel farclip (corner to corner radius) at load
 0 optimization darkplaces server: implement first unused/last used entity range optimization on entity spawn/remove similar to the client particles (LordHavoc)
 0 optimization darkplaces visibility: R_Q1BSP_BoxTouchingPVS and R_Q3BSP_BoxTouchingPVS should check pvsframe on nodes as well as leafs (Vic)
 0 optimization darkplaces: calculate worldmodel farclip (corner to corner radius) at load

+0 optimize darkplaces renderer: get rid of attenuation texture on lights because math is faster, add fastpath for no normalmap (Lava_Croft)

 1 bug darkplaces WGL client: figure out why for some people GDI input has stuttering problems with gl_finish 0 mode (Kinn, Urre, romi, Spike, Black)
 1 bug darkplaces WGL/GLX/SDL client bug: if sound is unavailable (causing a freeze waiting for it to become available), the config is reset (SavageX)
 1 bug darkplaces bsd filesystem: read() is failing (not returning the requested amount) on freebsd when reading files, whether actual files or in a pk3 - somehow it is still able to read the pk3 zip directory though (suminigashi, Elric)
 1 bug darkplaces WGL client: figure out why for some people GDI input has stuttering problems with gl_finish 0 mode (Kinn, Urre, romi, Spike, Black)
 1 bug darkplaces WGL/GLX/SDL client bug: if sound is unavailable (causing a freeze waiting for it to become available), the config is reset (SavageX)
 1 bug darkplaces bsd filesystem: read() is failing (not returning the requested amount) on freebsd when reading files, whether actual files or in a pk3 - somehow it is still able to read the pk3 zip directory though (suminigashi, Elric)

diff --git a/world.c b/world.c
index a0cac28c100aefe47efb391e6b6ee7e65726f3a9..4830996ca77b50073ca69005e277fa51bee82b37 100644 (file)
--- a/world.c
+++ b/world.c
@@ -2553,11 +2553,11 @@ static void nearCallback (void *data, dGeomID o1, dGeomID o2)
 
        if(!strcmp(prog->name, "server"))
        {
 
        if(!strcmp(prog->name, "server"))
        {

-               if(ed1 && ed1->fields.server->touch)
+               if(ed1 && PRVM_serveredictfunction(ed1, touch))

                {
                        SV_LinkEdict_TouchAreaGrid_Call(ed1, ed2 ? ed2 : prog->edicts);
                }
                {
                        SV_LinkEdict_TouchAreaGrid_Call(ed1, ed2 ? ed2 : prog->edicts);
                }

-               if(ed2 && ed2->fields.server->touch)
+               if(ed2 && PRVM_serveredictfunction(ed2, touch))

                {
                        SV_LinkEdict_TouchAreaGrid_Call(ed2, ed1 ? ed1 : prog->edicts);
                }
                {
                        SV_LinkEdict_TouchAreaGrid_Call(ed2, ed1 ? ed1 : prog->edicts);
                }