-CVS: ----------------------------------------------------------------------
authorblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 27 May 2005 15:43:48 +0000 (15:43 +0000)
committerblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Fri, 27 May 2005 15:43:48 +0000 (15:43 +0000)
-Merged the old VM into the new one. The pr_* files are mess right now and
 will be removed as soon as they are not needed as semi-reference (to trace
 bugs)
-There is a certain risk that the server could crash now and then since some
 parts of the code can only be debugged (- checking them by looking at the code
 would be quite tedious to put it nicely)
-Changed all references to the old VM to point to the new VM (also hopefully
 all todo items)
-Im working on a cleanup for the SV_VM_Begin/End mess.

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

29 files changed:
cl_collision.c
gl_rmain.c
host.c
host_cmd.c
makefile.inc
menu.c
mvm_cmds.c
netconn.c
pr_cmds.c
pr_edict.c
pr_exec.c
pr_execprogram.h
progs.h
progsvm.h
protocol.c
prvm_cmds.c
prvm_cmds.h
prvm_edict.c
prvm_exec.c
prvm_execprogram.h
quakedef.h
server.h
sv_main.c
sv_move.c
sv_phys.c
sv_user.c
svvm_cmds.c [new file with mode: 0644]
world.c
world.h

index 8920a5e..c97f0a3 100644 (file)
@@ -6,7 +6,7 @@
 // not yet used
 typedef struct physentity_s
 {
-       // this may be a entity_t, or a edict_t, or whatever
+       // this may be a entity_t, or a prvm_edict_t, or whatever
        void *realentity;
 
        // can be NULL if it is a bbox object
index d7ab02c..760e60c 100644 (file)
@@ -606,7 +606,7 @@ void GL_Init (void)
        VID_CheckExtensions();
 
        // LordHavoc: report supported extensions
-       Con_DPrintf("\nengine extensions: %s\n", ENGINE_EXTENSIONS);
+       Con_DPrintf("\nengine extensions: %s\n", vm_sv_extensions );
 
        // clear to black (loading plaque will be seen over this)
        qglClearColor(0,0,0,1);
diff --git a/host.c b/host.c
index 9eaa3ba..41272a7 100644 (file)
--- a/host.c
+++ b/host.c
@@ -127,7 +127,7 @@ void Host_Error (const char *error, ...)
 
        CL_Parse_DumpPacket();
 
-       PR_Crash();
+       //PR_Crash();
 
        //PRVM_Crash(); // crash current prog
 
@@ -394,7 +394,7 @@ void SV_DropClient(qboolean crash)
        Con_Printf("Client \"%s\" dropped\n", host_client->name);
 
        // make sure edict is not corrupt (from a level change for example)
-       host_client->edict = EDICT_NUM(host_client - svs.clients + 1);
+       host_client->edict = PRVM_EDICT_NUM(host_client - svs.clients + 1);
 
        if (host_client->netconnection)
        {
@@ -419,18 +419,18 @@ 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
-               int saveSelf = pr_global_struct->self;
+               int saveSelf = prog->globals.server->self;
                host_client->clientconnectcalled = false;
-               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-               PR_ExecuteProgram(pr_global_struct->ClientDisconnect, "QC function ClientDisconnect is missing");
-               pr_global_struct->self = saveSelf;
+               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;
        }
 
        // remove leaving player from scoreboard
-       //host_client->edict->v->netname = PR_SetEngineString(host_client->name);
-       //if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
+       //host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
+       //if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
        //      val->_float = 0;
-       //host_client->edict->v->frags = 0;
+       //host_client->edict->fields.server->frags = 0;
        host_client->name[0] = 0;
        host_client->colors = 0;
        host_client->frags = 0;
@@ -458,7 +458,7 @@ void SV_DropClient(qboolean crash)
        if (sv.active)
        {
                // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
-               ED_ClearEdict(host_client->edict);
+               PRVM_ED_ClearEdict(host_client->edict);
        }
 
        // clear the client struct (this sets active to false)
@@ -487,8 +487,9 @@ void Host_ShutdownServer(qboolean crash)
        if (!sv.active)
                return;
 
+       SV_VM_Begin();
        // print out where the crash happened, if it was caused by QC
-       PR_Crash();
+       //PRVM_Crash();
 
        NetConn_Heartbeat(2);
        NetConn_Heartbeat(2);
@@ -503,18 +504,20 @@ void Host_ShutdownServer(qboolean crash)
                Con_Printf("Host_ShutdownServer: NetConn_SendToAll failed for %u clients\n", count);
 
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
-               if (host_client->active)
+               if (host_client->active) {
                        SV_DropClient(crash); // server shutdown
+               }
 
        NetConn_CloseServerPorts();
 
        sv.active = false;
-
 //
 // clear structures
 //
        memset(&sv, 0, sizeof(sv));
        memset(svs.clients, 0, svs.maxclients*sizeof(client_t));
+
+       SV_VM_End();
 }
 
 
@@ -670,10 +673,15 @@ void Host_ServerFrame (void)
                return;
        }
        sv.timer += host_realframetime;
+
+    
        // run the world state
        // don't allow simulation to run too fast or too slow or logic glitches can occur
        for (framecount = 0;framecount < framelimit && sv.timer > 0;framecount++)
        {
+               // setup the VM frame
+               SV_VM_Begin();
+
                if (cl.islocalgame)
                        advancetime = min(sv.timer, sys_ticrate.value);
                else
@@ -704,7 +712,12 @@ void Host_ServerFrame (void)
 
                // send an heartbeat if enough time has passed since the last one
                NetConn_Heartbeat(0);
+
+               // end the server VM frame
+               SV_VM_End();
        }
+
+
        // if we fell behind too many frames just don't worry about it
        if (sv.timer > 0)
                sv.timer = 0;
@@ -958,8 +971,8 @@ void Host_Init (void)
        Mathlib_Init();
 
        NetConn_Init();
-       PR_Init();
-       PR_Cmd_Init();
+       //PR_Init();
+       //PR_Cmd_Init();
        PRVM_Init();
        Mod_Init();
        SV_Init();
@@ -1082,7 +1095,7 @@ void Host_Shutdown(void)
        CDAudio_Shutdown ();
        S_Terminate ();
        NetConn_Shutdown ();
-       PR_Shutdown ();
+       //PR_Shutdown ();
 
        if (cls.state != ca_dedicated)
        {
index f28ac17..ac6d821 100644 (file)
@@ -24,8 +24,6 @@ int current_skill;
 cvar_t sv_cheats = {0, "sv_cheats", "0"};
 qboolean allowcheats = false;
 
-mfunction_t *ED_FindFunction (char *name);
-
 /*
 ==================
 Host_Quit_f
@@ -84,7 +82,7 @@ void Host_Status_f (void)
                }
                else
                        hours = 0;
-               print ("#%-2u %-16.16s  %3i  %2i:%02i:%02i\n", j+1, client->name, (int)client->edict->v->frags, hours, minutes, seconds);
+               print ("#%-2u %-16.16s  %3i  %2i:%02i:%02i\n", j+1, client->name, (int)client->edict->fields.server->frags, hours, minutes, seconds);
                print ("   %s\n", client->netconnection ? client->netconnection->address : "botclient");
        }
 }
@@ -111,8 +109,8 @@ void Host_God_f (void)
                return;
        }
 
-       host_client->edict->v->flags = (int)host_client->edict->v->flags ^ FL_GODMODE;
-       if (!((int)host_client->edict->v->flags & FL_GODMODE) )
+       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) )
                SV_ClientPrint("godmode OFF\n");
        else
                SV_ClientPrint("godmode ON\n");
@@ -132,8 +130,8 @@ void Host_Notarget_f (void)
                return;
        }
 
-       host_client->edict->v->flags = (int)host_client->edict->v->flags ^ FL_NOTARGET;
-       if (!((int)host_client->edict->v->flags & FL_NOTARGET) )
+       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) )
                SV_ClientPrint("notarget OFF\n");
        else
                SV_ClientPrint("notarget ON\n");
@@ -155,16 +153,16 @@ void Host_Noclip_f (void)
                return;
        }
 
-       if (host_client->edict->v->movetype != MOVETYPE_NOCLIP)
+       if (host_client->edict->fields.server->movetype != MOVETYPE_NOCLIP)
        {
                noclip_anglehack = true;
-               host_client->edict->v->movetype = MOVETYPE_NOCLIP;
+               host_client->edict->fields.server->movetype = MOVETYPE_NOCLIP;
                SV_ClientPrint("noclip ON\n");
        }
        else
        {
                noclip_anglehack = false;
-               host_client->edict->v->movetype = MOVETYPE_WALK;
+               host_client->edict->fields.server->movetype = MOVETYPE_WALK;
                SV_ClientPrint("noclip OFF\n");
        }
 }
@@ -190,14 +188,14 @@ void Host_Fly_f (void)
                return;
        }
 
-       if (host_client->edict->v->movetype != MOVETYPE_FLY)
+       if (host_client->edict->fields.server->movetype != MOVETYPE_FLY)
        {
-               host_client->edict->v->movetype = MOVETYPE_FLY;
+               host_client->edict->fields.server->movetype = MOVETYPE_FLY;
                SV_ClientPrint("flymode ON\n");
        }
        else
        {
-               host_client->edict->v->movetype = MOVETYPE_WALK;
+               host_client->edict->fields.server->movetype = MOVETYPE_WALK;
                SV_ClientPrint("flymode OFF\n");
        }
 }
@@ -278,7 +276,11 @@ void Host_Map_f (void)
        strcpy(level, Cmd_Argv(1));
        SV_SpawnServer(level);
        if (sv.active && cls.state == ca_disconnected)
+       {
+               SV_VM_Begin();
                CL_EstablishConnection("local:1");
+               SV_VM_End();
+       }
 }
 
 /*
@@ -309,12 +311,18 @@ void Host_Changelevel_f (void)
        key_dest = key_game;
        key_consoleactive = 0;
 
+       SV_VM_Begin();
        SV_SaveSpawnparms ();
+       SV_VM_End();
        allowcheats = sv_cheats.integer != 0;
        strcpy(level, Cmd_Argv(1));
        SV_SpawnServer(level);
        if (sv.active && cls.state == ca_disconnected)
+       {
+               SV_VM_Begin();
                CL_EstablishConnection("local:1");
+               SV_VM_End();
+       }
 }
 
 /*
@@ -348,8 +356,12 @@ void Host_Restart_f (void)
        allowcheats = sv_cheats.integer != 0;
        strcpy(mapname, sv.name);
        SV_SpawnServer(mapname);
-       if (sv.active && cls.state == ca_disconnected)
+       if (sv.active && cls.state == ca_disconnected) 
+       {
+               SV_VM_Begin();
                CL_EstablishConnection("local:1");
+               SV_VM_End();
+       }
 }
 
 /*
@@ -389,7 +401,9 @@ void Host_Connect_f (void)
                Con_Print("connect <serveraddress> : connect to a multiplayer game\n");
                return;
        }
-       CL_EstablishConnection(Cmd_Argv(1));
+       SV_VM_Begin();
+       CL_EstablishConnection("local:1");
+       SV_VM_End();
 }
 
 
@@ -464,7 +478,7 @@ void Host_Savegame_f (void)
                                Con_Print("Can't save multiplayer games.\n");
                                return;
                        }
-                       if (svs.clients[i].edict->v->deadflag)
+                       if (svs.clients[i].edict->fields.server->deadflag)
                        {
                                Con_Print("Can't savegame with a dead player\n");
                                return;
@@ -513,9 +527,14 @@ void Host_Savegame_f (void)
                        FS_Print(f,"m\n");
        }
 
-       ED_WriteGlobals (f);
-       for (i=0 ; i<sv.num_edicts ; i++)
-               ED_Write (f, EDICT_NUM(i));
+       SV_VM_Begin();
+
+       PRVM_ED_WriteGlobals (f);
+       for (i=0 ; i<prog->num_edicts ; i++)
+               PRVM_ED_Write (f, PRVM_EDICT_NUM(i));
+
+       SV_VM_End();
+
        FS_Close (f);
        Con_Print("done.\n");
 }
@@ -534,7 +553,7 @@ void Host_Loadgame_f (void)
        const char *start;
        const char *t;
        char *text;
-       edict_t *ent;
+       prvm_edict_t *ent;
        int i;
        int entnum;
        int version;
@@ -619,6 +638,7 @@ void Host_Loadgame_f (void)
        }
 
 // load the edicts out of the savegame file
+       SV_VM_Begin();
        // -1 is the globals
        entnum = -1;
        for (;;)
@@ -641,7 +661,7 @@ void Host_Loadgame_f (void)
                if (entnum == -1)
                {
                        // parse the global vars
-                       ED_ParseGlobals (start);
+                       PRVM_ED_ParseGlobals (start);
                }
                else
                {
@@ -651,22 +671,23 @@ void Host_Loadgame_f (void)
                                Mem_Free(text);
                                Host_Error("Host_PerformLoadGame: too many edicts in save file (reached MAX_EDICTS %i)\n", MAX_EDICTS);
                        }
-                       while (entnum >= sv.max_edicts)
-                               SV_IncreaseEdicts();
-                       ent = EDICT_NUM(entnum);
-                       memset (ent->v, 0, progs->entityfields * 4);
-                       ent->e->free = false;
-                       ED_ParseEdict (start, ent);
+                       while (entnum >= prog->max_edicts)
+                               //SV_IncreaseEdicts();
+                               PRVM_MEM_IncreaseEdicts();
+                       ent = PRVM_EDICT_NUM(entnum);
+                       memset (ent->fields.server, 0, prog->progs->entityfields * 4);
+                       ent->priv.server->free = false;
+                       PRVM_ED_ParseEdict (start, ent);
 
                        // link it into the bsp tree
-                       if (!ent->e->free)
+                       if (!ent->priv.server->free)
                                SV_LinkEdict (ent, false);
                }
 
                entnum++;
        }
 
-       sv.num_edicts = entnum;
+       prog->num_edicts = entnum;
        sv.time = time;
 
        for (i = 0;i < NUM_SPAWN_PARMS;i++)
@@ -675,6 +696,8 @@ void Host_Loadgame_f (void)
        // make sure we're connected to loopback
        if (cls.state == ca_disconnected || !(cls.state == ca_connected && cls.netcon != NULL && LHNETADDRESS_GetAddressType(&cls.netcon->peeraddress) == LHNETADDRESSTYPE_LOOP))
                CL_EstablishConnection("local:1");
+
+       SV_VM_End();
 }
 
 //============================================================================
@@ -724,7 +747,7 @@ void Host_Name_f (void)
 
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->name, newName, sizeof (host_client->name));
-       host_client->edict->v->netname = PR_SetEngineString(host_client->name);
+       host_client->edict->fields.server->netname = PRVM_SetEngineString(host_client->name);
        if (strcmp(host_client->old_name, host_client->name))
        {
                if (host_client->spawned)
@@ -786,11 +809,11 @@ void Host_Playermodel_f (void)
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playermodel, newPath, sizeof (host_client->playermodel));
        if( eval_playermodel )
-               GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PR_SetEngineString(host_client->playermodel);
+               PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(host_client->playermodel);
        if (strcmp(host_client->old_model, host_client->playermodel))
        {
                if (host_client->spawned)
-                       SV_BroadcastPrintf("%s changed model to %s\n", host_client->old_model, host_client->playermodel);
+                       SV_BroadcastPrintf("%s changed model to %s\n", host_client->name, host_client->playermodel);
                strcpy(host_client->old_model, host_client->playermodel);
                /*// send notification to all clients
                MSG_WriteByte (&sv.reliable_datagram, svc_updatepmodel);
@@ -847,11 +870,11 @@ void Host_Playerskin_f (void)
        // point the string back at updateclient->name to keep it safe
        strlcpy (host_client->playerskin, newPath, sizeof (host_client->playerskin));
        if( eval_playerskin )
-               GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PR_SetEngineString(host_client->playerskin);
+               PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(host_client->playerskin);
        if (strcmp(host_client->old_skin, host_client->playerskin))
        {
                if (host_client->spawned)
-                       SV_BroadcastPrintf("%s changed skin to %s\n", host_client->old_skin, host_client->playerskin);
+                       SV_BroadcastPrintf("%s changed skin to %s\n", host_client->name, host_client->playerskin);
                strcpy(host_client->old_skin, host_client->playerskin);
                /*// send notification to all clients
                MSG_WriteByte (&sv.reliable_datagram, svc_updatepskin);
@@ -920,7 +943,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++)
-               if (host_client->spawned && (!teamonly || host_client->edict->v->team == save->edict->v->team))
+               if (host_client->spawned && (!teamonly || host_client->edict->fields.server->team == save->edict->fields.server->team))
                        SV_ClientPrint(text);
        host_client = save;
 
@@ -1050,22 +1073,22 @@ void Host_Color_f(void)
                return;
        }
 
-       if (host_client->edict && (f = ED_FindFunction ("SV_ChangeTeam")) && (SV_ChangeTeam = (func_t)(f - pr_functions)))
+       if (host_client->edict && (f = PRVM_ED_FindFunction ("SV_ChangeTeam")) && (SV_ChangeTeam = (func_t)(f - prog->functions)))
        {
                Con_DPrint("Calling SV_ChangeTeam\n");
-               pr_global_struct->time = sv.time;
-               pr_globals[OFS_PARM0] = playercolor;
-               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-               PR_ExecuteProgram (SV_ChangeTeam, "QC function SV_ChangeTeam is missing");
+               prog->globals.server->time = sv.time;
+               prog->globals.generic[OFS_PARM0] = playercolor;
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+               PRVM_ExecuteProgram (SV_ChangeTeam, "QC function SV_ChangeTeam is missing");
        }
        else
        {
-               eval_t *val;
+               prvm_eval_t *val;
                if (host_client->edict)
                {
-                       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
+                       if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
                                val->_float = playercolor;
-                       host_client->edict->v->team = bottom + 1;
+                       host_client->edict->fields.server->team = bottom + 1;
                }
                host_client->colors = playercolor;
                if (host_client->old_colors != host_client->colors)
@@ -1117,15 +1140,15 @@ void Host_Kill_f (void)
                return;
        }
 
-       if (host_client->edict->v->health <= 0)
+       if (host_client->edict->fields.server->health <= 0)
        {
                SV_ClientPrint("Can't suicide -- already dead!\n");
                return;
        }
 
-       pr_global_struct->time = sv.time;
-       pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-       PR_ExecuteProgram (pr_global_struct->ClientKill, "QC function ClientKill is missing");
+       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");
 }
 
 
@@ -1164,7 +1187,7 @@ cvar_t cl_pmodel = {CVAR_SAVE, "_cl_pmodel", "0"};
 static void Host_PModel_f (void)
 {
        int i;
-       eval_t *val;
+       prvm_eval_t *val;
 
        if (Cmd_Argc () == 1)
        {
@@ -1183,7 +1206,7 @@ static void Host_PModel_f (void)
                return;
        }
 
-       if (host_client->edict && (val = GETEDICTFIELDVALUE(host_client->edict, eval_pmodel)))
+       if (host_client->edict && (val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_pmodel)))
                val->_float = i;
 }
 
@@ -1258,36 +1281,36 @@ void Host_Spawn_f (void)
                // if this is the last client to be connected, unpause
                sv.paused = false;
 
-               if ((f = ED_FindFunction ("RestoreGame")))
-               if ((RestoreGame = (func_t)(f - pr_functions)))
+               if ((f = PRVM_ED_FindFunction ("RestoreGame")))
+               if ((RestoreGame = (func_t)(f - prog->functions)))
                {
                        Con_DPrint("Calling RestoreGame\n");
-                       pr_global_struct->time = sv.time;
-                       pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-                       PR_ExecuteProgram (RestoreGame, "QC function RestoreGame is missing");
+                       prog->globals.server->time = sv.time;
+                       prog->globals.server->self = PRVM_EDICT_TO_PROG(host_client->edict);
+                       PRVM_ExecuteProgram (RestoreGame, "QC function RestoreGame is missing");
                }
        }
        else
        {
                // set up the edict
-               ED_ClearEdict(host_client->edict);
+               PRVM_ED_ClearEdict(host_client->edict);
 
-               //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PR_GetString(host_client->edict->v->netname), PR_GetString(host_client->edict->v->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(host_client->edict->fields.server->netname), PRVM_GetString(host_client->edict->fields.server->netname), host_client->name);
 
                // copy spawn parms out of the client_t
                for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
-                       (&pr_global_struct->parm1)[i] = host_client->spawn_parms[i];
+                       (&prog->globals.server->parm1)[i] = host_client->spawn_parms[i];
 
                // call the spawn function
                host_client->clientconnectcalled = true;
-               pr_global_struct->time = sv.time;
-               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
-               PR_ExecuteProgram (pr_global_struct->ClientConnect, "QC function ClientConnect is missing");
+               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");
 
                if ((Sys_DoubleTime() - host_client->connecttime) <= sv.time)
                        Con_Printf("%s entered the game\n", host_client->name);
 
-               PR_ExecuteProgram (pr_global_struct->PutClientInServer, "QC function PutClientInServer is missing");
+               PRVM_ExecuteProgram (prog->globals.server->PutClientInServer, "QC function PutClientInServer is missing");
        }
 
 
@@ -1321,19 +1344,19 @@ void Host_Spawn_f (void)
        // send some stats
        MSG_WriteByte (&host_client->message, svc_updatestat);
        MSG_WriteByte (&host_client->message, STAT_TOTALSECRETS);
-       MSG_WriteLong (&host_client->message, pr_global_struct->total_secrets);
+       MSG_WriteLong (&host_client->message, prog->globals.server->total_secrets);
 
        MSG_WriteByte (&host_client->message, svc_updatestat);
        MSG_WriteByte (&host_client->message, STAT_TOTALMONSTERS);
-       MSG_WriteLong (&host_client->message, pr_global_struct->total_monsters);
+       MSG_WriteLong (&host_client->message, prog->globals.server->total_monsters);
 
        MSG_WriteByte (&host_client->message, svc_updatestat);
        MSG_WriteByte (&host_client->message, STAT_SECRETS);
-       MSG_WriteLong (&host_client->message, pr_global_struct->found_secrets);
+       MSG_WriteLong (&host_client->message, prog->globals.server->found_secrets);
 
        MSG_WriteByte (&host_client->message, svc_updatestat);
        MSG_WriteByte (&host_client->message, STAT_MONSTERS);
-       MSG_WriteLong (&host_client->message, pr_global_struct->killed_monsters);
+       MSG_WriteLong (&host_client->message, prog->globals.server->killed_monsters);
 
        // send a fixangle
        // Never send a roll angle, because savegames can catch the server
@@ -1341,8 +1364,8 @@ void Host_Spawn_f (void)
        // and it won't happen if the game was just loaded, so you wind up
        // with a permanent head tilt
        MSG_WriteByte (&host_client->message, svc_setangle);
-       MSG_WriteAngle (&host_client->message, host_client->edict->v->angles[0], sv.protocol);
-       MSG_WriteAngle (&host_client->message, host_client->edict->v->angles[1], sv.protocol);
+       MSG_WriteAngle (&host_client->message, host_client->edict->fields.server->angles[0], sv.protocol);
+       MSG_WriteAngle (&host_client->message, host_client->edict->fields.server->angles[1], sv.protocol);
        MSG_WriteAngle (&host_client->message, 0, sv.protocol);
 
        SV_WriteClientdataToMessage (host_client, host_client->edict, &host_client->message, stats);
@@ -1466,7 +1489,7 @@ void Host_Give_f (void)
 {
        const char *t;
        int v;
-       eval_t *val;
+       prvm_eval_t *val;
 
        if (cmd_source == src_command)
        {
@@ -1501,128 +1524,128 @@ void Host_Give_f (void)
                        if (t[0] == '6')
                        {
                                if (t[1] == 'a')
-                                       host_client->edict->v->items = (int)host_client->edict->v->items | HIT_PROXIMITY_GUN;
+                                       host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_PROXIMITY_GUN;
                                else
-                                       host_client->edict->v->items = (int)host_client->edict->v->items | IT_GRENADE_LAUNCHER;
+                                       host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | IT_GRENADE_LAUNCHER;
                        }
                        else if (t[0] == '9')
-                               host_client->edict->v->items = (int)host_client->edict->v->items | HIT_LASER_CANNON;
+                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_LASER_CANNON;
                        else if (t[0] == '0')
-                               host_client->edict->v->items = (int)host_client->edict->v->items | HIT_MJOLNIR;
+                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | HIT_MJOLNIR;
                        else if (t[0] >= '2')
-                               host_client->edict->v->items = (int)host_client->edict->v->items | (IT_SHOTGUN << (t[0] - '2'));
+                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
                }
                else
                {
                        if (t[0] >= '2')
-                               host_client->edict->v->items = (int)host_client->edict->v->items | (IT_SHOTGUN << (t[0] - '2'));
+                               host_client->edict->fields.server->items = (int)host_client->edict->fields.server->items | (IT_SHOTGUN << (t[0] - '2'));
                }
                break;
 
        case 's':
-               if (gamemode == GAME_ROGUE && (val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_shells1)))
+               if (gamemode == GAME_ROGUE && (val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_shells1)))
                        val->_float = v;
 
-               host_client->edict->v->ammo_shells = v;
+               host_client->edict->fields.server->ammo_shells = v;
                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {
-                       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_nails1)))
+                       if ((val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_nails1)))
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
-                                       host_client->edict->v->ammo_nails = v;
+                               if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_nails = v;
                        }
                }
                else
                {
-                       host_client->edict->v->ammo_nails = v;
+                       host_client->edict->fields.server->ammo_nails = v;
                }
                break;
        case 'l':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_lava_nails);
+                       val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_lava_nails);
                        if (val)
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon > IT_LIGHTNING)
-                                       host_client->edict->v->ammo_nails = v;
+                               if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_nails = v;
                        }
                }
                break;
        case 'r':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_rockets1);
+                       val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_rockets1);
                        if (val)
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
-                                       host_client->edict->v->ammo_rockets = v;
+                               if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_rockets = v;
                        }
                }
                else
                {
-                       host_client->edict->v->ammo_rockets = v;
+                       host_client->edict->fields.server->ammo_rockets = v;
                }
                break;
        case 'm':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_multi_rockets);
+                       val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_multi_rockets);
                        if (val)
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon > IT_LIGHTNING)
-                                       host_client->edict->v->ammo_rockets = v;
+                               if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_rockets = v;
                        }
                }
                break;
        case 'h':
-               host_client->edict->v->health = v;
+               host_client->edict->fields.server->health = v;
                break;
        case 'c':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_cells1);
+                       val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_cells1);
                        if (val)
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
-                                       host_client->edict->v->ammo_cells = v;
+                               if (host_client->edict->fields.server->weapon <= IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_cells = v;
                        }
                }
                else
                {
-                       host_client->edict->v->ammo_cells = v;
+                       host_client->edict->fields.server->ammo_cells = v;
                }
                break;
        case 'p':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_plasma);
+                       val = PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_ammo_plasma);
                        if (val)
                        {
                                val->_float = v;
-                               if (host_client->edict->v->weapon > IT_LIGHTNING)
-                                       host_client->edict->v->ammo_cells = v;
+                               if (host_client->edict->fields.server->weapon > IT_LIGHTNING)
+                                       host_client->edict->fields.server->ammo_cells = v;
                        }
                }
                break;
        }
 }
 
-edict_t        *FindViewthing (void)
+prvm_edict_t   *FindViewthing (void)
 {
        int             i;
-       edict_t *e;
+       prvm_edict_t    *e;
 
-       for (i=0 ; i<sv.num_edicts ; i++)
+       for (i=0 ; i<prog->num_edicts ; i++)
        {
-               e = EDICT_NUM(i);
-               if (!strcmp (PR_GetString(e->v->classname), "viewthing"))
+               e = PRVM_EDICT_NUM(i);
+               if (!strcmp (PRVM_GetString(e->fields.server->classname), "viewthing"))
                        return e;
        }
        Con_Print("No viewthing on map\n");
@@ -1636,7 +1659,7 @@ Host_Viewmodel_f
 */
 void Host_Viewmodel_f (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        model_t *m;
 
        e = FindViewthing ();
@@ -1650,8 +1673,8 @@ void Host_Viewmodel_f (void)
                return;
        }
 
-       e->v->frame = 0;
-       cl.model_precache[(int)e->v->modelindex] = m;
+       e->fields.server->frame = 0;
+       cl.model_precache[(int)e->fields.server->modelindex] = m;
 }
 
 /*
@@ -1661,20 +1684,20 @@ Host_Viewframe_f
 */
 void Host_Viewframe_f (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        int             f;
        model_t *m;
 
        e = FindViewthing ();
        if (!e)
                return;
-       m = cl.model_precache[(int)e->v->modelindex];
+       m = cl.model_precache[(int)e->fields.server->modelindex];
 
        f = atoi(Cmd_Argv(1));
        if (f >= m->numframes)
                f = m->numframes-1;
 
-       e->v->frame = f;
+       e->fields.server->frame = f;
 }
 
 
@@ -1693,19 +1716,19 @@ Host_Viewnext_f
 */
 void Host_Viewnext_f (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        model_t *m;
 
        e = FindViewthing ();
        if (!e)
                return;
-       m = cl.model_precache[(int)e->v->modelindex];
+       m = cl.model_precache[(int)e->fields.server->modelindex];
 
-       e->v->frame = e->v->frame + 1;
-       if (e->v->frame >= m->numframes)
-               e->v->frame = m->numframes - 1;
+       e->fields.server->frame = e->fields.server->frame + 1;
+       if (e->fields.server->frame >= m->numframes)
+               e->fields.server->frame = m->numframes - 1;
 
-       PrintFrameName (m, e->v->frame);
+       PrintFrameName (m, e->fields.server->frame);
 }
 
 /*
@@ -1715,20 +1738,20 @@ Host_Viewprev_f
 */
 void Host_Viewprev_f (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        model_t *m;
 
        e = FindViewthing ();
        if (!e)
                return;
 
-       m = cl.model_precache[(int)e->v->modelindex];
+       m = cl.model_precache[(int)e->fields.server->modelindex];
 
-       e->v->frame = e->v->frame - 1;
-       if (e->v->frame < 0)
-               e->v->frame = 0;
+       e->fields.server->frame = e->fields.server->frame - 1;
+       if (e->fields.server->frame < 0)
+               e->fields.server->frame = 0;
 
-       PrintFrameName (m, e->v->frame);
+       PrintFrameName (m, e->fields.server->frame);
 }
 
 /*
index a512ef8..a143524 100644 (file)
@@ -75,11 +75,12 @@ OBJ_COMMON= \
        palette.o \
        polygon.o \
        portals.o \
-       pr_cmds.o \
-       pr_edict.o \
-       pr_exec.o \
+#      pr_cmds.o \
+#      pr_edict.o \
+#      pr_exec.o \
        protocol.o \
        mvm_cmds.o \
+       svvm_cmds.o \
        prvm_cmds.o \
        prvm_edict.o \
        prvm_exec.o \
diff --git a/menu.c b/menu.c
index 130d5bd..466e9f1 100644 (file)
--- a/menu.c
+++ b/menu.c
@@ -4629,8 +4629,8 @@ void MP_Keydown (int key, char ascii)
        *prog->time = realtime;
 
        // pass key
-       prog->globals[OFS_PARM0] = (float) key;
-       prog->globals[OFS_PARM1] = (float) ascii;
+       prog->globals.generic[OFS_PARM0] = (float) key;
+       prog->globals.generic[OFS_PARM1] = (float) ascii;
        PRVM_ExecuteProgram(m_keydown, M_F_KEYDOWN"(float key, float ascii) required\n");
 
        PRVM_End;
@@ -4694,9 +4694,10 @@ void MP_Init (void)
        PRVM_Begin;
        PRVM_InitProg(PRVM_MENUPROG);
 
-       prog->crc = M_PROGHEADER_CRC;
+       prog->headercrc = M_PROGHEADER_CRC;
        prog->edictprivate_size = 0; // no private struct used
        prog->name = M_NAME;
+       prog->num_edicts = 1;
        prog->limit_edicts = M_MAX_EDICTS;
        prog->extensionstring = vm_m_extensions;
        prog->builtins = vm_m_builtins;
@@ -4708,7 +4709,7 @@ void MP_Init (void)
        // allocate the mempools
        prog->progs_mempool = Mem_AllocPool(M_PROG_FILENAME, 0, NULL);
 
-       PRVM_LoadProgs(M_PROG_FILENAME, m_numrequiredfunc, m_required_func);
+       PRVM_LoadProgs(M_PROG_FILENAME, m_numrequiredfunc, m_required_func, 0, NULL);
 
        // set m_draw and m_keydown
        m_draw = (func_t) (PRVM_ED_FindFunction(M_F_DRAW) - prog->functions);
index 5636ad0..401b33d 100644 (file)
@@ -6,6 +6,54 @@
 char *vm_m_extensions =
 "DP_CINEMATIC_DPV";
 
+/*
+=========
+VM_M_precache_file
+
+string precache_file(string)
+=========
+*/
+void VM_M_precache_file (void)
+{      // precache_file is only used to copy files with qcc, it does nothing
+       VM_SAFEPARMCOUNT(1,VM_precache_file);
+
+       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
+}
+
+/*
+=========
+VM_M_preache_error
+
+used instead of the other VM_precache_* functions in the builtin list
+=========
+*/
+
+void VM_M_precache_error (void)
+{
+       PRVM_ERROR ("PF_Precache_*: Precache can only be done in spawn functions");
+}
+
+/*
+=========
+VM_M_precache_sound
+
+string precache_sound (string sample)
+=========
+*/
+void VM_M_precache_sound (void)
+{
+       const char      *s;
+
+       VM_SAFEPARMCOUNT(1, VM_precache_sound);
+
+       s = PRVM_G_STRING(OFS_PARM0);
+       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
+       VM_CheckEmptyString (s);
+
+       if(snd_initialized.integer && !S_PrecacheSound (s,true, true))
+               Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
+}
+
 /*
 =========
 VM_M_setmousetarget
@@ -75,7 +123,7 @@ void VM_M_setkeydest(void)
                // key_dest = key_message
                // break;
        default:
-               PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]);
+               PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals.generic[OFS_PARM0]);
        }
 }
 
@@ -672,6 +720,98 @@ void VM_M_addwantedserverlistkey( void )
        VM_SAFEPARMCOUNT( 1, VM_M_addwantedserverlistkey );
 }
 
+/*
+===============================================================================
+MESSAGE WRITING
+
+used only for client and menu
+severs uses VM_SV_...
+
+Write*(* data, float type, float to)
+
+===============================================================================
+*/
+
+#define        MSG_BROADCAST   0               // unreliable to all
+#define        MSG_ONE                 1               // reliable to one (msg_entity)
+#define        MSG_ALL                 2               // reliable to all
+#define        MSG_INIT                3               // write to the init string
+
+sizebuf_t *VM_WriteDest (void)
+{
+       int             dest;
+       int             destclient;
+
+       if(!sv.active)
+               PRVM_ERROR("VM_WriteDest: game is not server (%s)\n", PRVM_NAME);
+
+       dest = PRVM_G_FLOAT(OFS_PARM1);
+       switch (dest)
+       {
+       case MSG_BROADCAST:
+               return &sv.datagram;
+
+       case MSG_ONE:
+               destclient = (int) PRVM_G_FLOAT(OFS_PARM2);
+               if (destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active)
+                       PRVM_ERROR("VM_clientcommand: %s: invalid client !\n", PRVM_NAME);
+
+               return &svs.clients[destclient].message;
+
+       case MSG_ALL:
+               return &sv.reliable_datagram;
+
+       case MSG_INIT:
+               return &sv.signon;
+
+       default:
+               PRVM_ERROR ("WriteDest: bad destination");
+               break;
+       }
+
+       return NULL;
+}
+
+void VM_M_WriteByte (void)
+{
+       MSG_WriteByte (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+}
+
+void VM_M_WriteChar (void)
+{
+       MSG_WriteChar (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+}
+
+void VM_M_WriteShort (void)
+{
+       MSG_WriteShort (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+}
+
+void VM_M_WriteLong (void)
+{
+       MSG_WriteLong (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
+}
+
+void VM_M_WriteAngle (void)
+{
+       MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
+}
+
+void VM_M_WriteCoord (void)
+{
+       MSG_WriteCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
+}
+
+void VM_M_WriteString (void)
+{
+       MSG_WriteString (VM_WriteDest(), PRVM_G_STRING(OFS_PARM0));
+}
+
+void VM_M_WriteEntity (void)
+{
+       MSG_WriteShort (VM_WriteDest(), PRVM_G_EDICTNUM(OFS_PARM0));
+}
+
 prvm_builtin_t vm_m_builtins[] = {
        0, // to be consistent with the old vm
        // common builtings (mostly)
@@ -702,8 +842,8 @@ prvm_builtin_t vm_m_builtins[] = {
        VM_findfloat,
        VM_findchain,
        VM_findchainfloat,
-       VM_precache_file,
-       VM_precache_sound,
+       VM_M_precache_file,
+       VM_M_precache_sound,
        VM_coredump,    // 30
        VM_traceon,
        VM_traceoff,
@@ -767,14 +907,14 @@ prvm_builtin_t vm_m_builtins[] = {
        e100,                   // 300
        e100,                   // 400
        // msg functions
-       VM_WriteByte,
-       VM_WriteChar,
-       VM_WriteShort,
-       VM_WriteLong,
-       VM_WriteAngle,
-       VM_WriteCoord,
-       VM_WriteString,
-       VM_WriteEntity, // 408
+       VM_M_WriteByte,
+       VM_M_WriteChar,
+       VM_M_WriteShort,
+       VM_M_WriteLong,
+       VM_M_WriteAngle,
+       VM_M_WriteCoord,
+       VM_M_WriteString,
+       VM_M_WriteEntity,       // 408
        0,
        0,                              // 410
        e10,                    // 420
index e5fe3d8..ba94089 100755 (executable)
--- a/netconn.c
+++ b/netconn.c
@@ -1583,7 +1583,7 @@ int NetConn_ServerParsePacket(lhnetsocket_t *mysocket, qbyte *data, int length,
                                                        MSG_WriteByte(&net_message, playerNumber);
                                                        MSG_WriteString(&net_message, client->name);
                                                        MSG_WriteLong(&net_message, client->colors);
-                                                       MSG_WriteLong(&net_message, (int)client->edict->v->frags);
+                                                       MSG_WriteLong(&net_message, (int)client->edict->fields.server->frags);
                                                        MSG_WriteLong(&net_message, (int)(realtime - client->connecttime));
                                                        MSG_WriteString(&net_message, client->netconnection ? client->netconnection->address : "botclient");
                                                        *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
index 52555c9..1fe17e1 100644 (file)
--- a/pr_cmds.c
+++ b/pr_cmds.c
@@ -37,7 +37,7 @@ static char *PR_GetTempString(void)
        return s;
 }
 
-#define        RETURN_EDICT(e) (G_INT(OFS_RETURN) = EDICT_TO_PROG(e))
+#define        RETURN_EDICT(e) (PRVM_G_INT(OFS_RETURN) = PRVM_EDICT_TO_PROG(e))
 #define PF_WARNING(s) do{Con_Printf(s);PR_PrintState();return;}while(0)
 #define PF_ERROR(s) do{Host_Error(s);return;}while(0)
 
@@ -60,7 +60,7 @@ void PF_VarString(int first, char *out, int outlength)
        outend = out + outlength - 1;
        for (i = first;i < pr_argc && out < outend;i++)
        {
-               s = G_STRING((OFS_PARM0+i*3));
+               s = PRVM_G_STRING((OFS_PARM0+i*3));
                while (out < outend && *s)
                        *out++ = *s++;
        }
@@ -207,7 +207,7 @@ checkextension(extensionname)
 */
 void PF_checkextension (void)
 {
-       G_FLOAT(OFS_RETURN) = checkextension(G_STRING(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = checkextension(PRVM_G_STRING(OFS_PARM0));
 }
 
 /*
@@ -222,12 +222,12 @@ error(value)
 */
 void PF_error (void)
 {
-       edict_t *ed;
+       prvm_edict_t    *ed;
        char string[STRINGTEMP_LENGTH];
 
        PF_VarString(0, string, sizeof(string));
-       Con_Printf("======SERVER ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name), string);
-       ed = PROG_TO_EDICT(pr_global_struct->self);
+       Con_Printf("======SERVER ERROR in %s:\n%s\n", PRVM_GetString(pr_xfunction->s_name), string);
+       ed = PRVM_PROG_TO_EDICT(prog->globals.server->self);
        ED_Print(ed);
 
        PF_ERROR("Program error");
@@ -245,12 +245,12 @@ objerror(value)
 */
 void PF_objerror (void)
 {
-       edict_t *ed;
+       prvm_edict_t    *ed;
        char string[STRINGTEMP_LENGTH];
 
        PF_VarString(0, string, sizeof(string));
-       Con_Printf("======OBJECT ERROR in %s:\n%s\n", PR_GetString(pr_xfunction->s_name), string);
-       ed = PROG_TO_EDICT(pr_global_struct->self);
+       Con_Printf("======OBJECT ERROR in %s:\n%s\n", PRVM_GetString(pr_xfunction->s_name), string);
+       ed = PRVM_PROG_TO_EDICT(prog->globals.server->self);
        ED_Print(ed);
        ED_Free (ed);
 }
@@ -266,7 +266,7 @@ makevectors(vector)
 */
 void PF_makevectors (void)
 {
-       AngleVectors (G_VECTOR(OFS_PARM0), pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
+       AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up);
 }
 
 /*
@@ -279,8 +279,8 @@ vectorvectors(vector, vector)
 */
 void PF_vectorvectors (void)
 {
-       VectorNormalize2(G_VECTOR(OFS_PARM0), pr_global_struct->v_forward);
-       VectorVectors(pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up);
+       VectorNormalize2(PRVM_G_VECTOR(OFS_PARM0), prog->globals.server->v_forward);
+       VectorVectors(prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up);
 }
 
 /*
@@ -294,21 +294,21 @@ setorigin (entity, origin)
 */
 void PF_setorigin (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        float   *org;
 
-       e = G_EDICT(OFS_PARM0);
-       if (e == sv.edicts)
+       e = PRVM_G_EDICT(OFS_PARM0);
+       if (e == prog->edicts)
                PF_WARNING("setorigin: can not modify world entity\n");
-       if (e->e->free)
+       if (e->priv.server->free)
                PF_WARNING("setorigin: can not modify free entity\n");
-       org = G_VECTOR(OFS_PARM1);
-       VectorCopy (org, e->v->origin);
+       org = PRVM_G_VECTOR(OFS_PARM1);
+       VectorCopy (org, e->fields.server->origin);
        SV_LinkEdict (e, false);
 }
 
 
-void SetMinMaxSize (edict_t *e, float *min, float *max, qboolean rotate)
+void SetMinMaxSize (prvm_edict_t *e, float *min, float *max, qboolean rotate)
 {
        int             i;
 
@@ -317,9 +317,9 @@ void SetMinMaxSize (edict_t *e, float *min, float *max, qboolean rotate)
                        PF_ERROR("SetMinMaxSize: backwards mins/maxs\n");
 
 // set derived values
-       VectorCopy (min, e->v->mins);
-       VectorCopy (max, e->v->maxs);
-       VectorSubtract (max, min, e->v->size);
+       VectorCopy (min, e->fields.server->mins);
+       VectorCopy (max, e->fields.server->maxs);
+       VectorSubtract (max, min, e->fields.server->size);
 
        SV_LinkEdict (e, false);
 }
@@ -336,16 +336,16 @@ setsize (entity, minvector, maxvector)
 */
 void PF_setsize (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        float   *min, *max;
 
-       e = G_EDICT(OFS_PARM0);
-       if (e == sv.edicts)
+       e = PRVM_G_EDICT(OFS_PARM0);
+       if (e == prog->edicts)
                PF_WARNING("setsize: can not modify world entity\n");
-       if (e->e->free)
+       if (e->priv.server->free)
                PF_WARNING("setsize: can not modify free entity\n");
-       min = G_VECTOR(OFS_PARM1);
-       max = G_VECTOR(OFS_PARM2);
+       min = PRVM_G_VECTOR(OFS_PARM1);
+       max = PRVM_G_VECTOR(OFS_PARM2);
        SetMinMaxSize (e, min, max, false);
 }
 
@@ -360,18 +360,18 @@ setmodel(entity, model)
 static vec3_t quakemins = {-16, -16, -16}, quakemaxs = {16, 16, 16};
 void PF_setmodel (void)
 {
-       edict_t *e;
+       prvm_edict_t    *e;
        model_t *mod;
        int             i;
 
-       e = G_EDICT(OFS_PARM0);
-       if (e == sv.edicts)
+       e = PRVM_G_EDICT(OFS_PARM0);
+       if (e == prog->edicts)
                PF_WARNING("setmodel: can not modify world entity\n");
-       if (e->e->free)
+       if (e->priv.server->free)
                PF_WARNING("setmodel: can not modify free entity\n");
-       i = SV_ModelIndex(G_STRING(OFS_PARM1), 1);
-       e->v->model = PR_SetEngineString(sv.model_precache[i]);
-       e->v->modelindex = i;
+       i = SV_ModelIndex(PRVM_G_STRING(OFS_PARM1), 1);
+       e->fields.server->model = PRVM_SetEngineString(sv.model_precache[i]);
+       e->fields.server->modelindex = i;
 
        mod = sv.models[i];
 
@@ -417,7 +417,7 @@ void PF_sprint (void)
        int                     entnum;
        char string[STRINGTEMP_LENGTH];
 
-       entnum = G_EDICTNUM(OFS_PARM0);
+       entnum = PRVM_G_EDICTNUM(OFS_PARM0);
 
        if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
        {
@@ -447,7 +447,7 @@ void PF_centerprint (void)
        int                     entnum;
        char string[STRINGTEMP_LENGTH];
 
-       entnum = G_EDICTNUM(OFS_PARM0);
+       entnum = PRVM_G_EDICTNUM(OFS_PARM0);
 
        if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
        {
@@ -475,7 +475,7 @@ void PF_normalize (void)
        vec3_t  newvalue;
        float   new;
 
-       value1 = G_VECTOR(OFS_PARM0);
+       value1 = PRVM_G_VECTOR(OFS_PARM0);
 
        new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
        new = sqrt(new);
@@ -490,7 +490,7 @@ void PF_normalize (void)
                newvalue[2] = value1[2] * new;
        }
 
-       VectorCopy (newvalue, G_VECTOR(OFS_RETURN));
+       VectorCopy (newvalue, PRVM_G_VECTOR(OFS_RETURN));
 }
 
 /*
@@ -505,12 +505,12 @@ void PF_vlen (void)
        float   *value1;
        float   new;
 
-       value1 = G_VECTOR(OFS_PARM0);
+       value1 = PRVM_G_VECTOR(OFS_PARM0);
 
        new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
        new = sqrt(new);
 
-       G_FLOAT(OFS_RETURN) = new;
+       PRVM_G_FLOAT(OFS_RETURN) = new;
 }
 
 /*
@@ -525,7 +525,7 @@ void PF_vectoyaw (void)
        float   *value1;
        float   yaw;
 
-       value1 = G_VECTOR(OFS_PARM0);
+       value1 = PRVM_G_VECTOR(OFS_PARM0);
 
        if (value1[1] == 0 && value1[0] == 0)
                yaw = 0;
@@ -536,7 +536,7 @@ void PF_vectoyaw (void)
                        yaw += 360;
        }
 
-       G_FLOAT(OFS_RETURN) = yaw;
+       PRVM_G_FLOAT(OFS_RETURN) = yaw;
 }
 
 
@@ -551,7 +551,7 @@ void PF_vectoangles (void)
 {
        double value1[3], forward, yaw, pitch;
 
-       VectorCopy(G_VECTOR(OFS_PARM0), value1);
+       VectorCopy(PRVM_G_VECTOR(OFS_PARM0), value1);
 
        if (value1[1] == 0 && value1[0] == 0)
        {
@@ -581,7 +581,7 @@ void PF_vectoangles (void)
                        pitch += 360;
        }
 
-       VectorSet(G_VECTOR(OFS_RETURN), pitch, yaw, 0);
+       VectorSet(PRVM_G_VECTOR(OFS_RETURN), pitch, yaw, 0);
 }
 
 /*
@@ -595,7 +595,7 @@ random()
 */
 void PF_random (void)
 {
-       G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
+       PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
 }
 
 /*
@@ -611,10 +611,10 @@ void PF_particle (void)
        float           color;
        float           count;
 
-       org = G_VECTOR(OFS_PARM0);
-       dir = G_VECTOR(OFS_PARM1);
-       color = G_FLOAT(OFS_PARM2);
-       count = G_FLOAT(OFS_PARM3);
+       org = PRVM_G_VECTOR(OFS_PARM0);
+       dir = PRVM_G_VECTOR(OFS_PARM1);
+       color = PRVM_G_FLOAT(OFS_PARM2);
+       count = PRVM_G_FLOAT(OFS_PARM3);
        SV_StartParticle (org, dir, color, count);
 }
 
@@ -632,10 +632,10 @@ void PF_ambientsound (void)
        float           vol, attenuation;
        int                     soundnum, large;
 
-       pos = G_VECTOR (OFS_PARM0);
-       samp = G_STRING(OFS_PARM1);
-       vol = G_FLOAT(OFS_PARM2);
-       attenuation = G_FLOAT(OFS_PARM3);
+       pos = PRVM_G_VECTOR (OFS_PARM0);
+       samp = PRVM_G_STRING(OFS_PARM1);
+       vol = PRVM_G_FLOAT(OFS_PARM2);
+       attenuation = PRVM_G_FLOAT(OFS_PARM3);
 
 // check to see if samp was properly precached
        soundnum = SV_SoundIndex(samp, 1);
@@ -684,15 +684,15 @@ void PF_sound (void)
 {
        const char      *sample;
        int                     channel;
-       edict_t         *entity;
+       prvm_edict_t            *entity;
        int             volume;
        float attenuation;
 
-       entity = G_EDICT(OFS_PARM0);
-       channel = G_FLOAT(OFS_PARM1);
-       sample = G_STRING(OFS_PARM2);
-       volume = G_FLOAT(OFS_PARM3) * 255;
-       attenuation = G_FLOAT(OFS_PARM4);
+       entity = PRVM_G_EDICT(OFS_PARM0);
+       channel = PRVM_G_FLOAT(OFS_PARM1);
+       sample = PRVM_G_STRING(OFS_PARM2);
+       volume = PRVM_G_FLOAT(OFS_PARM3) * 255;
+       attenuation = PRVM_G_FLOAT(OFS_PARM4);
 
        if (volume < 0 || volume > 255)
                PF_WARNING("SV_StartSound: volume must be in range 0-1\n");
@@ -734,29 +734,29 @@ void PF_traceline (void)
        float   *v1, *v2;
        trace_t trace;
        int             move;
-       edict_t *ent;
+       prvm_edict_t    *ent;
 
        pr_xfunction->builtinsprofile += 30;
 
-       v1 = G_VECTOR(OFS_PARM0);
-       v2 = G_VECTOR(OFS_PARM1);
-       move = G_FLOAT(OFS_PARM2);
-       ent = G_EDICT(OFS_PARM3);
+       v1 = PRVM_G_VECTOR(OFS_PARM0);
+       v2 = PRVM_G_VECTOR(OFS_PARM1);
+       move = PRVM_G_FLOAT(OFS_PARM2);
+       ent = PRVM_G_EDICT(OFS_PARM3);
 
        trace = SV_Move (v1, vec3_origin, vec3_origin, v2, move, ent);
 
-       pr_global_struct->trace_allsolid = trace.allsolid;
-       pr_global_struct->trace_startsolid = trace.startsolid;
-       pr_global_struct->trace_fraction = trace.fraction;
-       pr_global_struct->trace_inwater = trace.inwater;
-       pr_global_struct->trace_inopen = trace.inopen;
-       VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
-       VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
-       pr_global_struct->trace_plane_dist =  trace.plane.dist;
+       prog->globals.server->trace_allsolid = trace.allsolid;
+       prog->globals.server->trace_startsolid = trace.startsolid;
+       prog->globals.server->trace_fraction = trace.fraction;
+       prog->globals.server->trace_inwater = trace.inwater;
+       prog->globals.server->trace_inopen = trace.inopen;
+       VectorCopy (trace.endpos, prog->globals.server->trace_endpos);
+       VectorCopy (trace.plane.normal, prog->globals.server->trace_plane_normal);
+       prog->globals.server->trace_plane_dist =  trace.plane.dist;
        if (trace.ent)
-               pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(trace.ent);
        else
-               pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
        // FIXME: add trace_endcontents
 }
 
@@ -778,61 +778,61 @@ void PF_tracebox (void)
        float   *v1, *v2, *m1, *m2;
        trace_t trace;
        int             move;
-       edict_t *ent;
+       prvm_edict_t    *ent;
 
        pr_xfunction->builtinsprofile += 30;
 
-       v1 = G_VECTOR(OFS_PARM0);
-       m1 = G_VECTOR(OFS_PARM1);
-       m2 = G_VECTOR(OFS_PARM2);
-       v2 = G_VECTOR(OFS_PARM3);
-       move = G_FLOAT(OFS_PARM4);
-       ent = G_EDICT(OFS_PARM5);
+       v1 = PRVM_G_VECTOR(OFS_PARM0);
+       m1 = PRVM_G_VECTOR(OFS_PARM1);
+       m2 = PRVM_G_VECTOR(OFS_PARM2);
+       v2 = PRVM_G_VECTOR(OFS_PARM3);
+       move = PRVM_G_FLOAT(OFS_PARM4);
+       ent = PRVM_G_EDICT(OFS_PARM5);
 
        trace = SV_Move (v1, m1, m2, v2, move, ent);
 
-       pr_global_struct->trace_allsolid = trace.allsolid;
-       pr_global_struct->trace_startsolid = trace.startsolid;
-       pr_global_struct->trace_fraction = trace.fraction;
-       pr_global_struct->trace_inwater = trace.inwater;
-       pr_global_struct->trace_inopen = trace.inopen;
-       VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
-       VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
-       pr_global_struct->trace_plane_dist =  trace.plane.dist;
+       prog->globals.server->trace_allsolid = trace.allsolid;
+       prog->globals.server->trace_startsolid = trace.startsolid;
+       prog->globals.server->trace_fraction = trace.fraction;
+       prog->globals.server->trace_inwater = trace.inwater;
+       prog->globals.server->trace_inopen = trace.inopen;
+       VectorCopy (trace.endpos, prog->globals.server->trace_endpos);
+       VectorCopy (trace.plane.normal, prog->globals.server->trace_plane_normal);
+       prog->globals.server->trace_plane_dist =  trace.plane.dist;
        if (trace.ent)
-               pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(trace.ent);
        else
-               pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
 }
 
-extern trace_t SV_Trace_Toss (edict_t *ent, edict_t *ignore);
-void PF_TraceToss (void)
+extern trace_t SV_Trace_Toss (prvm_edict_t *ent, prvm_edict_t *ignore);
+void PF_tracetoss (void)
 {
        trace_t trace;
-       edict_t *ent;
-       edict_t *ignore;
+       prvm_edict_t    *ent;
+       prvm_edict_t    *ignore;
 
        pr_xfunction->builtinsprofile += 600;
 
-       ent = G_EDICT(OFS_PARM0);
-       if (ent == sv.edicts)
+       ent = PRVM_G_EDICT(OFS_PARM0);
+       if (ent == prog->edicts)
                PF_WARNING("tracetoss: can not use world entity\n");
-       ignore = G_EDICT(OFS_PARM1);
+       ignore = PRVM_G_EDICT(OFS_PARM1);
 
        trace = SV_Trace_Toss (ent, ignore);
 
-       pr_global_struct->trace_allsolid = trace.allsolid;
-       pr_global_struct->trace_startsolid = trace.startsolid;
-       pr_global_struct->trace_fraction = trace.fraction;
-       pr_global_struct->trace_inwater = trace.inwater;
-       pr_global_struct->trace_inopen = trace.inopen;
-       VectorCopy (trace.endpos, pr_global_struct->trace_endpos);
-       VectorCopy (trace.plane.normal, pr_global_struct->trace_plane_normal);
-       pr_global_struct->trace_plane_dist =  trace.plane.dist;
+       prog->globals.server->trace_allsolid = trace.allsolid;
+       prog->globals.server->trace_startsolid = trace.startsolid;
+       prog->globals.server->trace_fraction = trace.fraction;
+       prog->globals.server->trace_inwater = trace.inwater;
+       prog->globals.server->trace_inopen = trace.inopen;
+       VectorCopy (trace.endpos, prog->globals.server->trace_endpos);
+       VectorCopy (trace.plane.normal, prog->globals.server->trace_plane_normal);
+       prog->globals.server->trace_plane_dist =  trace.plane.dist;
        if (trace.ent)
-               pr_global_struct->trace_ent = EDICT_TO_PROG(trace.ent);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(trace.ent);
        else
-               pr_global_struct->trace_ent = EDICT_TO_PROG(sv.edicts);
+               prog->globals.server->trace_ent = PRVM_EDICT_TO_PROG(prog->edicts);
 }
 
 
@@ -858,7 +858,7 @@ qbyte checkpvs[MAX_MAP_LEAFS/8];
 int PF_newcheckclient (int check)
 {
        int             i;
-       edict_t *ent;
+       prvm_edict_t    *ent;
        vec3_t  org;
 
 // cycle to the next one
@@ -877,16 +877,16 @@ int PF_newcheckclient (int check)
                if (i == svs.maxclients+1)
                        i = 1;
                // look up the client's edict
-               ent = EDICT_NUM(i);
+               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->e->free || ent->v->health <= 0 || ((int)ent->v->flags & FL_NOTARGET)))
+               if (i != check && (ent->priv.server->free || ent->fields.server->health <= 0 || ((int)ent->fields.server->flags & FL_NOTARGET)))
                        continue;
                // found a valid client (possibly the same one again)
                break;
        }
 
 // get the PVS for the entity
-       VectorAdd(ent->v->origin, ent->v->view_ofs, org);
+       VectorAdd(ent->fields.server->origin, ent->fields.server->view_ofs, org);
        checkpvsbytes = 0;
        if (sv.worldmodel && sv.worldmodel->brush.FatPVS)
                checkpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, org, 0, checkpvs, sizeof(checkpvs));
@@ -912,7 +912,7 @@ name checkclient ()
 int c_invis, c_notvis;
 void PF_checkclient (void)
 {
-       edict_t *ent, *self;
+       prvm_edict_t    *ent, *self;
        vec3_t  view;
 
        // find a new check if on a new frame
@@ -923,20 +923,20 @@ void PF_checkclient (void)
        }
 
        // return check if it might be visible
-       ent = EDICT_NUM(sv.lastcheck);
-       if (ent->e->free || ent->v->health <= 0)
+       ent = PRVM_EDICT_NUM(sv.lastcheck);
+       if (ent->priv.server->free || ent->fields.server->health <= 0)
        {
-               RETURN_EDICT(sv.edicts);
+               RETURN_EDICT(prog->edicts);
                return;
        }
 
        // if current entity can't possibly see the check entity, return 0
-       self = PROG_TO_EDICT(pr_global_struct->self);
-       VectorAdd(self->v->origin, self->v->view_ofs, view);
+       self = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       VectorAdd(self->fields.server->origin, self->fields.server->view_ofs, view);
        if (sv.worldmodel && checkpvsbytes && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, checkpvs, view, view))
        {
                c_notvis++;
-               RETURN_EDICT(sv.edicts);
+               RETURN_EDICT(prog->edicts);
                return;
        }
 
@@ -963,13 +963,13 @@ void PF_stuffcmd (void)
        const char      *str;
        client_t        *old;
 
-       entnum = G_EDICTNUM(OFS_PARM0);
+       entnum = PRVM_G_EDICTNUM(OFS_PARM0);
        if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
        {
                Con_Print("Can't stuffcmd to a non-client\n");
                return;
        }
-       str = G_STRING(OFS_PARM1);
+       str = PRVM_G_STRING(OFS_PARM1);
 
        old = host_client;
        host_client = svs.clients + entnum-1;
@@ -988,7 +988,7 @@ localcmd (string)
 */
 void PF_localcmd (void)
 {
-       Cbuf_AddText(G_STRING(OFS_PARM0));
+       Cbuf_AddText(PRVM_G_STRING(OFS_PARM0));
 }
 
 /*
@@ -1000,7 +1000,7 @@ float cvar (string)
 */
 void PF_cvar (void)
 {
-       G_FLOAT(OFS_RETURN) = Cvar_VariableValue(G_STRING(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(PRVM_G_STRING(OFS_PARM0));
 }
 
 /*
@@ -1012,7 +1012,7 @@ float cvar (string)
 */
 void PF_cvar_set (void)
 {
-       Cvar_Set(G_STRING(OFS_PARM0), G_STRING(OFS_PARM1));
+       Cvar_Set(PRVM_G_STRING(OFS_PARM0), PRVM_G_STRING(OFS_PARM1));
 }
 
 /*
@@ -1026,17 +1026,17 @@ findradius (origin, radius)
 */
 void PF_findradius (void)
 {
-       edict_t *ent, *chain;
+       prvm_edict_t *ent, *chain;
        vec_t radius, radius2;
        vec3_t org, eorg, mins, maxs;
        int i;
        int numtouchedicts;
-       edict_t *touchedicts[MAX_EDICTS];
+       prvm_edict_t *touchedicts[MAX_EDICTS];
 
-       chain = (edict_t *)sv.edicts;
+       chain = (prvm_edict_t *)prog->edicts;
 
-       VectorCopy(G_VECTOR(OFS_PARM0), org);
-       radius = G_FLOAT(OFS_PARM1);
+       VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
+       radius = PRVM_G_FLOAT(OFS_PARM1);
        radius2 = radius * radius;
 
        mins[0] = org[0] - (radius + 1);
@@ -1058,23 +1058,23 @@ void PF_findradius (void)
                pr_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->v->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
+               if (ent->fields.server->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
-               VectorSubtract(org, ent->v->origin, eorg);
+               VectorSubtract(org, ent->fields.server->origin, eorg);
                if (sv_gameplayfix_findradiusdistancetobox.integer)
                {
-                       eorg[0] -= bound(ent->v->mins[0], eorg[0], ent->v->maxs[0]);
-                       eorg[1] -= bound(ent->v->mins[1], eorg[1], ent->v->maxs[1]);
-                       eorg[2] -= bound(ent->v->mins[2], eorg[2], ent->v->maxs[2]);
+                       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]);
                }
                else
-                       VectorMAMAM(1, eorg, 0.5f, ent->v->mins, 0.5f, ent->v->maxs, eorg);
+                       VectorMAMAM(1, eorg, 0.5f, ent->fields.server->mins, 0.5f, ent->fields.server->maxs, eorg);
                if (DotProduct(eorg, eorg) < radius2)
                {
-                       ent->v->chain = EDICT_TO_PROG(chain);
+                       ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
                        chain = ent;
                }
        }
@@ -1102,42 +1102,42 @@ void PF_ftos (void)
 {
        float v;
        char *s;
-       v = G_FLOAT(OFS_PARM0);
+       v = PRVM_G_FLOAT(OFS_PARM0);
 
        s = PR_GetTempString();
        if ((float)((int)v) == v)
                sprintf(s, "%i", (int)v);
        else
                sprintf(s, "%f", v);
-       G_INT(OFS_RETURN) = PR_SetEngineString(s);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
 }
 
 void PF_fabs (void)
 {
        float   v;
-       v = G_FLOAT(OFS_PARM0);
-       G_FLOAT(OFS_RETURN) = fabs(v);
+       v = PRVM_G_FLOAT(OFS_PARM0);
+       PRVM_G_FLOAT(OFS_RETURN) = fabs(v);
 }
 
 void PF_vtos (void)
 {
        char *s;
        s = PR_GetTempString();
-       sprintf (s, "'%5.1f %5.1f %5.1f'", G_VECTOR(OFS_PARM0)[0], G_VECTOR(OFS_PARM0)[1], G_VECTOR(OFS_PARM0)[2]);
-       G_INT(OFS_RETURN) = PR_SetEngineString(s);
+       sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
 }
 
 void PF_etos (void)
 {
        char *s;
        s = PR_GetTempString();
-       sprintf (s, "entity %i", G_EDICTNUM(OFS_PARM0));
-       G_INT(OFS_RETURN) = PR_SetEngineString(s);
+       sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
 }
 
 void PF_Spawn (void)
 {
-       edict_t *ed;
+       prvm_edict_t    *ed;
        pr_xfunction->builtinsprofile += 20;
        ed = ED_Alloc();
        RETURN_EDICT(ed);
@@ -1145,16 +1145,16 @@ void PF_Spawn (void)
 
 void PF_Remove (void)
 {
-       edict_t *ed;
+       prvm_edict_t    *ed;
        pr_xfunction->builtinsprofile += 20;
 
-       ed = G_EDICT(OFS_PARM0);
-       if (ed == sv.edicts)
+       ed = PRVM_G_EDICT(OFS_PARM0);
+       if (ed == prog->edicts)
                PF_WARNING("remove: tried to remove world\n");
-       if (NUM_FOR_EDICT(ed) <= svs.maxclients)
+       if (PRVM_NUM_FOR_EDICT(ed) <= svs.maxclients)
                PF_WARNING("remove: tried to remove a client\n");
        // LordHavoc: not an error because id1 progs did this in some cases (killtarget removes entities, even if they are already removed in some cases...)
-       if (ed->e->free && developer.integer)
+       if (ed->priv.server->free && developer.integer)
                PF_WARNING("remove: tried to remove an entity that was already removed\n");
        ED_Free (ed);
 }
@@ -1166,22 +1166,22 @@ void PF_Find (void)
        int             e;
        int             f;
        const char      *s, *t;
-       edict_t *ed;
+       prvm_edict_t    *ed;
 
-       e = G_EDICTNUM(OFS_PARM0);
-       f = G_INT(OFS_PARM1);
-       s = G_STRING(OFS_PARM2);
+       e = PRVM_G_EDICTNUM(OFS_PARM0);
+       f = PRVM_G_INT(OFS_PARM1);
+       s = PRVM_G_STRING(OFS_PARM2);
        if (!s || !s[0])
        {
-               RETURN_EDICT(sv.edicts);
+               RETURN_EDICT(prog->edicts);
                return;
        }
 
-       for (e++ ; e < sv.num_edicts ; e++)
+       for (e++ ; e < prog->num_edicts ; e++)
        {
                pr_xfunction->builtinsprofile++;
-               ed = EDICT_NUM(e);
-               if (ed->e->free)
+               ed = PRVM_EDICT_NUM(e);
+               if (ed->priv.server->free)
                        continue;
                t = E_STRING(ed,f);
                if (!t)
@@ -1193,7 +1193,7 @@ void PF_Find (void)
                }
        }
 
-       RETURN_EDICT(sv.edicts);
+       RETURN_EDICT(prog->edicts);
 }
 
 // LordHavoc: added this for searching float, int, and entity reference fields
@@ -1202,17 +1202,17 @@ void PF_FindFloat (void)
        int             e;
        int             f;
        float   s;
-       edict_t *ed;
+       prvm_edict_t    *ed;
 
-       e = G_EDICTNUM(OFS_PARM0);
-       f = G_INT(OFS_PARM1);
-       s = G_FLOAT(OFS_PARM2);
+       e = PRVM_G_EDICTNUM(OFS_PARM0);
+       f = PRVM_G_INT(OFS_PARM1);
+       s = PRVM_G_FLOAT(OFS_PARM2);
 
-       for (e++ ; e < sv.num_edicts ; e++)
+       for (e++ ; e < prog->num_edicts ; e++)
        {
                pr_xfunction->builtinsprofile++;
-               ed = EDICT_NUM(e);
-               if (ed->e->free)
+               ed = PRVM_EDICT_NUM(e);
+               if (ed->priv.server->free)
                        continue;
                if (E_FLOAT(ed,f) == s)
                {
@@ -1221,7 +1221,7 @@ void PF_FindFloat (void)
                }
        }
 
-       RETURN_EDICT(sv.edicts);
+       RETURN_EDICT(prog->edicts);
 }
 
 // chained search for strings in entity fields
@@ -1231,23 +1231,23 @@ void PF_findchain (void)
        int             i;
        int             f;
        const char      *s, *t;
-       edict_t *ent, *chain;
+       prvm_edict_t    *ent, *chain;
 
-       chain = (edict_t *)sv.edicts;
+       chain = (prvm_edict_t *)prog->edicts;
 
-       f = G_INT(OFS_PARM0);
-       s = G_STRING(OFS_PARM1);
+       f = PRVM_G_INT(OFS_PARM0);
+       s = PRVM_G_STRING(OFS_PARM1);
        if (!s || !s[0])
        {
-               RETURN_EDICT(sv.edicts);
+               RETURN_EDICT(prog->edicts);
                return;
        }
 
-       ent = NEXT_EDICT(sv.edicts);
-       for (i = 1;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
+       ent = PRVM_NEXT_EDICT(prog->edicts);
+       for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                pr_xfunction->builtinsprofile++;
-               if (ent->e->free)
+               if (ent->priv.server->free)
                        continue;
                t = E_STRING(ent,f);
                if (!t)
@@ -1255,7 +1255,7 @@ void PF_findchain (void)
                if (strcmp(t,s))
                        continue;
 
-               ent->v->chain = EDICT_TO_PROG(chain);
+               ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
                chain = ent;
        }
 
@@ -1269,23 +1269,23 @@ void PF_findchainfloat (void)
        int             i;
        int             f;
        float   s;
-       edict_t *ent, *chain;
+       prvm_edict_t    *ent, *chain;
 
-       chain = (edict_t *)sv.edicts;
+       chain = (prvm_edict_t *)prog->edicts;
 
-       f = G_INT(OFS_PARM0);
-       s = G_FLOAT(OFS_PARM1);
+       f = PRVM_G_INT(OFS_PARM0);
+       s = PRVM_G_FLOAT(OFS_PARM1);
 
-       ent = NEXT_EDICT(sv.edicts);
-       for (i = 1;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
+       ent = PRVM_NEXT_EDICT(prog->edicts);
+       for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                pr_xfunction->builtinsprofile++;
-               if (ent->e->free)
+               if (ent->priv.server->free)
                        continue;
                if (E_FLOAT(ent,f) != s)
                        continue;
 
-               ent->v->chain = EDICT_TO_PROG(chain);
+               ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
                chain = ent;
        }
 
@@ -1298,17 +1298,17 @@ void PF_findflags (void)
        int             e;
        int             f;
        int             s;
-       edict_t *ed;
+       prvm_edict_t    *ed;
 
-       e = G_EDICTNUM(OFS_PARM0);
-       f = G_INT(OFS_PARM1);
-       s = (int)G_FLOAT(OFS_PARM2);
+       e = PRVM_G_EDICTNUM(OFS_PARM0);
+       f = PRVM_G_INT(OFS_PARM1);
+       s = (int)PRVM_G_FLOAT(OFS_PARM2);
 
-       for (e++ ; e < sv.num_edicts ; e++)
+       for (e++ ; e < prog->num_edicts ; e++)
        {
                pr_xfunction->builtinsprofile++;
-               ed = EDICT_NUM(e);
-               if (ed->e->free)
+               ed = PRVM_EDICT_NUM(e);
+               if (ed->priv.server->free)
                        continue;
                if ((int)E_FLOAT(ed,f) & s)
                {
@@ -1317,7 +1317,7 @@ void PF_findflags (void)
                }
        }
 
-       RETURN_EDICT(sv.edicts);
+       RETURN_EDICT(prog->edicts);
 }
 
 // LordHavoc: chained search for flags in float fields
@@ -1326,23 +1326,23 @@ void PF_findchainflags (void)
        int             i;
        int             f;
        int             s;
-       edict_t *ent, *chain;
+       prvm_edict_t    *ent, *chain;
 
-       chain = (edict_t *)sv.edicts;
+       chain = (prvm_edict_t *)prog->edicts;
 
-       f = G_INT(OFS_PARM0);
-       s = (int)G_FLOAT(OFS_PARM1);
+       f = PRVM_G_INT(OFS_PARM0);
+       s = (int)PRVM_G_FLOAT(OFS_PARM1);
 
-       ent = NEXT_EDICT(sv.edicts);
-       for (i = 1;i < sv.num_edicts;i++, ent = NEXT_EDICT(ent))
+       ent = PRVM_NEXT_EDICT(prog->edicts);
+       for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                pr_xfunction->builtinsprofile++;
-               if (ent->e->free)
+               if (ent->priv.server->free)
                        continue;
                if (!((int)E_FLOAT(ent,f) & s))
                        continue;
 
-               ent->v->chain = EDICT_TO_PROG(chain);
+               ent->fields.server->chain = PRVM_EDICT_TO_PROG(chain);
                chain = ent;
        }
 
@@ -1351,20 +1351,20 @@ void PF_findchainflags (void)
 
 void PF_precache_file (void)
 {      // precache_file is only used to copy files with qcc, it does nothing
-       G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
+       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
 }
 
 
 void PF_precache_sound (void)
 {
-       SV_SoundIndex(G_STRING(OFS_PARM0), 2);
-       G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
+       SV_SoundIndex(PRVM_G_STRING(OFS_PARM0), 2);
+       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
 }
 
 void PF_precache_model (void)
 {
-       SV_ModelIndex(G_STRING(OFS_PARM0), 2);
-       G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
+       SV_ModelIndex(PRVM_G_STRING(OFS_PARM0), 2);
+       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
 }
 
 
@@ -1385,7 +1385,7 @@ void PF_traceoff (void)
 
 void PF_eprint (void)
 {
-       ED_PrintNum (G_EDICTNUM(OFS_PARM0));
+       ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0));
 }
 
 /*
@@ -1397,24 +1397,24 @@ float(float yaw, float dist) walkmove
 */
 void PF_walkmove (void)
 {
-       edict_t *ent;
+       prvm_edict_t    *ent;
        float   yaw, dist;
        vec3_t  move;
        mfunction_t     *oldf;
        int     oldself;
 
        // assume failure if it returns early
-       G_FLOAT(OFS_RETURN) = 0;
+       PRVM_G_FLOAT(OFS_RETURN) = 0;
 
-       ent = PROG_TO_EDICT(pr_global_struct->self);
-       if (ent == sv.edicts)
+       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       if (ent == prog->edicts)
                PF_WARNING("walkmove: can not modify world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("walkmove: can not modify free entity\n");
-       yaw = G_FLOAT(OFS_PARM0);
-       dist = G_FLOAT(OFS_PARM1);
+       yaw = PRVM_G_FLOAT(OFS_PARM0);
+       dist = PRVM_G_FLOAT(OFS_PARM1);
 
-       if ( !( (int)ent->v->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
+       if ( !( (int)ent->fields.server->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
                return;
 
        yaw = yaw*M_PI*2 / 360;
@@ -1425,14 +1425,14 @@ void PF_walkmove (void)
 
 // save program state, because SV_movestep may call other progs
        oldf = pr_xfunction;
-       oldself = pr_global_struct->self;
+       oldself = prog->globals.server->self;
 
-       G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);
+       PRVM_G_FLOAT(OFS_RETURN) = SV_movestep(ent, move, true);
 
 
 // restore program state
        pr_xfunction = oldf;
-       pr_global_struct->self = oldself;
+       prog->globals.server->self = oldself;
 }
 
 /*
@@ -1444,33 +1444,33 @@ void() droptofloor
 */
 void PF_droptofloor (void)
 {
-       edict_t         *ent;
+       prvm_edict_t            *ent;
        vec3_t          end;
        trace_t         trace;
 
        // assume failure if it returns early
-       G_FLOAT(OFS_RETURN) = 0;
+       PRVM_G_FLOAT(OFS_RETURN) = 0;
 
-       ent = PROG_TO_EDICT(pr_global_struct->self);
-       if (ent == sv.edicts)
+       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       if (ent == prog->edicts)
                PF_WARNING("droptofloor: can not modify world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("droptofloor: can not modify free entity\n");
 
-       VectorCopy (ent->v->origin, end);
+       VectorCopy (ent->fields.server->origin, end);
        end[2] -= 256;
 
-       trace = SV_Move (ent->v->origin, ent->v->mins, ent->v->maxs, end, MOVE_NORMAL, ent);
+       trace = SV_Move (ent->fields.server->origin, ent->fields.server->mins, ent->fields.server->maxs, end, MOVE_NORMAL, ent);
 
        if (trace.fraction != 1)
        {
-               VectorCopy (trace.endpos, ent->v->origin);
+               VectorCopy (trace.endpos, ent->fields.server->origin);
                SV_LinkEdict (ent, false);
-               ent->v->flags = (int)ent->v->flags | FL_ONGROUND;
-               ent->v->groundentity = EDICT_TO_PROG(trace.ent);
-               G_FLOAT(OFS_RETURN) = 1;
+               ent->fields.server->flags = (int)ent->fields.server->flags | FL_ONGROUND;
+               ent->fields.server->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->e->suspendedinairflag = true;
+               ent->priv.server->suspendedinairflag = true;
        }
 }
 
@@ -1488,8 +1488,8 @@ void PF_lightstyle (void)
        client_t        *client;
        int                     j;
 
-       style = G_FLOAT(OFS_PARM0);
-       val = G_STRING(OFS_PARM1);
+       style = PRVM_G_FLOAT(OFS_PARM0);
+       val = PRVM_G_STRING(OFS_PARM1);
 
 // change the string in sv
        strlcpy(sv.lightstyles[style], val, sizeof(sv.lightstyles[style]));
@@ -1512,19 +1512,19 @@ void PF_lightstyle (void)
 void PF_rint (void)
 {
        float   f;
-       f = G_FLOAT(OFS_PARM0);
+       f = PRVM_G_FLOAT(OFS_PARM0);
        if (f > 0)
-               G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
+               PRVM_G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
        else
-               G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
+               PRVM_G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
 }
 void PF_floor (void)
 {
-       G_FLOAT(OFS_RETURN) = floor(G_FLOAT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = floor(PRVM_G_FLOAT(OFS_PARM0));
 }
 void PF_ceil (void)
 {
-       G_FLOAT(OFS_RETURN) = ceil(G_FLOAT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = ceil(PRVM_G_FLOAT(OFS_PARM0));
 }
 
 
@@ -1535,7 +1535,7 @@ PF_checkbottom
 */
 void PF_checkbottom (void)
 {
-       G_FLOAT(OFS_RETURN) = SV_CheckBottom (G_EDICT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = SV_CheckBottom (PRVM_G_EDICT(OFS_PARM0));
 }
 
 /*
@@ -1545,7 +1545,7 @@ PF_pointcontents
 */
 void PF_pointcontents (void)
 {
-       G_FLOAT(OFS_RETURN) = SV_PointQ1Contents(G_VECTOR(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = SV_PointQ1Contents(PRVM_G_VECTOR(OFS_PARM0));
 }
 
 /*
@@ -1558,20 +1558,20 @@ entity nextent(entity)
 void PF_nextent (void)
 {
        int             i;
-       edict_t *ent;
+       prvm_edict_t    *ent;
 
-       i = G_EDICTNUM(OFS_PARM0);
+       i = PRVM_G_EDICTNUM(OFS_PARM0);
        while (1)
        {
                pr_xfunction->builtinsprofile++;
                i++;
-               if (i == sv.num_edicts)
+               if (i == prog->num_edicts)
                {
-                       RETURN_EDICT(sv.edicts);
+                       RETURN_EDICT(prog->edicts);
                        return;
                }
-               ent = EDICT_NUM(i);
-               if (!ent->e->free)
+               ent = PRVM_EDICT_NUM(i);
+               if (!ent->priv.server->free)
                {
                        RETURN_EDICT(ent);
                        return;
@@ -1589,7 +1589,7 @@ vector aim(entity, missilespeed)
 */
 void PF_aim (void)
 {
-       edict_t *ent, *check, *bestent;
+       prvm_edict_t    *ent, *check, *bestent;
        vec3_t  start, dir, end, bestdir;
        int             i, j;
        trace_t tr;
@@ -1597,29 +1597,29 @@ void PF_aim (void)
        float   speed;
 
        // assume failure if it returns early
-       VectorCopy(pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
+       VectorCopy(prog->globals.server->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;
 
-       ent = G_EDICT(OFS_PARM0);
-       if (ent == sv.edicts)
+       ent = PRVM_G_EDICT(OFS_PARM0);
+       if (ent == prog->edicts)
                PF_WARNING("aim: can not use world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("aim: can not use free entity\n");
-       speed = G_FLOAT(OFS_PARM1);
+       speed = PRVM_G_FLOAT(OFS_PARM1);
 
-       VectorCopy (ent->v->origin, start);
+       VectorCopy (ent->fields.server->origin, start);
        start[2] += 20;
 
 // try sending a trace straight
-       VectorCopy (pr_global_struct->v_forward, dir);
+       VectorCopy (prog->globals.server->v_forward, dir);
        VectorMA (start, 2048, dir, end);
        tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent);
-       if (tr.ent && ((edict_t *)tr.ent)->v->takedamage == DAMAGE_AIM
-       && (!teamplay.integer || ent->v->team <=0 || ent->v->team != ((edict_t *)tr.ent)->v->team) )
+       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) )
        {
-               VectorCopy (pr_global_struct->v_forward, G_VECTOR(OFS_RETURN));
+               VectorCopy (prog->globals.server->v_forward, PRVM_G_VECTOR(OFS_RETURN));
                return;
        }
 
@@ -1629,22 +1629,22 @@ void PF_aim (void)
        bestdist = sv_aim.value;
        bestent = NULL;
 
-       check = NEXT_EDICT(sv.edicts);
-       for (i=1 ; i<sv.num_edicts ; i++, check = NEXT_EDICT(check) )
+       check = PRVM_NEXT_EDICT(prog->edicts);
+       for (i=1 ; i<prog->num_edicts ; i++, check = PRVM_NEXT_EDICT(check) )
        {
                pr_xfunction->builtinsprofile++;
-               if (check->v->takedamage != DAMAGE_AIM)
+               if (check->fields.server->takedamage != DAMAGE_AIM)
                        continue;
                if (check == ent)
                        continue;
-               if (teamplay.integer && ent->v->team > 0 && ent->v->team == check->v->team)
+               if (teamplay.integer && ent->fields.server->team > 0 && ent->fields.server->team == check->fields.server->team)
                        continue;       // don't aim at teammate
                for (j=0 ; j<3 ; j++)
-                       end[j] = check->v->origin[j]
-                       + 0.5*(check->v->mins[j] + check->v->maxs[j]);
+                       end[j] = check->fields.server->origin[j]
+                       + 0.5*(check->fields.server->mins[j] + check->fields.server->maxs[j]);
                VectorSubtract (end, start, dir);
                VectorNormalize (dir);
-               dist = DotProduct (dir, pr_global_struct->v_forward);
+               dist = DotProduct (dir, prog->globals.server->v_forward);
                if (dist < bestdist)
                        continue;       // to far to turn
                tr = SV_Move (start, vec3_origin, vec3_origin, end, MOVE_NORMAL, ent);
@@ -1657,16 +1657,16 @@ void PF_aim (void)
 
        if (bestent)
        {
-               VectorSubtract (bestent->v->origin, ent->v->origin, dir);
-               dist = DotProduct (dir, pr_global_struct->v_forward);
-               VectorScale (pr_global_struct->v_forward, dist, end);
+               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);
                end[2] = dir[2];
                VectorNormalize (end);
-               VectorCopy (end, G_VECTOR(OFS_RETURN));
+               VectorCopy (end, PRVM_G_VECTOR(OFS_RETURN));
        }
        else
        {
-               VectorCopy (bestdir, G_VECTOR(OFS_RETURN));
+               VectorCopy (bestdir, PRVM_G_VECTOR(OFS_RETURN));
        }
 }
 
@@ -1679,17 +1679,17 @@ This was a major timewaster in progs, so it was converted to C
 */
 void PF_changeyaw (void)
 {
-       edict_t         *ent;
+       prvm_edict_t            *ent;
        float           ideal, current, move, speed;
 
-       ent = PROG_TO_EDICT(pr_global_struct->self);
-       if (ent == sv.edicts)
+       ent = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+       if (ent == prog->edicts)
                PF_WARNING("changeyaw: can not modify world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("changeyaw: can not modify free entity\n");
-       current = ANGLEMOD(ent->v->angles[1]);
-       ideal = ent->v->ideal_yaw;
-       speed = ent->v->yaw_speed;
+       current = ANGLEMOD(ent->fields.server->angles[1]);
+       ideal = ent->fields.server->ideal_yaw;
+       speed = ent->fields.server->yaw_speed;
 
        if (current == ideal)
                return;
@@ -1715,7 +1715,7 @@ void PF_changeyaw (void)
                        move = -speed;
        }
 
-       ent->v->angles[1] = ANGLEMOD (current + move);
+       ent->fields.server->angles[1] = ANGLEMOD (current + move);
 }
 
 /*
@@ -1725,24 +1725,24 @@ PF_changepitch
 */
 void PF_changepitch (void)
 {
-       edict_t         *ent;
+       prvm_edict_t            *ent;
        float           ideal, current, move, speed;
-       eval_t          *val;
+       prvm_eval_t             *val;
 
-       ent = G_EDICT(OFS_PARM0);
-       if (ent == sv.edicts)
+       ent = PRVM_G_EDICT(OFS_PARM0);
+       if (ent == prog->edicts)
                PF_WARNING("changepitch: can not modify world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("changepitch: can not modify free entity\n");
-       current = ANGLEMOD( ent->v->angles[0] );
-       if ((val = GETEDICTFIELDVALUE(ent, eval_idealpitch)))
+       current = ANGLEMOD( ent->fields.server->angles[0] );
+       if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_idealpitch)))
                ideal = val->_float;
        else
        {
                PF_WARNING("PF_changepitch: .float idealpitch and .float pitch_speed must be defined to use changepitch\n");
                return;
        }
-       if ((val = GETEDICTFIELDVALUE(ent, eval_pitch_speed)))
+       if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_pitch_speed)))
                speed = val->_float;
        else
        {
@@ -1774,7 +1774,7 @@ void PF_changepitch (void)
                        move = -speed;
        }
 
-       ent->v->angles[0] = ANGLEMOD (current + move);
+       ent->fields.server->angles[0] = ANGLEMOD (current + move);
 }
 
 /*
@@ -1794,17 +1794,17 @@ sizebuf_t *WriteDest (void)
 {
        int             entnum;
        int             dest;
-       edict_t *ent;
+       prvm_edict_t    *ent;
 
-       dest = G_FLOAT(OFS_PARM0);
+       dest = PRVM_G_FLOAT(OFS_PARM0);
        switch (dest)
        {
        case MSG_BROADCAST:
                return &sv.datagram;
 
        case MSG_ONE:
-               ent = PROG_TO_EDICT(pr_global_struct->msg_entity);
-               entnum = NUM_FOR_EDICT(ent);
+               ent = PRVM_PROG_TO_EDICT(prog->globals.server->msg_entity);
+               entnum = PRVM_NUM_FOR_EDICT(ent);
                if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
                        Host_Error("WriteDest: tried to write to non-client\n");
                return &svs.clients[entnum-1].message;
@@ -1825,81 +1825,81 @@ sizebuf_t *WriteDest (void)
 
 void PF_WriteByte (void)
 {
-       MSG_WriteByte (WriteDest(), G_FLOAT(OFS_PARM1));
+       MSG_WriteByte (WriteDest(), PRVM_G_FLOAT(OFS_PARM1));
 }
 
 void PF_WriteChar (void)
 {
-       MSG_WriteChar (WriteDest(), G_FLOAT(OFS_PARM1));
+       MSG_WriteChar (WriteDest(), PRVM_G_FLOAT(OFS_PARM1));
 }
 
 void PF_WriteShort (void)
 {
-       MSG_WriteShort (WriteDest(), G_FLOAT(OFS_PARM1));
+       MSG_WriteShort (WriteDest(), PRVM_G_FLOAT(OFS_PARM1));
 }
 
 void PF_WriteLong (void)
 {
-       MSG_WriteLong (WriteDest(), G_FLOAT(OFS_PARM1));
+       MSG_WriteLong (WriteDest(), PRVM_G_FLOAT(OFS_PARM1));
 }
 
 void PF_WriteAngle (void)
 {
-       MSG_WriteAngle (WriteDest(), G_FLOAT(OFS_PARM1), sv.protocol);
+       MSG_WriteAngle (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
 }
 
 void PF_WriteCoord (void)
 {
-       MSG_WriteCoord (WriteDest(), G_FLOAT(OFS_PARM1), sv.protocol);
+       MSG_WriteCoord (WriteDest(), PRVM_G_FLOAT(OFS_PARM1), sv.protocol);
 }
 
 void PF_WriteString (void)
 {
-       MSG_WriteString (WriteDest(), G_STRING(OFS_PARM1));
+       MSG_WriteString (WriteDest(), PRVM_G_STRING(OFS_PARM1));
 }
 
 
 void PF_WriteEntity (void)
 {
-       MSG_WriteShort (WriteDest(), G_EDICTNUM(OFS_PARM1));
+       MSG_WriteShort (WriteDest(), PRVM_G_EDICTNUM(OFS_PARM1));
 }
 
 //=============================================================================
 
 void PF_makestatic (void)
 {
-       edict_t *ent;
+       prvm_edict_t *ent;
        int i, large;
 
-       ent = G_EDICT(OFS_PARM0);
-       if (ent == sv.edicts)
+       ent = PRVM_G_EDICT(OFS_PARM0);
+       if (ent == prog->edicts)
                PF_WARNING("makestatic: can not modify world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("makestatic: can not modify free entity\n");
 
        large = false;
-       if (ent->v->modelindex >= 256 || ent->v->frame >= 256)
+       if (ent->fields.server->modelindex >= 256 || ent->fields.server->frame >= 256)
                large = true;
 
        if (large)
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic2);
-               MSG_WriteShort (&sv.signon, ent->v->modelindex);
-               MSG_WriteShort (&sv.signon, ent->v->frame);
+               MSG_WriteShort (&sv.signon, ent->fields.server->modelindex);
+               MSG_WriteShort (&sv.signon, ent->fields.server->frame);
        }
        else
        {
                MSG_WriteByte (&sv.signon,svc_spawnstatic);
-               MSG_WriteByte (&sv.signon, ent->v->modelindex);
-               MSG_WriteByte (&sv.signon, ent->v->frame);
+               MSG_WriteByte (&sv.signon, ent->fields.server->modelindex);
+               MSG_WriteByte (&sv.signon, ent->fields.server->frame);
        }
 
-       MSG_WriteByte (&sv.signon, ent->v->colormap);
-       MSG_WriteByte (&sv.signon, ent->v->skin);
+       MSG_WriteByte (&sv.signon, ent->fields.server->colormap);
+       MSG_WriteByte (&sv.signon, ent->fields.server->skin);
        for (i=0 ; i<3 ; i++)
        {
-               MSG_WriteCoord(&sv.signon, ent->v->origin[i], sv.protocol);
-               MSG_WriteAngle(&sv.signon, ent->v->angles[i], sv.protocol);
+               MSG_WriteCoord(&sv.signon, ent->fields.server->origin[i], sv.protocol);
+               MSG_WriteAngle(&sv.signon, ent->fields.server->angles[i], sv.protocol);
        }
 
 // throw the entity away now
@@ -1915,12 +1915,12 @@ PF_setspawnparms
 */
 void PF_setspawnparms (void)
 {
-       edict_t *ent;
+       prvm_edict_t    *ent;
        int             i;
        client_t        *client;
 
-       ent = G_EDICT(OFS_PARM0);
-       i = NUM_FOR_EDICT(ent);
+       ent = PRVM_G_EDICT(OFS_PARM0);
+       i = PRVM_NUM_FOR_EDICT(ent);
        if (i < 1 || i > svs.maxclients || !svs.clients[i-1].active)
        {
                Con_Print("tried to setspawnparms on a non-client\n");
@@ -1930,7 +1930,7 @@ void PF_setspawnparms (void)
        // copy spawn parms out of the client_t
        client = svs.clients + i-1;
        for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
-               (&pr_global_struct->parm1)[i] = client->spawn_parms[i];
+               (&prog->globals.server->parm1)[i] = client->spawn_parms[i];
 }
 
 /*
@@ -1947,23 +1947,23 @@ void PF_changelevel (void)
                return;
        svs.changelevel_issued = true;
 
-       s = G_STRING(OFS_PARM0);
+       s = PRVM_G_STRING(OFS_PARM0);
        Cbuf_AddText (va("changelevel %s\n",s));
 }
 
 void PF_sin (void)
 {
-       G_FLOAT(OFS_RETURN) = sin(G_FLOAT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = sin(PRVM_G_FLOAT(OFS_PARM0));
 }
 
 void PF_cos (void)
 {
-       G_FLOAT(OFS_RETURN) = cos(G_FLOAT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = cos(PRVM_G_FLOAT(OFS_PARM0));
 }
 
 void PF_sqrt (void)
 {
-       G_FLOAT(OFS_RETURN) = sqrt(G_FLOAT(OFS_PARM0));
+       PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
 }
 
 /*
@@ -1985,7 +1985,7 @@ void PF_randomvec (void)
                temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
        }
        while (DotProduct(temp, temp) >= 1);
-       VectorCopy (temp, G_VECTOR(OFS_RETURN));
+       VectorCopy (temp, PRVM_G_VECTOR(OFS_RETURN));
 }
 
 /*
@@ -2004,21 +2004,21 @@ void PF_GetLight (void)
 {
        vec3_t ambientcolor, diffusecolor, diffusenormal;
        vec_t *p;
-       p = G_VECTOR(OFS_PARM0);
+       p = PRVM_G_VECTOR(OFS_PARM0);
        VectorClear(ambientcolor);
        VectorClear(diffusecolor);
        VectorClear(diffusenormal);
        if (sv.worldmodel && sv.worldmodel->brush.LightPoint)
                sv.worldmodel->brush.LightPoint(sv.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
-       VectorMA(ambientcolor, 0.5, diffusecolor, G_VECTOR(OFS_RETURN));
+       VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
 }
 
 void PF_registercvar (void)
 {
        const char *name, *value;
-       name = G_STRING(OFS_PARM0);
-       value = G_STRING(OFS_PARM1);
-       G_FLOAT(OFS_RETURN) = 0;
+       name = PRVM_G_STRING(OFS_PARM0);
+       value = PRVM_G_STRING(OFS_PARM1);
+       PRVM_G_FLOAT(OFS_RETURN) = 0;
 
 // first check to see if it has already been defined
        if (Cvar_FindVar (name))
@@ -2033,7 +2033,7 @@ void PF_registercvar (void)
 
        Cvar_Get(name, value, 0);
 
-       G_FLOAT(OFS_RETURN) = 1; // success
+       PRVM_G_FLOAT(OFS_RETURN) = 1; // success
 }
 
 /*
@@ -2049,19 +2049,19 @@ void PF_min (void)
 {
        // LordHavoc: 3+ argument enhancement suggested by FrikaC
        if (pr_argc == 2)
-               G_FLOAT(OFS_RETURN) = min(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
+               PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
        else if (pr_argc >= 3)
        {
                int i;
-               float f = G_FLOAT(OFS_PARM0);
+               float f = PRVM_G_FLOAT(OFS_PARM0);
                for (i = 1;i < pr_argc;i++)
-                       if (G_FLOAT((OFS_PARM0+i*3)) < f)
-                               f = G_FLOAT((OFS_PARM0+i*3));
-               G_FLOAT(OFS_RETURN) = f;
+                       if (PRVM_G_FLOAT((OFS_PARM0+i*3)) < f)
+                               f = PRVM_G_FLOAT((OFS_PARM0+i*3));
+               PRVM_G_FLOAT(OFS_RETURN) = f;
        }
        else
        {
-               G_FLOAT(OFS_RETURN) = 0;
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
                PF_WARNING("min: must supply at least 2 floats\n");
        }
 }
@@ -2079,19 +2079,19 @@ void PF_max (void)
 {
        // LordHavoc: 3+ argument enhancement suggested by FrikaC
        if (pr_argc == 2)
-               G_FLOAT(OFS_RETURN) = max(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
+               PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
        else if (pr_argc >= 3)
        {
                int i;
-               float f = G_FLOAT(OFS_PARM0);
+               float f = PRVM_G_FLOAT(OFS_PARM0);
                for (i = 1;i < pr_argc;i++)
-                       if (G_FLOAT((OFS_PARM0+i*3)) > f)
-                               f = G_FLOAT((OFS_PARM0+i*3));
-               G_FLOAT(OFS_RETURN) = f;
+                       if (PRVM_G_FLOAT((OFS_PARM0+i*3)) > f)
+                               f = PRVM_G_FLOAT((OFS_PARM0+i*3));
+               PRVM_G_FLOAT(OFS_RETURN) = f;
        }
        else
        {
-               G_FLOAT(OFS_RETURN) = 0;
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
                PF_WARNING("max: must supply at least 2 floats\n");
        }
 }
@@ -2107,7 +2107,7 @@ min(min, value, max)
 */
 void PF_bound (void)
 {
-       G_FLOAT(OFS_RETURN) = bound(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1), G_FLOAT(OFS_PARM2));
+       PRVM_G_FLOAT(OFS_RETURN) = bound(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1), PRVM_G_FLOAT(OFS_PARM2));
 }
 
 /*
@@ -2121,7 +2121,7 @@ pow(a, b)
 */
 void PF_pow (void)
 {
-       G_FLOAT(OFS_RETURN) = pow(G_FLOAT(OFS_PARM0), G_FLOAT(OFS_PARM1));
+       PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
 }
 
 /*
@@ -2135,16 +2135,16 @@ copyentity(src, dst)
 */
 void PF_copyentity (void)
 {
-       edict_t *in, *out;
-       in = G_EDICT(OFS_PARM0);
-       if (in == sv.edicts)
+       prvm_edict_t *in, *out;
+       in = PRVM_G_EDICT(OFS_PARM0);
+       if (in == prog->edicts)
                PF_WARNING("copyentity: can not read world entity\n");
-       if (in->e->free)
+       if (in->priv.server->free)
                PF_WARNING("copyentity: can not read free entity\n");
-       out = G_EDICT(OFS_PARM1);
-       if (out == sv.edicts)
+       out = PRVM_G_EDICT(OFS_PARM1);
+       if (out == prog->edicts)
                PF_WARNING("copyentity: can not modify world entity\n");
-       if (out->e->free)
+       if (out->priv.server->free)
                PF_WARNING("copyentity: can not modify free entity\n");
        memcpy(out->v, in->v, progs->entityfields * 4);
 }
@@ -2162,10 +2162,10 @@ void PF_setcolor (void)
 {
        client_t *client;
        int entnum, i;
-       eval_t *val;
+       prvm_eval_t *val;
 
-       entnum = G_EDICTNUM(OFS_PARM0);
-       i = G_FLOAT(OFS_PARM1);
+       entnum = PRVM_G_EDICTNUM(OFS_PARM0);
+       i = PRVM_G_FLOAT(OFS_PARM1);
 
        if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
        {
@@ -2176,9 +2176,9 @@ void PF_setcolor (void)
        client = svs.clients + entnum-1;
        if (client->edict)
        {
-               if ((val = GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
+               if ((val = PRVM_GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
                        val->_float = i;
-               client->edict->v->team = (i & 15) + 1;
+               client->edict->fields.server->team = (i & 15) + 1;
        }
        client->colors = i;
        if (client->old_colors != client->colors)
@@ -2202,52 +2202,52 @@ void PF_effect (void)
 {
        int i;
        const char *s;
-       s = G_STRING(OFS_PARM1);
+       s = PRVM_G_STRING(OFS_PARM1);
        if (!s || !s[0])
                PF_WARNING("effect: no model specified\n");
 
        i = SV_ModelIndex(s, 1);
        if (!i)
                PF_WARNING("effect: model not precached\n");
-       SV_StartEffect(G_VECTOR(OFS_PARM0), i, G_FLOAT(OFS_PARM2), G_FLOAT(OFS_PARM3), G_FLOAT(OFS_PARM4));
+       SV_StartEffect(PRVM_G_VECTOR(OFS_PARM0), i, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3), PRVM_G_FLOAT(OFS_PARM4));
 }
 
 void PF_te_blood (void)
 {
-       if (G_FLOAT(OFS_PARM2) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM2) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_BLOOD);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // velocity
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[0], 127));
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[1], 127));
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[2], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
        // count
-       MSG_WriteByte(&sv.datagram, bound(0, (int) G_FLOAT(OFS_PARM2), 255));
+       MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
 }
 
 void PF_te_bloodshower (void)
 {
-       if (G_FLOAT(OFS_PARM3) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM3) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_BLOODSHOWER);
        // min
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // max
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // speed
-       MSG_WriteCoord(&sv.datagram, G_FLOAT(OFS_PARM2), sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2), sv.protocol);
        // count
-       MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
+       MSG_WriteShort(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
 }
 
 void PF_te_explosionrgb (void)
@@ -2255,107 +2255,107 @@ void PF_te_explosionrgb (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_EXPLOSIONRGB);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // color
-       MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[0] * 255), 255));
-       MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[1] * 255), 255));
-       MSG_WriteByte(&sv.datagram, bound(0, (int) (G_VECTOR(OFS_PARM1)[2] * 255), 255));
+       MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[0] * 255), 255));
+       MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[1] * 255), 255));
+       MSG_WriteByte(&sv.datagram, bound(0, (int) (PRVM_G_VECTOR(OFS_PARM1)[2] * 255), 255));
 }
 
 void PF_te_particlecube (void)
 {
-       if (G_FLOAT(OFS_PARM3) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM3) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_PARTICLECUBE);
        // min
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // max
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // velocity
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
        // count
-       MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
+       MSG_WriteShort(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
        // color
-       MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
+       MSG_WriteByte(&sv.datagram, PRVM_G_FLOAT(OFS_PARM4));
        // gravity true/false
-       MSG_WriteByte(&sv.datagram, ((int) G_FLOAT(OFS_PARM5)) != 0);
+       MSG_WriteByte(&sv.datagram, ((int) PRVM_G_FLOAT(OFS_PARM5)) != 0);
        // randomvel
-       MSG_WriteCoord(&sv.datagram, G_FLOAT(OFS_PARM6), sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_FLOAT(OFS_PARM6), sv.protocol);
 }
 
 void PF_te_particlerain (void)
 {
-       if (G_FLOAT(OFS_PARM3) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM3) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_PARTICLERAIN);
        // min
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // max
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // velocity
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
        // count
-       MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
+       MSG_WriteShort(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
        // color
-       MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
+       MSG_WriteByte(&sv.datagram, PRVM_G_FLOAT(OFS_PARM4));
 }
 
 void PF_te_particlesnow (void)
 {
-       if (G_FLOAT(OFS_PARM3) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM3) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_PARTICLESNOW);
        // min
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // max
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // velocity
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
        // count
-       MSG_WriteShort(&sv.datagram, bound(0, G_FLOAT(OFS_PARM3), 65535));
+       MSG_WriteShort(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM3), 65535));
        // color
-       MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM4));
+       MSG_WriteByte(&sv.datagram, PRVM_G_FLOAT(OFS_PARM4));
 }
 
 void PF_te_spark (void)
 {
-       if (G_FLOAT(OFS_PARM2) < 1)
+       if (PRVM_G_FLOAT(OFS_PARM2) < 1)
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SPARK);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // velocity
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[0], 127));
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[1], 127));
-       MSG_WriteByte(&sv.datagram, bound(-128, (int) G_VECTOR(OFS_PARM1)[2], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[0], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[1], 127));
+       MSG_WriteByte(&sv.datagram, bound(-128, (int) PRVM_G_VECTOR(OFS_PARM1)[2], 127));
        // count
-       MSG_WriteByte(&sv.datagram, bound(0, (int) G_FLOAT(OFS_PARM2), 255));
+       MSG_WriteByte(&sv.datagram, bound(0, (int) PRVM_G_FLOAT(OFS_PARM2), 255));
 }
 
 void PF_te_gunshotquad (void)
@@ -2363,9 +2363,9 @@ void PF_te_gunshotquad (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_GUNSHOTQUAD);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_spikequad (void)
@@ -2373,9 +2373,9 @@ void PF_te_spikequad (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SPIKEQUAD);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_superspikequad (void)
@@ -2383,9 +2383,9 @@ void PF_te_superspikequad (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SUPERSPIKEQUAD);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_explosionquad (void)
@@ -2393,9 +2393,9 @@ void PF_te_explosionquad (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_EXPLOSIONQUAD);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_smallflash (void)
@@ -2403,29 +2403,29 @@ void PF_te_smallflash (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SMALLFLASH);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_customflash (void)
 {
-       if (G_FLOAT(OFS_PARM1) < 8 || G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
+       if (PRVM_G_FLOAT(OFS_PARM1) < 8 || PRVM_G_FLOAT(OFS_PARM2) < (1.0 / 256.0))
                return;
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_CUSTOMFLASH);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // radius
-       MSG_WriteByte(&sv.datagram, bound(0, G_FLOAT(OFS_PARM1) / 8 - 1, 255));
+       MSG_WriteByte(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM1) / 8 - 1, 255));
        // lifetime
-       MSG_WriteByte(&sv.datagram, bound(0, G_FLOAT(OFS_PARM2) * 256 - 1, 255));
+       MSG_WriteByte(&sv.datagram, bound(0, PRVM_G_FLOAT(OFS_PARM2) * 256 - 1, 255));
        // color
-       MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[0] * 255, 255));
-       MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[1] * 255, 255));
-       MSG_WriteByte(&sv.datagram, bound(0, G_VECTOR(OFS_PARM3)[2] * 255, 255));
+       MSG_WriteByte(&sv.datagram, bound(0, PRVM_G_VECTOR(OFS_PARM3)[0] * 255, 255));
+       MSG_WriteByte(&sv.datagram, bound(0, PRVM_G_VECTOR(OFS_PARM3)[1] * 255, 255));
+       MSG_WriteByte(&sv.datagram, bound(0, PRVM_G_VECTOR(OFS_PARM3)[2] * 255, 255));
 }
 
 void PF_te_gunshot (void)
@@ -2433,9 +2433,9 @@ void PF_te_gunshot (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_GUNSHOT);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_spike (void)
@@ -2443,9 +2443,9 @@ void PF_te_spike (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SPIKE);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_superspike (void)
@@ -2453,9 +2453,9 @@ void PF_te_superspike (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_SUPERSPIKE);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_explosion (void)
@@ -2463,9 +2463,9 @@ void PF_te_explosion (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_EXPLOSION);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_tarexplosion (void)
@@ -2473,9 +2473,9 @@ void PF_te_tarexplosion (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_TAREXPLOSION);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_wizspike (void)
@@ -2483,9 +2483,9 @@ void PF_te_wizspike (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_WIZSPIKE);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_knightspike (void)
@@ -2493,9 +2493,9 @@ void PF_te_knightspike (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_KNIGHTSPIKE);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_lavasplash (void)
@@ -2503,9 +2503,9 @@ void PF_te_lavasplash (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_LAVASPLASH);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_teleport (void)
@@ -2513,9 +2513,9 @@ void PF_te_teleport (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_TELEPORT);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 void PF_te_explosion2 (void)
@@ -2523,12 +2523,12 @@ void PF_te_explosion2 (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_EXPLOSION2);
        // origin
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
        // color
-       MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM1));
-       MSG_WriteByte(&sv.datagram, G_FLOAT(OFS_PARM2));
+       MSG_WriteByte(&sv.datagram, PRVM_G_FLOAT(OFS_PARM1));
+       MSG_WriteByte(&sv.datagram, PRVM_G_FLOAT(OFS_PARM2));
 }
 
 void PF_te_lightning1 (void)
@@ -2536,15 +2536,15 @@ void PF_te_lightning1 (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_LIGHTNING1);
        // owner entity
-       MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
+       MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
        // start
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // end
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
 }
 
 void PF_te_lightning2 (void)
@@ -2552,15 +2552,15 @@ void PF_te_lightning2 (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_LIGHTNING2);
        // owner entity
-       MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
+       MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
        // start
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // end
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
 }
 
 void PF_te_lightning3 (void)
@@ -2568,15 +2568,15 @@ void PF_te_lightning3 (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_LIGHTNING3);
        // owner entity
-       MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
+       MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
        // start
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // end
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
 }
 
 void PF_te_beam (void)
@@ -2584,24 +2584,24 @@ void PF_te_beam (void)
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_BEAM);
        // owner entity
-       MSG_WriteShort(&sv.datagram, G_EDICTNUM(OFS_PARM0));
+       MSG_WriteShort(&sv.datagram, PRVM_G_EDICTNUM(OFS_PARM0));
        // start
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM1)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM1)[2], sv.protocol);
        // end
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM2)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM2)[2], sv.protocol);
 }
 
 void PF_te_plasmaburn (void)
 {
        MSG_WriteByte(&sv.datagram, svc_temp_entity);
        MSG_WriteByte(&sv.datagram, TE_PLASMABURN);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[0], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[1], sv.protocol);
-       MSG_WriteCoord(&sv.datagram, G_VECTOR(OFS_PARM0)[2], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[0], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[1], sv.protocol);
+       MSG_WriteCoord(&sv.datagram, PRVM_G_VECTOR(OFS_PARM0)[2], sv.protocol);
 }
 
 static void clippointtosurface(msurface_t *surface, vec3_t p, vec3_t out)
@@ -2640,13 +2640,13 @@ static void clippointtosurface(msurface_t *surface, vec3_t p, vec3_t out)
        }
 }
 
-static msurface_t *getsurface(edict_t *ed, int surfacenum)
+static msurface_t *getsurface(prvm_edict_t *ed, int surfacenum)
 {
        int modelindex;
        model_t *model;
-       if (!ed || ed->e->free)
+       if (!ed || ed->priv.server->free)
                return NULL;
-       modelindex = ed->v->modelindex;
+       modelindex = ed->fields.server->modelindex;
        if (modelindex < 1 || modelindex >= MAX_MODELS)
                return NULL;
        model = sv.models[modelindex];
@@ -2661,41 +2661,41 @@ void PF_getsurfacenumpoints(void)
 {
        msurface_t *surface;
        // return 0 if no such surface
-       if (!(surface = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
+       if (!(surface = getsurface(PRVM_G_EDICT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1))))
        {
-               G_FLOAT(OFS_RETURN) = 0;
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
                return;
        }
 
        // note: this (incorrectly) assumes it is a simple polygon
-       G_FLOAT(OFS_RETURN) = surface->num_vertices;
+       PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
 }
 //PF_getsurfacepoint,     // #435 vector(entity e, float s, float n) getsurfacepoint = #435;
 void PF_getsurfacepoint(void)
 {
-       edict_t *ed;
+       prvm_edict_t *ed;
        msurface_t *surface;
        int pointnum;
-       VectorClear(G_VECTOR(OFS_RETURN));
-       ed = G_EDICT(OFS_PARM0);
-       if (!ed || ed->e->free)
+       VectorClear(PRVM_G_VECTOR(OFS_RETURN));
+       ed = PRVM_G_EDICT(OFS_PARM0);
+       if (!ed || ed->priv.server->free)
                return;
-       if (!(surface = getsurface(ed, G_FLOAT(OFS_PARM1))))
+       if (!(surface = getsurface(ed, PRVM_G_FLOAT(OFS_PARM1))))
                return;
        // note: this (incorrectly) assumes it is a simple polygon
-       pointnum = G_FLOAT(OFS_PARM2);
+       pointnum = PRVM_G_FLOAT(OFS_PARM2);
        if (pointnum < 0 || pointnum >= surface->num_vertices)
                return;
        // FIXME: implement rotation/scaling
-       VectorAdd(&(surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->v->origin, G_VECTOR(OFS_RETURN));
+       VectorAdd(&(surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
 }
 //PF_getsurfacenormal,    // #436 vector(entity e, float s) getsurfacenormal = #436;
 void PF_getsurfacenormal(void)
 {
        msurface_t *surface;
        vec3_t normal;
-       VectorClear(G_VECTOR(OFS_RETURN));
-       if (!(surface = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
+       VectorClear(PRVM_G_VECTOR(OFS_RETURN));
+       if (!(surface = getsurface(PRVM_G_EDICT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1))))
                return;
        // FIXME: implement rotation/scaling
        // note: this (incorrectly) assumes it is a simple polygon
@@ -2703,16 +2703,16 @@ void PF_getsurfacenormal(void)
        // well for curved surfaces or arbitrary meshes
        TriangleNormal((surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex), (surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex) + 3, (surface->groupmesh->data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
        VectorNormalize(normal);
-       VectorCopy(normal, G_VECTOR(OFS_RETURN));
+       VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
 }
 //PF_getsurfacetexture,   // #437 string(entity e, float s) getsurfacetexture = #437;
 void PF_getsurfacetexture(void)
 {
        msurface_t *surface;
-       G_INT(OFS_RETURN) = 0;
-       if (!(surface = getsurface(G_EDICT(OFS_PARM0), G_FLOAT(OFS_PARM1))))
+       PRVM_G_INT(OFS_RETURN) = 0;
+       if (!(surface = getsurface(PRVM_G_EDICT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1))))
                return;
-       G_INT(OFS_RETURN) = PR_SetEngineString(surface->texture->name);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(surface->texture->name);
 }
 //PF_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint = #438;
 void PF_getsurfacenearpoint(void)
@@ -2720,17 +2720,17 @@ void PF_getsurfacenearpoint(void)
        int surfacenum, best, modelindex;
        vec3_t clipped, p;
        vec_t dist, bestdist;
-       edict_t *ed;
+       prvm_edict_t *ed;
        model_t *model;
        msurface_t *surface;
        vec_t *point;
-       G_FLOAT(OFS_RETURN) = -1;
-       ed = G_EDICT(OFS_PARM0);
-       point = G_VECTOR(OFS_PARM1);
+       PRVM_G_FLOAT(OFS_RETURN) = -1;
+       ed = PRVM_G_EDICT(OFS_PARM0);
+       point = PRVM_G_VECTOR(OFS_PARM1);
 
-       if (!ed || ed->e->free)
+       if (!ed || ed->priv.server->free)
                return;
-       modelindex = ed->v->modelindex;
+       modelindex = ed->fields.server->modelindex;
        if (modelindex < 1 || modelindex >= MAX_MODELS)
                return;
        model = sv.models[modelindex];
@@ -2738,7 +2738,7 @@ void PF_getsurfacenearpoint(void)
                return;
 
        // FIXME: implement rotation/scaling
-       VectorSubtract(point, ed->v->origin, p);
+       VectorSubtract(point, ed->fields.server->origin, p);
        best = -1;
        bestdist = 1000000000;
        for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
@@ -2763,25 +2763,25 @@ void PF_getsurfacenearpoint(void)
                        }
                }
        }
-       G_FLOAT(OFS_RETURN) = best;
+       PRVM_G_FLOAT(OFS_RETURN) = best;
 }
 //PF_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint = #439;
 void PF_getsurfaceclippedpoint(void)
 {
-       edict_t *ed;
+       prvm_edict_t *ed;
        msurface_t *surface;
        vec3_t p, out;
-       VectorClear(G_VECTOR(OFS_RETURN));
-       ed = G_EDICT(OFS_PARM0);
-       if (!ed || ed->e->free)
+       VectorClear(PRVM_G_VECTOR(OFS_RETURN));
+       ed = PRVM_G_EDICT(OFS_PARM0);
+       if (!ed || ed->priv.server->free)
                return;
-       if (!(surface = getsurface(ed, G_FLOAT(OFS_PARM1))))
+       if (!(surface = getsurface(ed, PRVM_G_FLOAT(OFS_PARM1))))
                return;
        // FIXME: implement rotation/scaling
-       VectorSubtract(G_VECTOR(OFS_PARM2), ed->v->origin, p);
+       VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.server->origin, p);
        clippointtosurface(surface, p, out);
        // FIXME: implement rotation/scaling
-       VectorAdd(out, ed->v->origin, G_VECTOR(OFS_RETURN));
+       VectorAdd(out, ed->fields.server->origin, PRVM_G_VECTOR(OFS_RETURN));
 }
 
 #define MAX_PRFILES 256
@@ -2809,7 +2809,7 @@ void PF_stof(void)
 {
        char string[STRINGTEMP_LENGTH];
        PF_VarString(0, string, sizeof(string));
-       G_FLOAT(OFS_RETURN) = atof(string);
+       PRVM_G_FLOAT(OFS_RETURN) = atof(string);
 }
 
 //float(string filename, float mode) fopen = #110; // opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE), returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason
@@ -2823,10 +2823,10 @@ void PF_fopen(void)
        if (filenum >= MAX_PRFILES)
        {
                Con_Printf("PF_fopen: ran out of file handles (%i)\n", MAX_PRFILES);
-               G_FLOAT(OFS_RETURN) = -2;
+               PRVM_G_FLOAT(OFS_RETURN) = -2;
                return;
        }
-       mode = G_FLOAT(OFS_PARM1);
+       mode = PRVM_G_FLOAT(OFS_PARM1);
        switch(mode)
        {
        case 0: // FILE_READ
@@ -2840,10 +2840,10 @@ void PF_fopen(void)
                break;
        default:
                Con_Printf("PF_fopen: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", mode);
-               G_FLOAT(OFS_RETURN) = -3;
+               PRVM_G_FLOAT(OFS_RETURN) = -3;
                return;
        }
-       filename = G_STRING(OFS_PARM0);
+       filename = PRVM_G_STRING(OFS_PARM0);
        // -4 failure (dangerous/non-portable filename) removed, FS_Open checks
        pr_files[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
 
@@ -2851,15 +2851,15 @@ void PF_fopen(void)
                pr_files[filenum] = FS_Open(filename, modestring, false, false);
 
        if (pr_files[filenum] == NULL)
-               G_FLOAT(OFS_RETURN) = -1;
+               PRVM_G_FLOAT(OFS_RETURN) = -1;
        else
-               G_FLOAT(OFS_RETURN) = filenum;
+               PRVM_G_FLOAT(OFS_RETURN) = filenum;
 }
 
 //void(float fhandle) fclose = #111; // closes a file
 void PF_fclose(void)
 {
-       int filenum = G_FLOAT(OFS_PARM0);
+       int filenum = PRVM_G_FLOAT(OFS_PARM0);
        if (filenum < 0 || filenum >= MAX_PRFILES)
        {
                Con_Printf("PF_fclose: invalid file handle %i\n", filenum);
@@ -2879,7 +2879,7 @@ void PF_fgets(void)
 {
        int c, end;
        static char string[STRINGTEMP_LENGTH];
-       int filenum = G_FLOAT(OFS_PARM0);
+       int filenum = PRVM_G_FLOAT(OFS_PARM0);
        if (filenum < 0 || filenum >= MAX_PRFILES)
        {
                Con_Printf("PF_fgets: invalid file handle %i\n", filenum);
@@ -2910,9 +2910,9 @@ void PF_fgets(void)
        if (developer.integer)
                Con_Printf("fgets: %s\n", string);
        if (c >= 0 || end)
-               G_INT(OFS_RETURN) = PR_SetEngineString(string);
+               PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
        else
-               G_INT(OFS_RETURN) = 0;
+               PRVM_G_INT(OFS_RETURN) = 0;
 }
 
 //void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
@@ -2920,7 +2920,7 @@ void PF_fputs(void)
 {
        int stringlength;
        char string[STRINGTEMP_LENGTH];
-       int filenum = G_FLOAT(OFS_PARM0);
+       int filenum = PRVM_G_FLOAT(OFS_PARM0);
        if (filenum < 0 || filenum >= MAX_PRFILES)
        {
                Con_Printf("PF_fputs: invalid file handle %i\n", filenum);
@@ -2942,11 +2942,11 @@ void PF_fputs(void)
 void PF_strlen(void)
 {
        const char *s;
-       s = G_STRING(OFS_PARM0);
+       s = PRVM_G_STRING(OFS_PARM0);
        if (s)
-               G_FLOAT(OFS_RETURN) = strlen(s);
+               PRVM_G_FLOAT(OFS_RETURN) = strlen(s);
        else
-               G_FLOAT(OFS_RETURN) = 0;
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
 }
 
 //string(string s1, string s2) strcat = #115; // concatenates two strings (for example "abc", "def" would return "abcdef") and returns as a tempstring
@@ -2954,7 +2954,7 @@ void PF_strcat(void)
 {
        char *s = PR_GetTempString();
        PF_VarString(0, s, STRINGTEMP_LENGTH);
-       G_INT(OFS_RETURN) = PR_SetEngineString(s);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(s);
 }
 
 //string(string s, float start, float length) substring = #116; // returns a section of a string as a tempstring
@@ -2963,16 +2963,16 @@ void PF_substring(void)
        int i, start, length;
        const char *s;
        char *string = PR_GetTempString();
-       s = G_STRING(OFS_PARM0);
-       start = G_FLOAT(OFS_PARM1);
-       length = G_FLOAT(OFS_PARM2);
+       s = PRVM_G_STRING(OFS_PARM0);
+       start = PRVM_G_FLOAT(OFS_PARM1);
+       length = PRVM_G_FLOAT(OFS_PARM2);
        if (!s)
                s = "";
        for (i = 0;i < start && *s;i++, s++);
        for (i = 0;i < STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++)
                string[i] = *s;
        string[i] = 0;
-       G_INT(OFS_RETURN) = PR_SetEngineString(string);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
 }
 
 //vector(string s) stov = #117; // returns vector value from a string
@@ -2980,7 +2980,7 @@ void PF_stov(void)
 {
        char string[STRINGTEMP_LENGTH];
        PF_VarString(0, string, sizeof(string));
-       Math_atov(string, G_VECTOR(OFS_RETURN));
+       Math_atov(string, PRVM_G_VECTOR(OFS_RETURN));
 }
 
 //string(string s) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
@@ -2988,16 +2988,16 @@ void PF_strzone(void)
 {
        const char *in;
        char *out;
-       in = G_STRING(OFS_PARM0);
+       in = PRVM_G_STRING(OFS_PARM0);
        out = PR_AllocString(strlen(in) + 1);
        strcpy(out, in);
-       G_INT(OFS_RETURN) = PR_SetQCString(out);
+       PRVM_G_INT(OFS_RETURN) = PR_SetQCString(out);
 }
 
 //void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
 void PF_strunzone(void)
 {
-       PR_FreeString((char *)G_STRING(OFS_PARM0));
+       PR_FreeString((char *)PRVM_G_STRING(OFS_PARM0));
 }
 
 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
@@ -3008,7 +3008,7 @@ void PF_clientcommand (void)
        int i;
 
        //find client for this entity
-       i = (NUM_FOR_EDICT(G_EDICT(OFS_PARM0)) - 1);
+       i = (PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(OFS_PARM0)) - 1);
        if (i < 0 || i >= svs.maxclients || !svs.clients[i].active)
        {
                Con_Print("PF_clientcommand: entity is not a client\n");
@@ -3017,7 +3017,7 @@ void PF_clientcommand (void)
 
        temp_client = host_client;
        host_client = svs.clients + i;
-       Cmd_ExecuteString (G_STRING(OFS_PARM1), src_client);
+       Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
        host_client = temp_client;
 }
 
@@ -3030,7 +3030,7 @@ void PF_tokenize (void)
 {
        int pos;
        const char *p;
-       p = G_STRING(OFS_PARM0);
+       p = PRVM_G_STRING(OFS_PARM0);
 
        num_tokens = 0;
        pos = 0;
@@ -3045,73 +3045,73 @@ void PF_tokenize (void)
                pos += strlen(com_token) + 1;
        }
 
-       G_FLOAT(OFS_RETURN) = num_tokens;
+       PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
 }
 
 //string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index)
 //this function originally written by KrimZon, made shorter by LordHavoc
 void PF_argv (void)
 {
-       int token_num = G_FLOAT(OFS_PARM0);
+       int token_num = PRVM_G_FLOAT(OFS_PARM0);
        if (token_num >= 0 && token_num < num_tokens)
-               G_INT(OFS_RETURN) = PR_SetEngineString(tokens[token_num]);
+               PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]);
        else
-               G_INT(OFS_RETURN) = PR_SetEngineString(NULL);
+               PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(NULL);
 }
 
 //void(entity e, entity tagentity, string tagname) setattachment = #443; // attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag)
 void PF_setattachment (void)
 {
-       edict_t *e = G_EDICT(OFS_PARM0);
-       edict_t *tagentity = G_EDICT(OFS_PARM1);
-       const char *tagname = G_STRING(OFS_PARM2);
-       eval_t *v;
+       prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
+       prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
+       const char *tagname = PRVM_G_STRING(OFS_PARM2);
+       prvm_eval_t *v;
        int modelindex;
        model_t *model;
 
-       if (e == sv.edicts)
+       if (e == prog->edicts)
                PF_WARNING("setattachment: can not modify world entity\n");
-       if (e->e->free)
+       if (e->priv.server->free)
                PF_WARNING("setattachment: can not modify free entity\n");
 
        if (tagentity == NULL)
-               tagentity = sv.edicts;
+               tagentity = prog->edicts;
 
-       v = GETEDICTFIELDVALUE(e, eval_tag_entity);
+       v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_entity);
        if (v)
-               v->edict = EDICT_TO_PROG(tagentity);
+               fields.server->edict = PRVM_EDICT_TO_PROG(tagentity);
 
-       v = GETEDICTFIELDVALUE(e, eval_tag_index);
+       v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_index);
        if (v)
-               v->_float = 0;
-       if (tagentity != NULL && tagentity != sv.edicts && tagname && tagname[0])
+               fields.server->_float = 0;
+       if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
        {
-               modelindex = (int)tagentity->v->modelindex;
+               modelindex = (int)tagentity->fields.server->modelindex;
                if (modelindex >= 0 && modelindex < MAX_MODELS && (model = sv.models[modelindex]))
                {
-                       v->_float = Mod_Alias_GetTagIndexForName(model, tagentity->v->skin, tagname);
-                       if (v->_float == 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", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity), model->name);
+                       fields.server->_float = Mod_Alias_GetTagIndexForName(model, tagentity->fields.server->skin, tagname);
+                       if (fields.server->_float == 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);
                }
                else
-                       Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity));
+                       Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 }
 
 /////////////////////////////////////////
 // DP_MD3_TAGINFO extension coded by VorteX
 
-int SV_GetTagIndex (edict_t *e, const char *tagname)
+int SV_GetTagIndex (prvm_edict_t *e, const char *tagname)
 {
        int i;
        model_t *model;
 
-       i = e->v->modelindex;
+       i = e->fields.server->modelindex;
        if (i < 1 || i >= MAX_MODELS)
                return -1;
        model = sv.models[i];
 
-       return Mod_Alias_GetTagIndexForName(model, e->v->skin, tagname);
+       return Mod_Alias_GetTagIndexForName(model, e->fields.server->skin, tagname);
 };
 
 // Warnings/errors code:
@@ -3124,29 +3124,29 @@ int SV_GetTagIndex (edict_t *e, const char *tagname)
 extern cvar_t cl_bob;
 extern cvar_t cl_bobcycle;
 extern cvar_t cl_bobup;
-int SV_GetTagMatrix (matrix4x4_t *out, edict_t *ent, int tagindex)
+int SV_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
 {
-       eval_t *val;
+       prvm_eval_t *val;
        int modelindex, reqframe, attachloop;
        matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
-       edict_t *attachent;
+       prvm_edict_t *attachent;
        model_t *model;
 
        Matrix4x4_CreateIdentity(out); // warnings and errors return identical matrix
 
-       if (ent == sv.edicts)
+       if (ent == prog->edicts)
                return 1;
-       if (ent->e->free)
+       if (ent->priv.server->free)
                return 2;
 
-       modelindex = (int)ent->v->modelindex;
+       modelindex = (int)ent->fields.server->modelindex;
        if (modelindex <= 0 || modelindex > MAX_MODELS)
                return 3;
 
        model = sv.models[modelindex];
 
-       if (ent->v->frame >= 0 && ent->v->frame < model->numframes && model->animscenes)
-               reqframe = model->animscenes[(int)ent->v->frame].firstframe;
+       if (ent->fields.server->frame >= 0 && ent->fields.server->frame < model->numframes && model->animscenes)
+               reqframe = model->animscenes[(int)ent->fields.server->frame].firstframe;
        else
                reqframe = 0; // if model has wrong frame, engine automatically switches to model first frame
 
@@ -3160,23 +3160,23 @@ int SV_GetTagMatrix (matrix4x4_t *out, edict_t *ent, int tagindex)
        else
                Matrix4x4_CreateIdentity(&tagmatrix);
 
-       if ((val = GETEDICTFIELDVALUE(ent, eval_tag_entity)) && val->edict)
+       if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_tag_entity)) && val->edict)
        { // DP_GFX_QUAKE3MODELTAGS, scan all chain and stop on unattached entity
                attachloop = 0;
                do
                {
-                       attachent = EDICT_NUM(val->edict); // to this it entity our entity is attached
-                       val = GETEDICTFIELDVALUE(ent, eval_tag_index);
-                       if (val->_float >= 1 && attachent->v->modelindex >= 1 && attachent->v->modelindex < MAX_MODELS && (model = sv.models[(int)attachent->v->modelindex]) && model->animscenes && attachent->v->frame >= 0 && attachent->v->frame < model->numframes)
-                               Mod_Alias_GetTagMatrix(model, model->animscenes[(int)attachent->v->frame].firstframe, val->_float - 1, &attachmatrix);
+                       attachent = PRVM_EDICT_NUM(val->edict); // to this it entity our entity is attached
+                       val = PRVM_GETEDICTFIELDVALUE(ent, eval_tag_index);
+                       if (val->_float >= 1 && attachent->fields.server->modelindex >= 1 && attachent->fields.server->modelindex < MAX_MODELS && (model = sv.models[(int)attachent->fields.server->modelindex]) && model->animscenes && attachent->fields.server->frame >= 0 && attachent->fields.server->frame < model->numframes)
+                               Mod_Alias_GetTagMatrix(model, model->animscenes[(int)attachent->fields.server->frame].firstframe, val->_float - 1, &attachmatrix);
                        else
                                Matrix4x4_CreateIdentity(&attachmatrix);
 
                        // apply transformation by child entity matrix
-                       val = GETEDICTFIELDVALUE(ent, eval_scale);
+                       val = PRVM_GETEDICTFIELDVALUE(ent, eval_scale);
                        if (val->_float == 0)
                                val->_float = 1;
-                       Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->v->origin[0], ent->v->origin[1], ent->v->origin[2], -ent->v->angles[0], ent->v->angles[1], ent->v->angles[2], val->_float);
+                       Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2], -ent->fields.server->angles[0], ent->fields.server->angles[1], ent->fields.server->angles[2], val->_float);
                        Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                        out->m[0][3] = entitymatrix.m[0][3] + val->_float*(entitymatrix.m[0][0]*tagmatrix.m[0][3] + entitymatrix.m[0][1]*tagmatrix.m[1][3] + entitymatrix.m[0][2]*tagmatrix.m[2][3]);
                        out->m[1][3] = entitymatrix.m[1][3] + val->_float*(entitymatrix.m[1][0]*tagmatrix.m[0][3] + entitymatrix.m[1][1]*tagmatrix.m[1][3] + entitymatrix.m[1][2]*tagmatrix.m[2][3]);
@@ -3195,30 +3195,30 @@ int SV_GetTagMatrix (matrix4x4_t *out, edict_t *ent, int tagindex)
                        if (attachloop > 255) // prevent runaway looping
                                return 5;
                }
-               while ((val = GETEDICTFIELDVALUE(ent, eval_tag_entity)) && val->edict);
+               while ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_tag_entity)) && val->edict);
        }
 
        // normal or RENDER_VIEWMODEL entity (or main parent entity on attach chain)
-       val = GETEDICTFIELDVALUE(ent, eval_scale);
+       val = PRVM_GETEDICTFIELDVALUE(ent, eval_scale);
        if (val->_float == 0)
                val->_float = 1;
        // Alias models have inverse pitch, bmodels can't have tags, so don't check for modeltype...
-       Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->v->origin[0], ent->v->origin[1], ent->v->origin[2], -ent->v->angles[0], ent->v->angles[1], ent->v->angles[2], val->_float);
+       Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->fields.server->origin[0], ent->fields.server->origin[1], ent->fields.server->origin[2], -ent->fields.server->angles[0], ent->fields.server->angles[1], ent->fields.server->angles[2], val->_float);
        Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
        out->m[0][3] = entitymatrix.m[0][3] + val->_float*(entitymatrix.m[0][0]*tagmatrix.m[0][3] + entitymatrix.m[0][1]*tagmatrix.m[1][3] + entitymatrix.m[0][2]*tagmatrix.m[2][3]);
        out->m[1][3] = entitymatrix.m[1][3] + val->_float*(entitymatrix.m[1][0]*tagmatrix.m[0][3] + entitymatrix.m[1][1]*tagmatrix.m[1][3] + entitymatrix.m[1][2]*tagmatrix.m[2][3]);
        out->m[2][3] = entitymatrix.m[2][3] + val->_float*(entitymatrix.m[2][0]*tagmatrix.m[0][3] + entitymatrix.m[2][1]*tagmatrix.m[1][3] + entitymatrix.m[2][2]*tagmatrix.m[2][3]);
 
-       if ((val = GETEDICTFIELDVALUE(ent, eval_viewmodelforclient)) && val->edict)
+       if ((val = PRVM_GETEDICTFIELDVALUE(ent, eval_viewmodelforclient)) && val->edict)
        {// RENDER_VIEWMODEL magic
                Matrix4x4_Copy(&tagmatrix, out);
-               ent = EDICT_NUM(val->edict);
+               ent = PRVM_EDICT_NUM(val->edict);
 
-               val = GETEDICTFIELDVALUE(ent, eval_scale);
+               val = PRVM_GETEDICTFIELDVALUE(ent, eval_scale);
                if (val->_float == 0)
                        val->_float = 1;
 
-               Matrix4x4_CreateFromQuakeEntity(&entitymatrix, ent->v->origin[0], ent->v->origin[1], ent->v->origin[2] + ent->v->view_ofs[2], ent->v->v_angle[0], ent->v->v_angle[1], ent->v->v_angle[2], val->_float);
+               Matrix4x4_CreateFromQuakeEntity(&entitymatrix, 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], val->_float);
                Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
                out->m[0][3] = entitymatrix.m[0][3] + val->_float*(entitymatrix.m[0][0]*tagmatrix.m[0][3] + entitymatrix.m[0][1]*tagmatrix.m[1][3] + entitymatrix.m[0][2]*tagmatrix.m[2][3]);
                out->m[1][3] = entitymatrix.m[1][3] + val->_float*(entitymatrix.m[1][0]*tagmatrix.m[0][3] + entitymatrix.m[1][1]*tagmatrix.m[1][3] + entitymatrix.m[1][2]*tagmatrix.m[2][3]);
@@ -3226,7 +3226,7 @@ int SV_GetTagMatrix (matrix4x4_t *out, edict_t *ent, int tagindex)
 
                /*
                // Cl_bob, ported from rendering code
-               if (ent->v->health > 0 && cl_bob.value && cl_bobcycle.value)
+               if (ent->fields.server->health > 0 && cl_bob.value && cl_bobcycle.value)
                {
                        double bob, cycle;
                        // LordHavoc: this code is *weird*, but not replacable (I think it
@@ -3241,7 +3241,7 @@ int SV_GetTagMatrix (matrix4x4_t *out, 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)
-                       bob = sqrt(ent->v->velocity[0]*ent->v->velocity[0] + ent->v->velocity[1]*ent->v->velocity[1])*cl_bob.value;
+                       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 = bob*0.3 + bob*0.7*cycle;
                        out->m[2][3] += bound(-7, bob, 4);
                }
@@ -3254,38 +3254,38 @@ int SV_GetTagMatrix (matrix4x4_t *out, edict_t *ent, int tagindex)
 
 void PF_gettagindex (void)
 {
-       edict_t *ent = G_EDICT(OFS_PARM0);
-       const char *tag_name = G_STRING(OFS_PARM1);
+       prvm_edict_t *ent = PRVM_G_EDICT(OFS_PARM0);
+       const char *tag_name = PRVM_G_STRING(OFS_PARM1);
        int modelindex, tag_index;
 
-       if (ent == sv.edicts)
+       if (ent == prog->edicts)
                PF_WARNING("gettagindex: can't affect world entity\n");
-       if (ent->e->free)
+       if (ent->priv.server->free)
                PF_WARNING("gettagindex: can't affect free entity\n");
 
-       modelindex = (int)ent->v->modelindex;
+       modelindex = (int)ent->fields.server->modelindex;
        tag_index = 0;
        if (modelindex <= 0 || modelindex > MAX_MODELS)
-               Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", NUM_FOR_EDICT(ent));
+               Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
        else
        {
                tag_index = SV_GetTagIndex(ent, tag_name);
                if (tag_index == 0)
-                       Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", NUM_FOR_EDICT(ent), tag_name);
+                       Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
        }
-       G_FLOAT(OFS_RETURN) = tag_index;
+       PRVM_G_FLOAT(OFS_RETURN) = tag_index;
 };
 
 //vector(entity ent, float tagindex) gettaginfo;
 void PF_gettaginfo (void)
 {
-       edict_t *e = G_EDICT(OFS_PARM0);
-       int tagindex = (int)G_FLOAT(OFS_PARM1);
+       prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
+       int tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
        matrix4x4_t tag_matrix;
        int returncode;
 
        returncode = SV_GetTagMatrix(&tag_matrix, e, tagindex);
-       Matrix4x4_ToVectors(&tag_matrix, pr_global_struct->v_forward, pr_global_struct->v_right, pr_global_struct->v_up, G_VECTOR(OFS_RETURN));
+       Matrix4x4_ToVectors(&tag_matrix, prog->globals.server->v_forward, prog->globals.server->v_right, prog->globals.server->v_up, PRVM_G_VECTOR(OFS_RETURN));
 
        switch(returncode)
        {
@@ -3296,13 +3296,13 @@ void PF_gettaginfo (void)
                        PF_WARNING("gettagindex: can't affect free entity\n");
                        break;
                case 3:
-                       Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", NUM_FOR_EDICT(e));
+                       Con_DPrintf("SV_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
                        break;
                case 4:
-                       Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", NUM_FOR_EDICT(e), tagindex);
+                       Con_DPrintf("SV_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
                        break;
                case 5:
-                       Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", NUM_FOR_EDICT(e));
+                       Con_DPrintf("SV_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
                        break;
        }
 }
@@ -3344,12 +3344,12 @@ void PF_search_begin(void)
        const char *pattern;
        int caseinsens, quiet;
 
-       pattern = G_STRING(OFS_PARM0);
+       pattern = PRVM_G_STRING(OFS_PARM0);
        if (!pattern || pattern[0] <= ' ')
                PF_ERROR("PF_search_begin: Bad string");
 
-       caseinsens = G_FLOAT(OFS_PARM1);
-       quiet = G_FLOAT(OFS_PARM2);
+       caseinsens = PRVM_G_FLOAT(OFS_PARM1);
+       quiet = PRVM_G_FLOAT(OFS_PARM2);
 
        for(handle = 0; handle < MAX_SEARCHES; handle++)
                if(!pr_fssearchlist[handle])
@@ -3358,14 +3358,14 @@ void PF_search_begin(void)
        if(handle >= MAX_SEARCHES)
        {
                Con_Printf("PR_search_begin: ran out of search handles (%i)\n", MAX_SEARCHES);
-               G_FLOAT(OFS_RETURN) = -2;
+               PRVM_G_FLOAT(OFS_RETURN) = -2;
                return;
        }
 
        if(!(pr_fssearchlist[handle] = FS_Search(pattern,caseinsens, quiet)))
-               G_FLOAT(OFS_RETURN) = -1;
+               PRVM_G_FLOAT(OFS_RETURN) = -1;
        else
-               G_FLOAT(OFS_RETURN) = handle;
+               PRVM_G_FLOAT(OFS_RETURN) = handle;
 }
 
 /*
@@ -3379,7 +3379,7 @@ void PF_search_end(void)
 {
        int handle;
 
-       handle = G_FLOAT(OFS_PARM0);
+       handle = PRVM_G_FLOAT(OFS_PARM0);
 
        if(handle < 0 || handle >= MAX_SEARCHES)
        {
@@ -3407,7 +3407,7 @@ void PF_search_getsize(void)
 {
        int handle;
 
-       handle = G_FLOAT(OFS_PARM0);
+       handle = PRVM_G_FLOAT(OFS_PARM0);
 
        if(handle < 0 || handle >= MAX_SEARCHES)
        {
@@ -3420,7 +3420,7 @@ void PF_search_getsize(void)
                return;
        }
 
-       G_FLOAT(OFS_RETURN) = pr_fssearchlist[handle]->numfilenames;
+       PRVM_G_FLOAT(OFS_RETURN) = pr_fssearchlist[handle]->numfilenames;
 }
 
 /*
@@ -3435,8 +3435,8 @@ void PF_search_getfilename(void)
        int handle, filenum;
        char *tmp;
 
-       handle = G_FLOAT(OFS_PARM0);
-       filenum = G_FLOAT(OFS_PARM1);
+       handle = PRVM_G_FLOAT(OFS_PARM0);
+       filenum = PRVM_G_FLOAT(OFS_PARM1);
 
        if(handle < 0 || handle >= MAX_SEARCHES)
        {
@@ -3457,7 +3457,7 @@ void PF_search_getfilename(void)
        tmp = PR_GetTempString();
        strcpy(tmp, pr_fssearchlist[handle]->filenames[filenum]);
 
-       G_INT(OFS_RETURN) = PR_SetEngineString(tmp);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
 }
 
 void PF_cvar_string (void)
@@ -3466,7 +3466,7 @@ void PF_cvar_string (void)
        cvar_t *var;
        char *tmp;
 
-       str = G_STRING(OFS_PARM0);
+       str = PRVM_G_STRING(OFS_PARM0);
        var = Cvar_FindVar (str);
        if (var)
        {
@@ -3475,7 +3475,7 @@ void PF_cvar_string (void)
        }
        else
                tmp = NULL;
-       G_INT(OFS_RETURN) = PR_SetEngineString(tmp);
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
 }
 
 //void(entity clent) dropclient (DP_SV_DROPCLIENT)
@@ -3483,7 +3483,7 @@ void PF_dropclient (void)
 {
        int clientnum;
        client_t *oldhostclient;
-       clientnum = G_EDICTNUM(OFS_PARM0) - 1;
+       clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
        if (clientnum < 0 || clientnum >= svs.maxclients)
                PF_WARNING("dropclient: not a client\n");
        if (!svs.clients[clientnum].active)
@@ -3498,16 +3498,16 @@ void PF_dropclient (void)
 void PF_spawnclient (void)
 {
        int i;
-       edict_t *ed;
+       prvm_edict_t    *ed;
        pr_xfunction->builtinsprofile += 2;
-       ed = sv.edicts;
+       ed = prog->edicts;
        for (i = 0;i < svs.maxclients;i++)
        {
                if (!svs.clients[i].active)
                {
                        pr_xfunction->builtinsprofile += 100;
                        SV_ConnectClient (i, NULL);
-                       ed = EDICT_NUM(i + 1);
+                       ed = PRVM_EDICT_NUM(i + 1);
                        break;
                }
        }
@@ -3518,15 +3518,15 @@ void PF_spawnclient (void)
 void PF_clienttype (void)
 {
        int clientnum;
-       clientnum = G_EDICTNUM(OFS_PARM0) - 1;
+       clientnum = PRVM_G_EDICTNUM(OFS_PARM0) - 1;
        if (clientnum < 0 || clientnum >= svs.maxclients)
-               G_FLOAT(OFS_RETURN) = 3;
+               PRVM_G_FLOAT(OFS_RETURN) = 3;
        else if (!svs.clients[clientnum].active)
-               G_FLOAT(OFS_RETURN) = 0;
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
        else if (svs.clients[clientnum].netconnection)
-               G_FLOAT(OFS_RETURN) = 1;
+               PRVM_G_FLOAT(OFS_RETURN) = 1;
        else
-               G_FLOAT(OFS_RETURN) = 2;
+               PRVM_G_FLOAT(OFS_RETURN) = 2;
 }
 
 builtin_t pr_builtin[] =
index 15db72d..8d78419 100644 (file)
@@ -22,7 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "quakedef.h"
 
 dprograms_t            *progs;
-mfunction_t            *pr_functions;
+mfunction_t            *prog->functions;
 char                   *pr_strings;
 int                            pr_stringssize;
 ddef_t                 *pr_fielddefs;
@@ -30,7 +30,7 @@ ddef_t                        *pr_globaldefs;
 dstatement_t   *pr_statements;
 globalvars_t   *pr_global_struct;
 float                  *pr_globals;                    // same as pr_global_struct
-int                            pr_edict_size;                  // in bytes
+int                            prog->edict_size;                       // in bytes
 int                            pr_edictareasize;               // LordHavoc: in bytes
 
 int                            pr_maxknownstrings;
@@ -44,7 +44,7 @@ mempool_t             *serverprogs_mempool;
 int            type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};
 
 ddef_t *ED_FieldAtOfs(int ofs);
-qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s);
+qboolean ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s);
 
 cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1"};
 cvar_t nomonsters = {0, "nomonsters", "0"};
@@ -86,7 +86,7 @@ typedef struct {
 static gefv_cache      gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}};
 
 ddef_t *ED_FindField (const char *name);
-mfunction_t *ED_FindFunction (const char *name);
+mfunction_t *PRVM_ED_FindFunction (const char *name);
 
 // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  these are defined as externs in progs.h
 int eval_gravity;
@@ -210,11 +210,11 @@ void FindEdictFieldOffsets(void)
        eval_playerskin = FindFieldOffset("playerskin");
 
        // LordHavoc: allowing QuakeC to override the player movement code
-       SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics");
+       SV_PlayerPhysicsQC = PRVM_ED_FindFunction ("SV_PlayerPhysics");
        // LordHavoc: support for endframe
-       EndFrameQC = ED_FindFunction ("EndFrame");
+       EndFrameQC = PRVM_ED_FindFunction ("EndFrame");
        //KrimZon - SERVER COMMANDS IN QUAKEC
-       SV_ParseClientCommandQC = ED_FindFunction ("SV_ParseClientCommand");
+       SV_ParseClientCommandQC = PRVM_ED_FindFunction ("SV_ParseClientCommand");
 }
 
 /*
@@ -224,30 +224,30 @@ ED_ClearEdict
 Sets everything to NULL
 =================
 */
-void ED_ClearEdict (edict_t *e)
+void ED_ClearEdict (prvm_edict_t *e)
 {
        int num;
        memset (e->v, 0, progs->entityfields * 4);
-       e->e->free = false;
+       e->priv.server->free = false;
        // LordHavoc: for consistency set these here
-       num = NUM_FOR_EDICT(e) - 1;
+       num = PRVM_NUM_FOR_EDICT(e) - 1;
        if (num >= 0 && num < svs.maxclients)
        {
-               eval_t *val;
+               prvm_eval_t *val;
                // set colormap and team on newly created player entity
-               e->v->colormap = num + 1;
-               e->v->team = (svs.clients[num].colors & 15) + 1;
+               e->fields.server->colormap = num + 1;
+               e->fields.server->team = (svs.clients[num].colors & 15) + 1;
                // set netname/clientcolors back to client values so that
                // DP_SV_CLIENTNAME and DPV_SV_CLIENTCOLORS will not immediately
                // reset them
-               e->v->netname = PR_SetEngineString(svs.clients[num].name);
-               if ((val = GETEDICTFIELDVALUE(e, eval_clientcolors)))
+               e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
+               if ((val = PRVM_GETEDICTFIELDVALUE(e, eval_clientcolors)))
                        val->_float = svs.clients[num].colors;
                // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
                if( eval_playermodel )
-                       GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PR_SetEngineString(svs.clients[num].playermodel);
+                       PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
                if( eval_playerskin )
-                       GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PR_SetEngineString(svs.clients[num].playerskin);
+                       PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
        }
 }
 
@@ -262,17 +262,17 @@ instead of being removed and recreated, which can cause interpolated
 angles and bad trails.
 =================
 */
-edict_t *ED_Alloc (void)
+prvm_edict_t *ED_Alloc (void)
 {
        int                     i;
-       edict_t         *e;
+       prvm_edict_t            *e;
 
-       for (i = svs.maxclients + 1;i < sv.num_edicts;i++)
+       for (i = svs.maxclients + 1;i < prog->num_edicts;i++)
        {
-               e = EDICT_NUM(i);
+               e = PRVM_EDICT_NUM(i);
                // the first couple seconds of server time can involve a lot of
                // freeing and allocating, so relax the replacement policy
-               if (e->e->free && ( e->e->freetime < 2 || sv.time - e->e->freetime > 0.5 ) )
+               if (e->priv.server->free && ( e->priv.server->freetime < 2 || sv.time - e->priv.server->freetime > 0.5 ) )
                {
                        ED_ClearEdict (e);
                        return e;
@@ -282,10 +282,10 @@ edict_t *ED_Alloc (void)
        if (i == MAX_EDICTS)
                Host_Error ("ED_Alloc: no free edicts");
 
-       sv.num_edicts++;
-       if (sv.num_edicts >= sv.max_edicts)
+       prog->num_edicts++;
+       if (prog->num_edicts >= prog->max_edicts)
                SV_IncreaseEdicts();
-       e = EDICT_NUM(i);
+       e = PRVM_EDICT_NUM(i);
        ED_ClearEdict (e);
 
        return e;
@@ -299,23 +299,23 @@ Marks the edict as free
 FIXME: walk all entities and NULL out references to this entity
 =================
 */
-void ED_Free (edict_t *ed)
+void ED_Free (prvm_edict_t *ed)
 {
        SV_UnlinkEdict (ed);            // unlink from world bsp
 
-       ed->e->free = true;
-       ed->v->model = 0;
-       ed->v->takedamage = 0;
-       ed->v->modelindex = 0;
-       ed->v->colormap = 0;
-       ed->v->skin = 0;
-       ed->v->frame = 0;
-       VectorClear(ed->v->origin);
-       VectorClear(ed->v->angles);
-       ed->v->nextthink = -1;
-       ed->v->solid = 0;
-
-       ed->e->freetime = sv.time;
+       ed->priv.server->free = true;
+       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;
+
+       ed->priv.server->freetime = sv.time;
 }
 
 //===========================================================================
@@ -371,7 +371,7 @@ ddef_t *ED_FindField (const char *name)
        for (i=0 ; i<progs->numfielddefs ; i++)
        {
                def = &pr_fielddefs[i];
-               if (!strcmp(PR_GetString(def->s_name), name))
+               if (!strcmp(PRVM_GetString(def->s_name), name))
                        return def;
        }
        return NULL;
@@ -390,7 +390,7 @@ ddef_t *ED_FindGlobal (const char *name)
        for (i=0 ; i<progs->numglobaldefs ; i++)
        {
                def = &pr_globaldefs[i];
-               if (!strcmp(PR_GetString(def->s_name), name))
+               if (!strcmp(PRVM_GetString(def->s_name), name))
                        return def;
        }
        return NULL;
@@ -399,18 +399,18 @@ ddef_t *ED_FindGlobal (const char *name)
 
 /*
 ============
-ED_FindFunction
+PRVM_ED_FindFunction
 ============
 */
-mfunction_t *ED_FindFunction (const char *name)
+mfunction_t *PRVM_ED_FindFunction (const char *name)
 {
        mfunction_t             *func;
        int                             i;
 
        for (i=0 ; i<progs->numfunctions ; i++)
        {
-               func = &pr_functions[i];
-               if (!strcmp(PR_GetString(func->s_name), name))
+               func = &prog->functions[i];
+               if (!strcmp(PRVM_GetString(func->s_name), name))
                        return func;
        }
        return NULL;
@@ -424,8 +424,8 @@ PR_ValueString
 Returns a string describing *data in a type specific manner
 =============
 */
-//int NoCrash_NUM_FOR_EDICT(edict_t *e);
-char *PR_ValueString (etype_t type, eval_t *val)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e);
+char *PR_ValueString (etype_t type, prvm_eval_t *val)
 {
        static char line[1024]; // LordHavoc: enlarged a bit (was 256)
        ddef_t *def;
@@ -437,10 +437,10 @@ char *PR_ValueString (etype_t type, eval_t *val)
        switch (type)
        {
        case ev_string:
-               strlcpy (line, PR_GetString (val->string), sizeof (line));
+               strlcpy (line, PRVM_GetString (val->string), sizeof (line));
                break;
        case ev_entity:
-               //n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict));
+               //n = NoCrash_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict));
                n = val->edict;
                if (n < 0 || n >= MAX_EDICTS)
                        dpsnprintf (line, sizeof (line), "entity %i (invalid!)", n);
@@ -448,12 +448,12 @@ char *PR_ValueString (etype_t type, eval_t *val)
                        dpsnprintf (line, sizeof (line), "entity %i", n);
                break;
        case ev_function:
-               f = pr_functions + val->function;
-               dpsnprintf (line, sizeof (line), "%s()", PR_GetString(f->s_name));
+               f = prog->functions + val->function;
+               dpsnprintf (line, sizeof (line), "%s()", PRVM_GetString(f->s_name));
                break;
        case ev_field:
                def = ED_FieldAtOfs ( val->_int );
-               dpsnprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
+               dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
                break;
        case ev_void:
                dpsnprintf (line, sizeof (line), "void");
@@ -485,7 +485,7 @@ Returns a string describing *data in a type specific manner
 Easier to parse than PR_ValueString
 =============
 */
-char *PR_UglyValueString (etype_t type, eval_t *val)
+char *PR_UglyValueString (etype_t type, prvm_eval_t *val)
 {
        static char line[4096];
        int i;
@@ -501,7 +501,7 @@ char *PR_UglyValueString (etype_t type, eval_t *val)
                // Parse the string a bit to turn special characters
                // (like newline, specifically) into escape codes,
                // this fixes saving games from various mods
-               s = PR_GetString (val->string);
+               s = PRVM_GetString (val->string);
                for (i = 0;i < (int)sizeof(line) - 2 && *s;)
                {
                        if (*s == '\n')
@@ -521,15 +521,15 @@ char *PR_UglyValueString (etype_t type, eval_t *val)
                line[i] = '\0';
                break;
        case ev_entity:
-               dpsnprintf (line, sizeof (line), "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
+               dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
                break;
        case ev_function:
-               f = pr_functions + val->function;
-               strlcpy (line, PR_GetString (f->s_name), sizeof (line));
+               f = prog->functions + val->function;
+               strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
                break;
        case ev_field:
                def = ED_FieldAtOfs ( val->_int );
-               dpsnprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
+               dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
                break;
        case ev_void:
                dpsnprintf (line, sizeof (line), "void");
@@ -571,7 +571,7 @@ char *PR_GlobalString (int ofs)
        else
        {
                s = PR_ValueString (def->type, val);
-               dpsnprintf (line, sizeof (line), "%i(%s)%s", ofs, PR_GetString(def->s_name), s);
+               dpsnprintf (line, sizeof (line), "%i(%s)%s", ofs, PRVM_GetString(def->s_name), s);
        }
 
        i = strlen(line);
@@ -592,7 +592,7 @@ char *PR_GlobalStringNoContents (int ofs)
        if (!def)
                dpsnprintf (line, sizeof (line), "%i(?)", ofs);
        else
-               dpsnprintf (line, sizeof (line), "%i(%s)", ofs, PR_GetString(def->s_name));
+               dpsnprintf (line, sizeof (line), "%i(%s)", ofs, PRVM_GetString(def->s_name));
 
        i = strlen(line);
        for ( ; i<20 ; i++)
@@ -612,7 +612,7 @@ For debugging
 */
 // LordHavoc: optimized this to print out much more quickly (tempstring)
 // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
-void ED_Print(edict_t *ed)
+void ED_Print(prvm_edict_t *ed)
 {
        int             l;
        ddef_t  *d;
@@ -622,18 +622,18 @@ void ED_Print(edict_t *ed)
        int             type;
        char    tempstring[8192], tempstring2[260]; // temporary string buffers
 
-       if (ed->e->free)
+       if (ed->priv.server->free)
        {
                Con_Print("FREE\n");
                return;
        }
 
        tempstring[0] = 0;
-       dpsnprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", NUM_FOR_EDICT(ed));
+       dpsnprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", PRVM_NUM_FOR_EDICT(ed));
        for (i=1 ; i<progs->numfielddefs ; i++)
        {
                d = &pr_fielddefs[i];
-               name = PR_GetString(d->s_name);
+               name = PRVM_GetString(d->s_name);
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
@@ -660,7 +660,7 @@ void ED_Print(edict_t *ed)
                        strcat(tempstring, " ");
                strcat(tempstring, " ");
 
-               name = PR_ValueString(d->type, (eval_t *)v);
+               name = PR_ValueString(d->type, (prvm_eval_t *)v);
                if (strlen(name) > 256)
                {
                        memcpy(tempstring2, name, 256);
@@ -687,7 +687,7 @@ ED_Write
 For savegames
 =============
 */
-void ED_Write (qfile_t *f, edict_t *ed)
+void ED_Write (qfile_t *f, prvm_edict_t *ed)
 {
        ddef_t  *d;
        int             *v;
@@ -697,7 +697,7 @@ void ED_Write (qfile_t *f, edict_t *ed)
 
        FS_Print(f, "{\n");
 
-       if (ed->e->free)
+       if (ed->priv.server->free)
        {
                FS_Print(f, "}\n");
                return;
@@ -706,7 +706,7 @@ void ED_Write (qfile_t *f, edict_t *ed)
        for (i=1 ; i<progs->numfielddefs ; i++)
        {
                d = &pr_fielddefs[i];
-               name = PR_GetString(d->s_name);
+               name = PRVM_GetString(d->s_name);
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
@@ -721,7 +721,7 @@ void ED_Write (qfile_t *f, edict_t *ed)
                        continue;
 
                FS_Printf(f,"\"%s\" ",name);
-               FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v));
+               FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (prvm_eval_t *)v));
        }
 
        FS_Print(f, "}\n");
@@ -729,7 +729,7 @@ void ED_Write (qfile_t *f, edict_t *ed)
 
 void ED_PrintNum (int ent)
 {
-       ED_Print(EDICT_NUM(ent));
+       ED_Print(PRVM_EDICT_NUM(ent));
 }
 
 /*
@@ -743,8 +743,8 @@ void ED_PrintEdicts (void)
 {
        int             i;
 
-       Con_Printf("%i entities\n", sv.num_edicts);
-       for (i=0 ; i<sv.num_edicts ; i++)
+       Con_Printf("%i entities\n", prog->num_edicts);
+       for (i=0 ; i<prog->num_edicts ; i++)
                ED_PrintNum (i);
 }
 
@@ -760,7 +760,7 @@ void ED_PrintEdict_f (void)
        int             i;
 
        i = atoi (Cmd_Argv(1));
-       if (i < 0 || i >= sv.num_edicts)
+       if (i < 0 || i >= prog->num_edicts)
        {
                Con_Print("Bad edict number\n");
                return;
@@ -778,25 +778,25 @@ For debugging
 void ED_Count (void)
 {
        int             i;
-       edict_t *ent;
+       prvm_edict_t    *ent;
        int             active, models, solid, step;
 
        active = models = solid = step = 0;
-       for (i=0 ; i<sv.num_edicts ; i++)
+       for (i=0 ; i<prog->num_edicts ; i++)
        {
-               ent = EDICT_NUM(i);
-               if (ent->e->free)
+               ent = PRVM_EDICT_NUM(i);
+               if (ent->priv.server->free)
                        continue;
                active++;
-               if (ent->v->solid)
+               if (ent->fields.server->solid)
                        solid++;
-               if (ent->v->model)
+               if (ent->fields.server->model)
                        models++;
-               if (ent->v->movetype == MOVETYPE_STEP)
+               if (ent->fields.server->movetype == MOVETYPE_STEP)
                        step++;
        }
 
-       Con_Printf("num_edicts:%3i\n", sv.num_edicts);
+       Con_Printf("num_edicts:%3i\n", prog->num_edicts);
        Con_Printf("active    :%3i\n", active);
        Con_Printf("view      :%3i\n", models);
        Con_Printf("touch     :%3i\n", solid);
@@ -837,9 +837,9 @@ void ED_WriteGlobals (qfile_t *f)
                if (type != ev_string && type != ev_float && type != ev_entity)
                        continue;
 
-               name = PR_GetString(def->s_name);
+               name = PRVM_GetString(def->s_name);
                FS_Printf(f,"\"%s\" ", name);
-               FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
+               FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (prvm_eval_t *)&pr_globals[def->ofs]));
        }
        FS_Print(f,"}\n");
 }
@@ -853,7 +853,7 @@ Console command to set a field of a specified edict
 */
 void ED_EdictSet_f(void)
 {
-       edict_t *ed;
+       prvm_edict_t *ed;
        ddef_t *key;
 
        if(Cmd_Argc() != 4)
@@ -861,7 +861,7 @@ void ED_EdictSet_f(void)
                Con_Print("edictset <edict number> <field> <value>\n");
                return;
        }
-       ed = EDICT_NUM(atoi(Cmd_Argv(1)));
+       ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(1)));
 
        if((key = ED_FindField(Cmd_Argv(2))) == 0)
        {
@@ -922,18 +922,18 @@ Can parse either fields or globals
 returns false if error
 =============
 */
-qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s)
+qboolean ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 {
        int i, l;
        char *new_p;
        ddef_t *def;
-       eval_t *val;
+       prvm_eval_t *val;
        mfunction_t *func;
 
        if (ent)
-               val = (eval_t *)((int *)ent->v + key->ofs);
+               val = (prvm_eval_t *)((int *)ent->v + key->ofs);
        else
-               val = (eval_t *)((int *)pr_globals + key->ofs);
+               val = (prvm_eval_t *)((int *)pr_globals + key->ofs);
        switch (key->type & ~DEF_SAVEGLOBAL)
        {
        case ev_string:
@@ -983,12 +983,12 @@ qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s)
                i = atoi(s);
                if (i < 0 || i >= MAX_EDICTS)
                        Con_Printf("ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i)\n", i, MAX_EDICTS);
-               while (i >= sv.max_edicts)
+               while (i >= prog->max_edicts)
                        SV_IncreaseEdicts();
                // if SV_IncreaseEdicts was called the base pointer needs to be updated
                if (ent)
-                       val = (eval_t *)((int *)ent->v + key->ofs);
-               val->edict = EDICT_TO_PROG(EDICT_NUM(i));
+                       val = (prvm_eval_t *)((int *)ent->v + key->ofs);
+               val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(i));
                break;
 
        case ev_field:
@@ -998,22 +998,22 @@ qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s)
                        Con_DPrintf("ED_ParseEpair: Can't find field %s\n", s);
                        return false;
                }
-               //val->_int = G_INT(def->ofs); // AK Please check this - seems to be an org. quake bug
+               //val->_int = PRVM_G_INT(def->ofs); // AK Please check this - seems to be an org. quake bug
                val->_int = def->ofs;
                break;
 
        case ev_function:
-               func = ED_FindFunction(s);
+               func = PRVM_ED_FindFunction(s);
                if (!func)
                {
                        Con_Printf("ED_ParseEpair: Can't find function %s\n", s);
                        return false;
                }
-               val->function = func - pr_functions;
+               val->function = func - prog->functions;
                break;
 
        default:
-               Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PR_GetString(key->s_name));
+               Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PRVM_GetString(key->s_name));
                return false;
        }
        return true;
@@ -1028,7 +1028,7 @@ ed should be a properly initialized empty edict.
 Used for initial level load and for savegames.
 ====================
 */
-const char *ED_ParseEdict (const char *data, edict_t *ent)
+const char *ED_ParseEdict (const char *data, prvm_edict_t *ent)
 {
        ddef_t *key;
        qboolean anglehack;
@@ -1039,7 +1039,7 @@ const char *ED_ParseEdict (const char *data, edict_t *ent)
        init = false;
 
 // clear it
-       if (ent != sv.edicts)   // hack
+       if (ent != prog->edicts)        // hack
                memset (ent->v, 0, progs->entityfields * 4);
 
 // go through all the dictionary pairs
@@ -1104,7 +1104,7 @@ const char *ED_ParseEdict (const char *data, edict_t *ent)
        }
 
        if (!init)
-               ent->e->free = true;
+               ent->priv.server->free = true;
 
        return data;
 }
@@ -1127,7 +1127,7 @@ to call ED_CallSpawnFunctions () to let the objects initialize themselves.
 */
 void ED_LoadFromFile (const char *data)
 {
-       edict_t *ent;
+       prvm_edict_t *ent;
        int parsed, inhibited, spawned, died;
        mfunction_t *func;
 
@@ -1136,7 +1136,7 @@ void ED_LoadFromFile (const char *data)
        inhibited = 0;
        spawned = 0;
        died = 0;
-       pr_global_struct->time = sv.time;
+       prog->globals.server->time = sv.time;
 
 // parse ents
        while (1)
@@ -1148,7 +1148,7 @@ void ED_LoadFromFile (const char *data)
                        Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
 
                if (!ent)
-                       ent = EDICT_NUM(0);
+                       ent = PRVM_EDICT_NUM(0);
                else
                        ent = ED_Alloc ();
                data = ED_ParseEdict (data, ent);
@@ -1159,16 +1159,16 @@ void ED_LoadFromFile (const char *data)
                {
                        if (deathmatch.integer)
                        {
-                               if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
+                               if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
                                {
                                        ED_Free (ent);
                                        inhibited++;
                                        continue;
                                }
                        }
-                       else if ((current_skill <= 0 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_EASY  ))
-                               || (current_skill == 1 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_MEDIUM))
-                               || (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD  )))
+                       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  )))
                        {
                                ED_Free (ent);
                                inhibited++;
@@ -1178,7 +1178,7 @@ void ED_LoadFromFile (const char *data)
 //
 // immediately call spawn function
 //
-               if (!ent->v->classname)
+               if (!ent->fields.server->classname)
                {
                        Con_Print("No classname for:\n");
                        ED_Print(ent);
@@ -1187,7 +1187,7 @@ void ED_LoadFromFile (const char *data)
                }
 
        // look for the spawn function
-               func = ED_FindFunction (PR_GetString(ent->v->classname));
+               func = PRVM_ED_FindFunction (PRVM_GetString(ent->fields.server->classname));
 
                if (!func)
                {
@@ -1200,10 +1200,10 @@ void ED_LoadFromFile (const char *data)
                        continue;
                }
 
-               pr_global_struct->self = EDICT_TO_PROG(ent);
-               PR_ExecuteProgram (func - pr_functions, "QC function spawn is missing");
+               prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+               PRVM_ExecuteProgram (func - prog->functions, "QC function spawn is missing");
                spawned++;
-               if (ent->e->free)
+               if (ent->priv.server->free)
                        died++;
        }
 
@@ -1314,7 +1314,7 @@ void PR_LoadProgs (const char *progsname)
        if (progs->crc != PROGHEADER_CRC && progs->crc != 32401) // tenebrae crc also allowed
                Host_Error ("progs.dat system vars have been modified, progdefs.h is out of date");
 
-       //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
+       //prog->functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
        dfunctions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
 
        pr_strings = (char *)progs + progs->ofs_strings;
@@ -1335,7 +1335,7 @@ void PR_LoadProgs (const char *progsname)
        // so allocate a new place for it
        infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs);
        pr_fielddefs = PR_Alloc((progs->numfielddefs + DPFIELDS) * sizeof(ddef_t));
-       pr_functions = PR_Alloc(sizeof(mfunction_t) * progs->numfunctions);
+       prog->functions = PR_Alloc(sizeof(mfunction_t) * progs->numfunctions);
 
        pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements);
 
@@ -1355,13 +1355,13 @@ void PR_LoadProgs (const char *progsname)
 
        for (i = 0;i < progs->numfunctions;i++)
        {
-               pr_functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
-               pr_functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
-               pr_functions[i].s_name = LittleLong (dfunctions[i].s_name);
-               pr_functions[i].s_file = LittleLong (dfunctions[i].s_file);
-               pr_functions[i].numparms = LittleLong (dfunctions[i].numparms);
-               pr_functions[i].locals = LittleLong (dfunctions[i].locals);
-               memcpy(pr_functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
+               prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
+               prog->functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
+               prog->functions[i].s_name = LittleLong (dfunctions[i].s_name);
+               prog->functions[i].s_file = LittleLong (dfunctions[i].s_file);
+               prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
+               prog->functions[i].locals = LittleLong (dfunctions[i].locals);
+               memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
        }
 
        for (i=0 ; i<progs->numglobaldefs ; i++)
@@ -1386,7 +1386,7 @@ void PR_LoadProgs (const char *progsname)
        {
                pr_fielddefs[progs->numfielddefs].type = dpfields[i].type;
                pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields;
-               pr_fielddefs[progs->numfielddefs].s_name = PR_SetEngineString(dpfields[i].string);
+               pr_fielddefs[progs->numfielddefs].s_name = PRVM_SetEngineString(dpfields[i].string);
                if (pr_fielddefs[progs->numfielddefs].type == ev_vector)
                        progs->entityfields += 3;
                else
@@ -1398,9 +1398,9 @@ void PR_LoadProgs (const char *progsname)
                ((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
 
        // moved edict_size calculation down here, below field adding code
-       // LordHavoc: this no longer includes the edict_t header
-       pr_edict_size = progs->entityfields * 4;
-       pr_edictareasize = pr_edict_size * MAX_EDICTS;
+       // LordHavoc: this no longer includes the prvm_edict_t header
+       prog->edict_size = progs->entityfields * 4;
+       pr_edictareasize = prog->edict_size * MAX_EDICTS;
 
        // LordHavoc: bounds check anything static
        for (i = 0,st = pr_statements;i < progs->numstatements;i++,st++)
@@ -1513,7 +1513,7 @@ void PR_Fields_f (void)
        int *counts;
        const char *name;
        char tempstring[5000], tempstring2[260];
-       edict_t *ed;
+       prvm_edict_t *ed;
        ddef_t *d;
        int *v;
        if (!sv.active)
@@ -1522,15 +1522,15 @@ void PR_Fields_f (void)
                return;
        }
        counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int));
-       for (ednum = 0;ednum < sv.max_edicts;ednum++)
+       for (ednum = 0;ednum < prog->max_edicts;ednum++)
        {
-               ed = EDICT_NUM(ednum);
-               if (ed->e->free)
+               ed = PRVM_EDICT_NUM(ednum);
+               if (ed->priv.server->free)
                        continue;
                for (i = 1;i < progs->numfielddefs;i++)
                {
                        d = &pr_fielddefs[i];
-                       name = PR_GetString(d->s_name);
+                       name = PRVM_GetString(d->s_name);
                        if (name[strlen(name)-2] == '_')
                                continue;       // skip _x, _y, _z vars
                        v = (int *)((char *)ed->v + d->ofs*4);
@@ -1551,7 +1551,7 @@ void PR_Fields_f (void)
        for (i = 0;i < progs->numfielddefs;i++)
        {
                d = &pr_fielddefs[i];
-               name = PR_GetString(d->s_name);
+               name = PRVM_GetString(d->s_name);
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
                switch(d->type & ~DEF_SAVEGLOBAL)
@@ -1610,7 +1610,7 @@ void PR_Fields_f (void)
                }
        }
        Mem_Free(counts);
-       Con_Printf("%i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, sv.max_edicts, progs->entityfields * 4 * sv.max_edicts, usedamount * 4 * sv.max_edicts);
+       Con_Printf("%i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, prog->max_edicts, progs->entityfields * 4 * prog->max_edicts, usedamount * 4 * prog->max_edicts);
 }
 
 void PR_Globals_f (void)
@@ -1622,7 +1622,7 @@ void PR_Globals_f (void)
                return;
        }
        for (i = 0;i < progs->numglobaldefs;i++)
-               Con_Printf("%s\n", PR_GetString(pr_globaldefs[i].s_name));
+               Con_Printf("%s\n", PRVM_GetString(pr_globaldefs[i].s_name));
        Con_Printf("%i global variables, totalling %i bytes\n", progs->numglobals, progs->numglobals * 4);
 }
 
@@ -1706,59 +1706,59 @@ void _PR_FreeAll(const char *filename, int fileline)
 {
        progs = NULL;
        pr_fielddefs = NULL;
-       pr_functions = NULL;
+       prog->functions = NULL;
        _Mem_EmptyPool(serverprogs_mempool, filename, fileline);
 }
 
-// LordHavoc: turned EDICT_NUM into a #define for speed reasons
-edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline)
+// LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
+prvm_edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline)
 {
-       Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
+       Host_Error ("PRVM_EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
        return NULL;
 }
 
 /*
-int NUM_FOR_EDICT_ERROR(edict_t *e)
+int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
 {
-       Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts);
+       Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
        return 0;
 }
 
-int NUM_FOR_EDICT(edict_t *e)
+int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
 {
        int n;
-       n = e - sv.edicts;
+       n = e - prog->edicts;
        if ((unsigned int)n >= MAX_EDICTS)
-               Host_Error ("NUM_FOR_EDICT: bad pointer");
+               Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
        return n;
 }
 
-//int NoCrash_NUM_FOR_EDICT(edict_t *e)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
 //{
-//     return e - sv.edicts;
+//     return e - prog->edicts;
 //}
 
-//#define      EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields))
-//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
-int EDICT_TO_PROG(edict_t *e)
+//#define      PRVM_EDICT_TO_PROG(e) ((qbyte *)(((prvm_edict_t *)e)->v) - (qbyte *)(prog->edictsfields))
+//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
+int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
 {
        int n;
-       n = e - sv.edicts;
-       if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-               Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts);
+       n = e - prog->edicts;
+       if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+               Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, prog->edicts);
        return n;// EXPERIMENTAL
-       //return (qbyte *)e->v - (qbyte *)sv.edictsfields;
+       //return (qbyte *)e->v - (qbyte *)prog->edictsfields;
 }
-edict_t *PROG_TO_EDICT(int n)
+prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
 {
-       if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-               Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
-       return sv.edicts + n; // EXPERIMENTAL
-       //return sv.edicts + ((n) / (progs->entityfields * 4));
+       if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+               Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i\n", n);
+       return prog->edicts + n; // EXPERIMENTAL
+       //return prog->edicts + ((n) / (progs->entityfields * 4));
 }
 */
 
-const char *PR_GetString(int num)
+const char *PRVM_GetString(int num)
 {
        if (num >= 0 && num < pr_stringssize)
                return pr_strings + num;
@@ -1766,12 +1766,12 @@ const char *PR_GetString(int num)
        {
                num = -1 - num;
                if (!pr_knownstrings[num])
-                       Host_Error("PR_GetString: attempt to get string that is already freed\n");
+                       Host_Error("PRVM_GetString: attempt to get string that is already freed\n");
                return pr_knownstrings[num];
        }
        else
        {
-               Host_Error("PR_GetString: invalid string offset %i\n", num);
+               Host_Error("PRVM_GetString: invalid string offset %i\n", num);
                return "";
        }
 }
@@ -1790,13 +1790,13 @@ int PR_SetQCString(const char *s)
        return -1 - i;
 }
 
-int PR_SetEngineString(const char *s)
+int PRVM_SetEngineString(const char *s)
 {
        int i;
        if (!s)
                return 0;
        if (s >= pr_strings && s <= pr_strings + pr_stringssize)
-               Host_Error("PR_SetEngineString: s in pr_strings area\n");
+               Host_Error("PRVM_SetEngineString: s in pr_strings area\n");
        for (i = 0;i < pr_numknownstrings;i++)
                if (pr_knownstrings[i] == s)
                        return -1 - i;
index 2393ed1..a63f04d 100644 (file)
--- a/pr_exec.c
+++ b/pr_exec.c
@@ -199,7 +199,7 @@ void PR_StackTrace (void)
                if (!f)
                        Con_Print("<NULL FUNCTION>\n");
                else
-                       Con_Printf("%12s : %s : statement %i\n", PR_GetString(f->s_file), PR_GetString(f->s_name), pr_stack[i].s - f->first_statement);
+                       Con_Printf("%12s : %s : statement %i\n", PRVM_GetString(f->s_file), PRVM_GetString(f->s_name), pr_stack[i].s - f->first_statement);
        }
 }
 
@@ -233,7 +233,7 @@ void PR_Profile_f (void)
                best = NULL;
                for (i=0 ; i<progs->numfunctions ; i++)
                {
-                       f = &pr_functions[i];
+                       f = &prog->functions[i];
                        if (f->profile > max)
                        {
                                max = f->profile;
@@ -243,7 +243,7 @@ void PR_Profile_f (void)
                if (best)
                {
                        //if (num < howmany)
-                               Con_Printf("%7i %7i %7i %s\n", best->profile, best->builtinsprofile, best->callcount, PR_GetString(best->s_name));
+                               Con_Printf("%7i %7i %7i %s\n", best->profile, best->builtinsprofile, best->callcount, PRVM_GetString(best->s_name));
                        num++;
                        best->profile = 0;
                        best->builtinsprofile = 0;
@@ -280,7 +280,7 @@ void PR_Crash(void)
 
 /*
 ============================================================================
-PR_ExecuteProgram
+PRVM_ExecuteProgram
 
 The interpretation main loop
 ============================================================================
@@ -309,7 +309,7 @@ int PR_EnterFunction (mfunction_t *f)
 // save off any locals that the new function steps on
        c = f->locals;
        if (localstack_used + c > LOCALSTACK_SIZE)
-               Host_Error ("PR_ExecuteProgram: locals stack overflow\n");
+               Host_Error ("PRVM_ExecuteProgram: locals stack overflow\n");
 
        for (i=0 ; i < c ; i++)
                localstack[localstack_used+i] = ((int *)pr_globals)[f->parm_start + i];
@@ -348,7 +348,7 @@ int PR_LeaveFunction (void)
        c = pr_xfunction->locals;
        localstack_used -= c;
        if (localstack_used < 0)
-               Host_Error ("PR_ExecuteProgram: locals stack underflow\n");
+               Host_Error ("PRVM_ExecuteProgram: locals stack underflow\n");
 
        for (i=0 ; i < c ; i++)
                ((int *)pr_globals)[pr_xfunction->parm_start + i] = localstack[localstack_used+i];
@@ -371,31 +371,31 @@ void PR_Execute_ProgsLoaded(void)
 
 /*
 ====================
-PR_ExecuteProgram
+PRVM_ExecuteProgram
 ====================
 */
 // LordHavoc: optimized
-#define OPA ((eval_t *)&pr_globals[(unsigned short) st->a])
-#define OPB ((eval_t *)&pr_globals[(unsigned short) st->b])
-#define OPC ((eval_t *)&pr_globals[(unsigned short) st->c])
+#define OPA ((prvm_eval_t *)&pr_globals[(unsigned short) st->a])
+#define OPB ((prvm_eval_t *)&pr_globals[(unsigned short) st->b])
+#define OPC ((prvm_eval_t *)&pr_globals[(unsigned short) st->c])
 extern cvar_t pr_boundscheck;
 extern cvar_t pr_traceqc;
-void PR_ExecuteProgram (func_t fnum, const char *errormessage)
+void PRVM_ExecuteProgram (func_t fnum, const char *errormessage)
 {
        dstatement_t    *st;
        mfunction_t     *f, *newf;
-       edict_t *ed;
-       eval_t  *ptr;
+       prvm_edict_t    *ed;
+       prvm_eval_t     *ptr;
        int             profile, startprofile, cachedpr_trace, exitdepth;
 
        if (!fnum || fnum >= (unsigned) progs->numfunctions)
        {
-               if (pr_global_struct->self)
-                       ED_Print(PROG_TO_EDICT(pr_global_struct->self));
-               Host_Error ("PR_ExecuteProgram: %s", errormessage);
+               if (prog->globals.server->self)
+                       ED_Print(PRVM_PROG_TO_EDICT(prog->globals.server->self));
+               Host_Error ("PRVM_ExecuteProgram: %s", errormessage);
        }
 
-       f = &pr_functions[fnum];
+       f = &prog->functions[fnum];
 
        pr_trace = pr_traceqc.integer;
 
index 3ea2241..f70f100 100644 (file)
@@ -90,7 +90,7 @@
                                OPC->_float = !OPA->vector[0] && !OPA->vector[1] && !OPA->vector[2];
                                break;
                        case OP_NOT_S:
-                               OPC->_float = !OPA->string || !*PR_GetString(OPA->string);
+                               OPC->_float = !OPA->string || !*PRVM_GetString(OPA->string);
                                break;
                        case OP_NOT_FNC:
                                OPC->_float = !OPA->function;
                                OPC->_float = (OPA->vector[0] == OPB->vector[0]) && (OPA->vector[1] == OPB->vector[1]) && (OPA->vector[2] == OPB->vector[2]);
                                break;
                        case OP_EQ_S:
-                               OPC->_float = !strcmp(PR_GetString(OPA->string),PR_GetString(OPB->string));
+                               OPC->_float = !strcmp(PRVM_GetString(OPA->string),PRVM_GetString(OPB->string));
                                break;
                        case OP_EQ_E:
                                OPC->_float = OPA->_int == OPB->_int;
                                OPC->_float = (OPA->vector[0] != OPB->vector[0]) || (OPA->vector[1] != OPB->vector[1]) || (OPA->vector[2] != OPB->vector[2]);
                                break;
                        case OP_NE_S:
-                               OPC->_float = strcmp(PR_GetString(OPA->string),PR_GetString(OPB->string));
+                               OPC->_float = strcmp(PRVM_GetString(OPA->string),PRVM_GetString(OPB->string));
                                break;
                        case OP_NE_E:
                                OPC->_float = OPA->_int != OPB->_int;
                                        return;
                                }
 #endif
-                               ptr = (eval_t *)((qbyte *)sv.edictsfields + OPB->_int);
+                               ptr = (prvm_eval_t *)((qbyte *)prog->edictsfields + OPB->_int);
                                ptr->_int = OPA->_int;
                                break;
                        case OP_STOREP_V:
                                        return;
                                }
 #endif
-                               ptr = (eval_t *)((qbyte *)sv.edictsfields + OPB->_int);
+                               ptr = (prvm_eval_t *)((qbyte *)prog->edictsfields + OPB->_int);
                                ptr->vector[0] = OPA->vector[0];
                                ptr->vector[1] = OPA->vector[1];
                                ptr->vector[2] = OPA->vector[2];
                                        Host_Error("assignment to world entity");
                                        return;
                                }
-                               ed = PROG_TO_EDICT(OPA->edict);
-                               OPC->_int = (qbyte *)((int *)ed->v + OPB->_int) - (qbyte *)sv.edictsfields;
+                               ed = PRVM_PROG_TO_EDICT(OPA->edict);
+                               OPC->_int = (qbyte *)((int *)ed->v + OPB->_int) - (qbyte *)prog->edictsfields;
                                break;
 
                        case OP_LOAD_F:
                                        return;
                                }
 #endif
-                               ed = PROG_TO_EDICT(OPA->edict);
-                               OPC->_int = ((eval_t *)((int *)ed->v + OPB->_int))->_int;
+                               ed = PRVM_PROG_TO_EDICT(OPA->edict);
+                               OPC->_int = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->_int;
                                break;
 
                        case OP_LOAD_V:
                                        return;
                                }
 #endif
-                               ed = PROG_TO_EDICT(OPA->edict);
-                               OPC->vector[0] = ((eval_t *)((int *)ed->v + OPB->_int))->vector[0];
-                               OPC->vector[1] = ((eval_t *)((int *)ed->v + OPB->_int))->vector[1];
-                               OPC->vector[2] = ((eval_t *)((int *)ed->v + OPB->_int))->vector[2];
+                               ed = PRVM_PROG_TO_EDICT(OPA->edict);
+                               OPC->vector[0] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[0];
+                               OPC->vector[1] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[1];
+                               OPC->vector[2] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[2];
                                break;
 
                //==================
                                else if (OPA->function > (unsigned) progs->numfunctions)
                                        Host_Error("Bad function number");
 
-                               newf = &pr_functions[OPA->function];
+                               newf = &prog->functions[OPA->function];
                                newf->callcount++;
 
                                if (newf->first_statement < 0)
                                pr_xfunction->profile += profile - startprofile;
                                startprofile = profile;
                                pr_xstatement = st - pr_statements;
-                               ed = PROG_TO_EDICT(pr_global_struct->self);
-                               ed->v->nextthink = pr_global_struct->time + 0.1;
-                               ed->v->frame = OPA->_float;
-                               ed->v->think = OPB->function;
+                               ed = PRVM_PROG_TO_EDICT(prog->globals.server->self);
+                               ed->fields.server->nextthink = prog->globals.server->time + 0.1;
+                               ed->fields.server->frame = OPA->_float;
+                               ed->fields.server->think = OPB->function;
                                break;
 
 // LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized
                                        return;
                                }
 #endif
-                               ptr = (eval_t *)((qbyte *)sv.edictsfields + OPB->_int);
+                               ptr = (prvm_eval_t *)((qbyte *)prog->edictsfields + OPB->_int);
                                ptr->_int = OPA->_int;
                                break;
                        case OP_LOAD_I:
                                        return;
                                }
 #endif
-                               ed = PROG_TO_EDICT(OPA->edict);
-                               OPC->_int = ((eval_t *)((int *)ed->v + OPB->_int))->_int;
+                               ed = PRVM_PROG_TO_EDICT(OPA->edict);
+                               OPC->_int = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->_int;
                                break;
 
                        case OP_GSTOREP_I:
diff --git a/progs.h b/progs.h
index 2a2605c..c4bd745 100644 (file)
--- a/progs.h
+++ b/progs.h
@@ -18,8 +18,112 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 */
 
-#ifndef PROGS_H
+#ifndef PROGS_H 
 #define PROGS_H
+#include "pr_comp.h"                   // defs shared with qcc
+
+typedef struct link_s
+{
+       int entitynumber;
+       struct link_s   *prev, *next;
+} link_t;
+
+#define ENTITYGRIDAREAS 16
+
+typedef struct edict_engineprivate_s
+{
+       // true if this edict is unused
+       qboolean free;
+       // sv.time when the object was freed (to prevent early reuse which could
+       // mess up client interpolation or obscure severe QuakeC bugs)
+       float freetime;
+
+       // physics grid areas this edict is linked into
+       link_t areagrid[ENTITYGRIDAREAS];
+       // since the areagrid can have multiple references to one entity,
+       // we should avoid extensive checking on entities already encountered
+       int areagridmarknumber;
+
+       // PROTOCOL_QUAKE, PROTOCOL_QUAKEDP, PROTOCOL_NEHAHRAMOVIE
+       // baseline values
+       entity_state_t baseline;
+
+       // LordHavoc: gross hack to make floating items still work
+       int suspendedinairflag;
+       // used by PushMove to keep track of where objects were before they were
+       // moved, in case they need to be moved back
+       vec3_t moved_from;
+       vec3_t moved_fromangles;
+}
+edict_engineprivate_t;
+
+// LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  see pr_edict.c for the functions which use these.
+extern int eval_gravity;
+extern int eval_button3;
+extern int eval_button4;
+extern int eval_button5;
+extern int eval_button6;
+extern int eval_button7;
+extern int eval_button8;
+extern int eval_buttonuse;
+extern int eval_buttonchat;
+extern int eval_glow_size;
+extern int eval_glow_trail;
+extern int eval_glow_color;
+extern int eval_items2;
+extern int eval_scale;
+extern int eval_alpha;
+extern int eval_renderamt; // HalfLife support
+extern int eval_rendermode; // HalfLife support
+extern int eval_fullbright;
+extern int eval_ammo_shells1;
+extern int eval_ammo_nails1;
+extern int eval_ammo_lava_nails;
+extern int eval_ammo_rockets1;
+extern int eval_ammo_multi_rockets;
+extern int eval_ammo_cells1;
+extern int eval_ammo_plasma;
+extern int eval_idealpitch;
+extern int eval_pitch_speed;
+extern int eval_viewmodelforclient;
+extern int eval_nodrawtoclient;
+extern int eval_exteriormodeltoclient;
+extern int eval_drawonlytoclient;
+extern int eval_ping;
+extern int eval_movement;
+extern int eval_pmodel;
+extern int eval_punchvector;
+extern int eval_viewzoom;
+extern int eval_clientcolors;
+extern int eval_tag_entity;
+extern int eval_tag_index;
+extern int eval_light_lev;
+extern int eval_color;
+extern int eval_style;
+extern int eval_pflags;
+extern int eval_cursor_active;
+extern int eval_cursor_screen;
+extern int eval_cursor_trace_start;
+extern int eval_cursor_trace_endpos;
+extern int eval_cursor_trace_ent;
+extern int eval_colormod;
+extern int eval_playermodel;
+extern int eval_playerskin;
+
+extern mfunction_t *SV_PlayerPhysicsQC;
+extern mfunction_t *EndFrameQC;
+//KrimZon - SERVER COMMANDS IN QUAKEC
+extern mfunction_t *SV_ParseClientCommandQC;
+
+#endif
+
+
+
+
+
+
+//////////////////////////////////
+#if 0
 
 #include "pr_comp.h"                   // defs shared with qcc
 #include "progdefs.h"                  // generated by program cdefs
@@ -33,7 +137,7 @@ typedef union eval_s
        int                             ivector[3];
        int                             _int;
        int                             edict;
-} eval_t;
+} prvm_eval_t;
 
 typedef struct link_s
 {
@@ -79,7 +183,7 @@ typedef struct edict_s
        // QuakeC fields (stored in dynamically resized array)
        entvars_t *v;
 }
-edict_t;
+prvm_edict_t;
 
 // LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue...  see pr_edict.c for the functions which use these.
 extern int eval_gravity;
@@ -134,7 +238,7 @@ extern int eval_colormod;
 extern int eval_playermodel;
 extern int eval_playerskin;
 
-#define GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (eval_t *)((qbyte *)ed->v + fieldoffset) : NULL)
+#define PRVM_GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (prvm_eval_t *)((qbyte *)ed->v + fieldoffset) : NULL)
 
 
 extern mfunction_t *SV_PlayerPhysicsQC;
@@ -145,7 +249,7 @@ extern mfunction_t *SV_ParseClientCommandQC;
 //============================================================================
 
 extern dprograms_t             *progs;
-extern mfunction_t             *pr_functions;
+extern mfunction_t             *prog->functions;
 extern char                    *pr_strings;
 extern int                             pr_stringssize;
 extern ddef_t                  *pr_globaldefs;
@@ -154,7 +258,7 @@ extern      dstatement_t    *pr_statements;
 extern globalvars_t    *pr_global_struct;
 extern float                   *pr_globals;                    // same as pr_global_struct
 
-extern int                             pr_edict_size;  // in bytes
+extern int                             prog->edict_size;       // in bytes
 extern int                             pr_edictareasize; // LordHavoc: for bounds checking
 
 extern int                             pr_maxknownstrings;
@@ -166,7 +270,7 @@ extern      const char              **pr_knownstrings;
 void PR_Init (void);
 void PR_Shutdown (void);
 
-void PR_ExecuteProgram (func_t fnum, const char *errormessage);
+void PRVM_ExecuteProgram (func_t fnum, const char *errormessage);
 void PR_LoadProgs (const char *progsname);
 
 #define PR_Alloc(buffersize) _PR_Alloc(buffersize, __FILE__, __LINE__)
@@ -183,49 +287,49 @@ void PR_Crash (void);
 
 void SV_IncreaseEdicts(void);
 
-edict_t *ED_Alloc (void);
-void ED_Free (edict_t *ed);
-void ED_ClearEdict (edict_t *e);
+prvm_edict_t *ED_Alloc (void);
+void ED_Free (prvm_edict_t *ed);
+void ED_ClearEdict (prvm_edict_t *e);
 
-void ED_Print(edict_t *ed);
-void ED_Write (qfile_t *f, edict_t *ed);
-const char *ED_ParseEdict (const char *data, edict_t *ent);
+void ED_Print(prvm_edict_t *ed);
+void ED_Write (qfile_t *f, prvm_edict_t *ed);
+const char *ED_ParseEdict (const char *data, prvm_edict_t *ent);
 
 void ED_WriteGlobals (qfile_t *f);
 void ED_ParseGlobals (const char *data);
 
 void ED_LoadFromFile (const char *data);
 
-edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline);
-#define EDICT_NUM(n) (((n) >= 0 && (n) < sv.max_edicts) ? sv.edicts + (n) : EDICT_NUM_ERROR(n, __FILE__, __LINE__))
-#define EDICT_NUM_UNSIGNED(n) (((n) < sv.max_edicts) ? sv.edicts + (n) : EDICT_NUM_ERROR(n, __FILE__, __LINE__))
+prvm_edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline);
+#define PRVM_EDICT_NUM(n) (((n) >= 0 && (n) < prog->max_edicts) ? prog->edicts + (n) : EDICT_NUM_ERROR(n, __FILE__, __LINE__))
+#define EDICT_NUM_UNSIGNED(n) (((n) < prog->max_edicts) ? prog->edicts + (n) : EDICT_NUM_ERROR(n, __FILE__, __LINE__))
 
-//int NUM_FOR_EDICT_ERROR(edict_t *e);
-#define NUM_FOR_EDICT(e) ((int)((edict_t *)(e) - sv.edicts))
-//int NUM_FOR_EDICT(edict_t *e);
+//int NUM_FOR_EDICT_ERROR(prvm_edict_t *e);
+#define PRVM_NUM_FOR_EDICT(e) ((int)((prvm_edict_t *)(e) - prog->edicts))
+//int PRVM_NUM_FOR_EDICT(prvm_edict_t *e);
 
-#define        NEXT_EDICT(e) ((e) + 1)
+#define        PRVM_NEXT_EDICT(e) ((e) + 1)
 
-#define EDICT_TO_PROG(e) (NUM_FOR_EDICT(e))
-//int EDICT_TO_PROG(edict_t *e);
-#define PROG_TO_EDICT(n) (EDICT_NUM(n))
-//edict_t *PROG_TO_EDICT(int n);
+#define PRVM_EDICT_TO_PROG(e) (PRVM_NUM_FOR_EDICT(e))
+//int PRVM_EDICT_TO_PROG(prvm_edict_t *e);
+#define PRVM_PROG_TO_EDICT(n) (PRVM_EDICT_NUM(n))
+//prvm_edict_t *PRVM_PROG_TO_EDICT(int n);
 
 //============================================================================
 
-#define        G_FLOAT(o) (pr_globals[o])
-#define        G_INT(o) (*(int *)&pr_globals[o])
-#define        G_EDICT(o) (PROG_TO_EDICT(*(int *)&pr_globals[o]))
-#define G_EDICTNUM(o) NUM_FOR_EDICT(G_EDICT(o))
-#define        G_VECTOR(o) (&pr_globals[o])
-#define        G_STRING(o) (PR_GetString(*(string_t *)&pr_globals[o]))
+#define        PRVM_G_FLOAT(o) (pr_globals[o])
+#define        PRVM_G_INT(o) (*(int *)&pr_globals[o])
+#define        PRVM_G_EDICT(o) (PRVM_PROG_TO_EDICT(*(int *)&pr_globals[o]))
+#define PRVM_G_EDICTNUM(o) PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(o))
+#define        PRVM_G_VECTOR(o) (&pr_globals[o])
+#define        PRVM_G_STRING(o) (PRVM_GetString(*(string_t *)&pr_globals[o]))
 //#define      G_FUNCTION(o) (*(func_t *)&pr_globals[o])
 
 // FIXME: make these go away?
 #define        E_FLOAT(e,o) (((float*)e->v)[o])
 //#define      E_INT(e,o) (((int*)e->v)[o])
 //#define      E_VECTOR(e,o) (&((float*)e->v)[o])
-#define        E_STRING(e,o) (PR_GetString(*(string_t *)&((float*)e->v)[o]))
+#define        E_STRING(e,o) (PRVM_GetString(*(string_t *)&((float*)e->v)[o]))
 
 extern int             type_size[8];
 
@@ -246,9 +350,9 @@ void PR_Execute_ProgsLoaded(void);
 void ED_PrintEdicts (void);
 void ED_PrintNum (int ent);
 
-const char *PR_GetString(int num);
+const char *PRVM_GetString(int num);
 int PR_SetQCString(const char *s);
-int PR_SetEngineString(const char *s);
+int PRVM_SetEngineString(const char *s);
 char *PR_AllocString(int bufferlength);
 void PR_FreeString(char *s);
 
index d702a7d..c40fd82 100644 (file)
--- a/progsvm.h
+++ b/progsvm.h
@@ -30,7 +30,7 @@ The code uses void pointers instead.
 #define PROGSVM_H
 
 #include "pr_comp.h"                   // defs shared with qcc
-//#include "progdefs.h"                        // generated by program cdefs
+#include "progdefs.h"                  // generated by program cdefs
 
 /*
 typedef union vm_eval_s
@@ -152,6 +152,13 @@ typedef union prvm_eval_s
        int                             edict;
 } prvm_eval_t;
 
+typedef struct prvm_required_field_s 
+{
+       int type;
+       const char *name;
+} prvm_required_field_t;
+
+
 /*typedef struct prvm_link_s
 {
        int entitynumber;
@@ -173,7 +180,8 @@ typedef struct prvm_edict_s
        union
        {
                prvm_edict_private_t *required;
-               void                             *vp;
+               void *vp;
+               edict_engineprivate_t *server;
                // add other private structs as you desire
                // new structs have to start with the elements of prvm_edit_private_t
                // e.g. a new struct has to either look like this:
@@ -192,14 +200,14 @@ typedef struct prvm_edict_s
                // However, the first one should be preferred.
        } priv;
        // QuakeC fields (stored in dynamically resized array)
-       //entvars_t *v;
        union 
        {
                void *vp;
+               entvars_t *server;
        } fields;
 } prvm_edict_t;
 
-#define PRVM_GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (prvm_eval_t *)((qbyte *)ed->v + fieldoffset) : NULL)
+#define PRVM_GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (prvm_eval_t *)((qbyte *)ed->fields.vp + fieldoffset) : NULL)
 
 /*// this struct is the basic requirement for a qc prog
 typedef struct prvm_pr_globalvars_s
@@ -250,11 +258,14 @@ typedef struct prvm_prog_s
        ddef_t                          *fielddefs;
        ddef_t                          *globaldefs;
        dstatement_t            *statements;
-       //prvm_pr_globalvars_t*pr_global_struct;
-       float                           *globals;                       // same as pr_global_struct
        int                                     edict_size;                     // in bytes
        int                                     edictareasize;          // LordHavoc: in bytes (for bound checking)
 
+       union {
+               float *generic;
+               globalvars_t *server;
+       } globals;
+
        int                                     maxknownstrings;
        int                                     numknownstrings;
        const char                      **knownstrings;
@@ -279,14 +290,23 @@ typedef struct prvm_prog_s
        int                                     localstack[PRVM_LOCALSTACK_SIZE];
        int                                     localstack_used;
 
-       unsigned short          crc; // [INIT]
+       unsigned short          headercrc; // [INIT]
+
+       unsigned short          filecrc;
 
        //============================================================================
        // until this point everything also exists (with the pr_ prefix) in the old vm
 
        // copies of some vars that were former read from sv
        int                                     num_edicts;
-       int                                     max_edicts;
+       // number of edicts for which space has been (should be) allocated
+       int                                     max_edicts; // [INIT]
+       // used instead of the constant MAX_EDICTS
+       int                                     limit_edicts; // [INIT]
+
+       // number of reserved edicts (allocated from 1)
+       int                                     reserved_edicts; // [INIT]
+
 
        prvm_edict_t            *edicts;
        void                            *edictsfields;
@@ -309,12 +329,11 @@ typedef struct prvm_prog_s
 
        char                            *extensionstring; // [INIT]
 
+       qboolean                        loadintoworld; // [INIT]
+
        // used to indicate whether a prog is loaded
        qboolean                        loaded;
 
-       // used instead of the constant MAX_EDICTS
-       int                                     limit_edicts; // [INIT]
-
 //     prvm_builtin_mem_t  *mem_list;
 
 // now passes as parameter of PRVM_LoadProgs
@@ -331,7 +350,7 @@ typedef struct prvm_prog_s
        void                            (*begin_increase_edicts)(void); // [INIT] used by PRVM_MEM_Increase_Edicts
        void                            (*end_increase_edicts)(void); // [INIT]
 
-       void                            (*init_edict)(int num); // [INIT] used by PRVM_ED_ClearEdict
+       void                            (*init_edict)(prvm_edict_t *edict); // [INIT] used by PRVM_ED_ClearEdict
        void                            (*free_edict)(prvm_edict_t *ed); // [INIT] used by PRVM_ED_Free
 
        void                            (*count_edicts)(void); // [INIT] used by PRVM_ED_Count_f
@@ -345,7 +364,6 @@ typedef struct prvm_prog_s
 
 } prvm_prog_t;
 
-
 extern prvm_prog_t * prog;
 
 #define PRVM_MAXPROGS 3
@@ -400,6 +418,12 @@ void PRVM_PrintState(void);
 void PRVM_CrashAll (void);
 void PRVM_Crash (void);
 
+int PRVM_ED_FindFieldOffset(const char *field);
+ddef_t *PRVM_ED_FindField (const char *name);
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+
+void PRVM_MEM_IncreaseEdicts(void);
+
 prvm_edict_t *PRVM_ED_Alloc (void);
 void PRVM_ED_Free (prvm_edict_t *ed);
 void PRVM_ED_ClearEdict (prvm_edict_t *e);
@@ -415,27 +439,28 @@ void PRVM_ED_LoadFromFile (const char *data);
 
 prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline);
 #define        PRVM_EDICT_NUM(n) (((n) >= 0 && (n) < prog->max_edicts) ? prog->edicts + (n) : PRVM_EDICT_NUM_ERROR(n, __FILE__, __LINE__))
+#define        PRVM_EDICT_NUM_UNSIGNED(n) (((n) < prog->max_edicts) ? prog->edicts + (n) : PRVM_EDICT_NUM_ERROR(n, __FILE__, __LINE__))
 
-//int NUM_FOR_EDICT_ERROR(edict_t *e);
+//int NUM_FOR_EDICT_ERROR(prvm_edict_t *e);
 #define PRVM_NUM_FOR_EDICT(e) ((int)((prvm_edict_t *)(e) - prog->edicts))
-//int NUM_FOR_EDICT(edict_t *e);
+//int PRVM_NUM_FOR_EDICT(prvm_edict_t *e);
 
 #define        PRVM_NEXT_EDICT(e) ((e) + 1)
 
 #define PRVM_EDICT_TO_PROG(e) (PRVM_NUM_FOR_EDICT(e))
-//int PRVM_EDICT_TO_PROG(edict_t *e);
+//int PRVM_EDICT_TO_PROG(prvm_edict_t *e);
 #define PRVM_PROG_TO_EDICT(n) (PRVM_EDICT_NUM(n))
-//edict_t *PRVM_PROG_TO_EDICT(int n);
+//prvm_edict_t *PRVM_PROG_TO_EDICT(int n);
 
 //============================================================================
 
-#define        PRVM_G_FLOAT(o) (prog->globals[o])
-#define        PRVM_G_INT(o) (*(int *)&prog->globals[o])
-#define        PRVM_G_EDICT(o) (PRVM_PROG_TO_EDICT(*(int *)&prog->globals[o]))
+#define        PRVM_G_FLOAT(o) (prog->globals.generic[o])
+#define        PRVM_G_INT(o) (*(int *)&prog->globals.generic[o])
+#define        PRVM_G_EDICT(o) (PRVM_PROG_TO_EDICT(*(int *)&prog->globals.generic[o]))
 #define PRVM_G_EDICTNUM(o) PRVM_NUM_FOR_EDICT(PRVM_G_EDICT(o))
-#define        PRVM_G_VECTOR(o) (&prog->globals[o])
-#define        PRVM_G_STRING(o) (PRVM_GetString(*(string_t *)&prog->globals[o]))
-//#define      PRVM_G_FUNCTION(o) (*(func_t *)&prog->globals[o])
+#define        PRVM_G_VECTOR(o) (&prog->globals.generic[o])
+#define        PRVM_G_STRING(o) (PRVM_GetString(*(string_t *)&prog->globals.generic[o]))
+//#define      PRVM_G_FUNCTION(o) (*(func_t *)&prog->globals.generic[o])
 
 // FIXME: make these go away?
 #define        PRVM_E_FLOAT(e,o) (((float*)e->fields.vp)[o])
@@ -460,10 +485,10 @@ void PRVM_FreeString(char *s);
 //============================================================================
 
 // used as replacement for a prog stack
-//#define PRVM_DEBUGPRSTACK
+#define PRVM_DEBUGPRSTACK
 
 #ifdef PRVM_DEBUGPRSTACK
-#define PRVM_Begin  if(prog != 0) Con_Printf("prog not 0(prog = %i) in file: %s line: %i!\n", PRVM_GetProgNr(), __FILE__, __LINE__)
+#define PRVM_Begin  if(prog != 0) Host_Error("prog not 0(prog = %i) in file: %s line: %i!\n", PRVM_GetProgNr(), __FILE__, __LINE__)
 #define PRVM_End       prog = 0
 #else
 #define PRVM_Begin
@@ -495,7 +520,7 @@ Load a program with LoadProgs
 */
 void PRVM_InitProg(int prognr);
 // LoadProgs expects to be called right after InitProg
-void PRVM_LoadProgs (const char *filename, int numrequiredfunc, char **required_func);
+void PRVM_LoadProgs (const char *filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field);
 void PRVM_ResetProg(void);
 
 qboolean PRVM_ProgLoaded(int prognr);
index f920414..7577d69 100644 (file)
@@ -270,7 +270,7 @@ void EntityFrameQuake_WriteFrame(sizebuf_t *msg, int numstates, const entity_sta
                        bits |= U_EXTERIORMODEL;
 
                // LordHavoc: old stuff, but rewritten to have more exact tolerances
-               baseline = sv.edicts[s->number].e->baseline;
+               baseline = prog->edicts[s->number].priv.server->baseline;
                if (baseline.origin[0] != s->origin[0])
                        bits |= U_ORIGIN1;
                if (baseline.origin[1] != s->origin[1])
@@ -1381,15 +1381,15 @@ void EntityFrame4_WriteFrame(sizebuf_t *msg, entityframe4_database_t *d, int num
                                Con_Printf(" %i", d->commit[i].framenum);
                Con_Print(")\n");
        }
-       if (d->currententitynumber >= sv.max_edicts)
+       if (d->currententitynumber >= prog->max_edicts)
                startnumber = 1;
        else
-               startnumber = bound(1, d->currententitynumber, sv.max_edicts - 1);
+               startnumber = bound(1, d->currententitynumber, prog->max_edicts - 1);
        MSG_WriteShort(msg, startnumber);
        // reset currententitynumber so if the loop does not break it we will
        // start at beginning next frame (if it does break, it will set it)
        d->currententitynumber = 1;
-       for (i = 0, n = startnumber;n < sv.max_edicts;n++)
+       for (i = 0, n = startnumber;n < prog->max_edicts;n++)
        {
                // find the old state to delta from
                e = EntityFrame4_GetReferenceEntity(d, n);
@@ -2025,8 +2025,8 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
        qbyte data[128];
        entityframe5_packetlog_t *packetlog;
 
-       if (sv.max_edicts > d->maxedicts)
-               EntityFrame5_ExpandEdicts(d, (sv.max_edicts + 255) & ~255);
+       if (prog->max_edicts > d->maxedicts)
+               EntityFrame5_ExpandEdicts(d, (prog->max_edicts + 255) & ~255);
 
        framenum = d->latestframenum + 1;
        d->viewentnum = viewentnum;
@@ -2090,8 +2090,8 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
                num++;
        }
        // all remaining entities are dead
-       // note: this must use sv.max_edicts, not sv.num_edicts, because sv.num_edicts can both increase and decrease, where as sv.max_edicts only increases (if sv.num_edicts is used, sometimes some entities are missed when the sv.num_edicts count goes back down after firing some shots)
-       for (;num < sv.max_edicts;num++)
+       // note: this must use prog->max_edicts, not prog->num_edicts, because prog->num_edicts can both increase and decrease, where as prog->max_edicts only increases (if prog->num_edicts is used, sometimes some entities are missed when the prog->num_edicts count goes back down after firing some shots)
+       for (;num < prog->max_edicts;num++)
        {
                if (CHECKPVSBIT(d->visiblebits, num))
                {
@@ -2111,7 +2111,7 @@ void EntityFrame5_WriteFrame(sizebuf_t *msg, entityframe5_database_t *d, int num
        // build lists of entities by priority level
        memset(entityframe5_prioritychaincounts, 0, sizeof(entityframe5_prioritychaincounts));
        l = 0;
-       for (num = 0;num < sv.num_edicts;num++)
+       for (num = 0;num < prog->num_edicts;num++)
        {
                if (d->priorities[num])
                {
index 55a7584..7d8354a 100644 (file)
@@ -11,8 +11,6 @@
 
 // temp string handling
 // LordHavoc: added this to semi-fix the problem of using many ftos calls in a print
-#define VM_STRINGTEMP_BUFFERS 16
-#define VM_STRINGTEMP_LENGTH 4096
 static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH];
 static int vm_string_tempindex = 0;
 
@@ -370,7 +368,7 @@ void VM_vectoangles (void)
                        yaw = 270;
 
                forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
-               pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
+               pitch = (atan2(value1[2], forward) * 180 / M_PI);
                if (pitch < 0)
                        pitch += 360;
        }
@@ -416,15 +414,15 @@ void PF_sound (void)
 {
        char            *sample;
        int                     channel;
-       edict_t         *entity;
+       prvm_edict_t            *entity;
        int             volume;
        float attenuation;
 
-       entity = G_EDICT(OFS_PARM0);
-       channel = G_FLOAT(OFS_PARM1);
-       sample = G_STRING(OFS_PARM2);
-       volume = G_FLOAT(OFS_PARM3) * 255;
-       attenuation = G_FLOAT(OFS_PARM4);
+       entity = PRVM_G_EDICT(OFS_PARM0);
+       channel = PRVM_G_FLOAT(OFS_PARM1);
+       sample = PRVM_G_STRING(OFS_PARM2);
+       volume = PRVM_G_FLOAT(OFS_PARM3) * 255;
+       attenuation = PRVM_G_FLOAT(OFS_PARM4);
 
        if (volume < 0 || volume > 255)
                Host_Error ("SV_StartSound: volume = %i", volume);
@@ -729,11 +727,17 @@ void VM_remove (void)
        VM_SAFEPARMCOUNT(1, VM_remove);
 
        ed = PRVM_G_EDICT(OFS_PARM0);
+       if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) {
+               Con_DPrint( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
+       } else if( ed->priv.required->free ) {
+               Con_DPrint( "VM_remove: tried to remove an already freed entity!\n" );
+       } else {
+               PRVM_ED_Free (ed);
+       }
 //     if (ed == prog->edicts)
 //             PRVM_ERROR ("remove: tried to remove world\n");
 //     if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
 //             Host_Error("remove: tried to remove a client\n");
-       PRVM_ED_Free (ed);
 }
 
 /*
@@ -922,54 +926,6 @@ void VM_findchainfloat (void)
        VM_RETURN_EDICT(chain);
 }
 
-/*
-=========
-VM_precache_file
-
-string precache_file(string)
-=========
-*/
-void VM_precache_file (void)
-{      // precache_file is only used to copy files with qcc, it does nothing
-       VM_SAFEPARMCOUNT(1,VM_precache_file);
-
-       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
-}
-
-/*
-=========
-VM_preache_error
-
-used instead of the other VM_precache_* functions in the builtin list
-=========
-*/
-
-void VM_precache_error (void)
-{
-       PRVM_ERROR ("PF_Precache_*: Precache can only be done in spawn functions");
-}
-
-/*
-=========
-VM_precache_sound
-
-string precache_sound (string sample)
-=========
-*/
-void VM_precache_sound (void)
-{
-       const char      *s;
-
-       VM_SAFEPARMCOUNT(1, VM_precache_sound);
-
-       s = PRVM_G_STRING(OFS_PARM0);
-       PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
-       VM_CheckEmptyString (s);
-
-       if(snd_initialized.integer && !S_PrecacheSound (s,true, true))
-               Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
-}
-
 /*
 =========
 VM_coredump
@@ -1138,98 +1094,6 @@ void VM_nextent (void)
        }
 }
 
-/*
-===============================================================================
-MESSAGE WRITING
-
-used only for client and menu
-severs uses VM_SV_...
-
-Write*(* data, float type, float to)
-
-===============================================================================
-*/
-
-#define        MSG_BROADCAST   0               // unreliable to all
-#define        MSG_ONE                 1               // reliable to one (msg_entity)
-#define        MSG_ALL                 2               // reliable to all
-#define        MSG_INIT                3               // write to the init string
-
-sizebuf_t *VM_WriteDest (void)
-{
-       int             dest;
-       int             destclient;
-
-       if(!sv.active)
-               PRVM_ERROR("VM_WriteDest: game is not server (%s)\n", PRVM_NAME);
-
-       dest = G_FLOAT(OFS_PARM1);
-       switch (dest)
-       {
-       case MSG_BROADCAST:
-               return &sv.datagram;
-
-       case MSG_ONE:
-               destclient = (int) PRVM_G_FLOAT(OFS_PARM2);
-               if (destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active)
-                       PRVM_ERROR("VM_clientcommand: %s: invalid client !\n", PRVM_NAME);
-
-               return &svs.clients[destclient].message;
-
-       case MSG_ALL:
-               return &sv.reliable_datagram;
-
-       case MSG_INIT:
-               return &sv.signon;
-
-       default:
-               PRVM_ERROR ("WriteDest: bad destination");
-               break;
-       }
-
-       return NULL;
-}
-
-void VM_WriteByte (void)
-{
-       MSG_WriteByte (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
-}
-
-void VM_WriteChar (void)
-{
-       MSG_WriteChar (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
-}
-
-void VM_WriteShort (void)
-{
-       MSG_WriteShort (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
-}
-
-void VM_WriteLong (void)
-{
-       MSG_WriteLong (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
-}
-
-void VM_WriteAngle (void)
-{
-       MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
-}
-
-void VM_WriteCoord (void)
-{
-       MSG_WriteCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
-}
-
-void VM_WriteString (void)
-{
-       MSG_WriteString (VM_WriteDest(), PRVM_G_STRING(OFS_PARM0));
-}
-
-void VM_WriteEntity (void)
-{
-       MSG_WriteShort (VM_WriteDest(), PRVM_G_EDICTNUM(OFS_PARM0));
-}
-
 //=============================================================================
 
 /*
@@ -1490,10 +1354,10 @@ setcolor(clientent, value)
 {
        client_t *client;
        int entnum, i;
-       eval_t *val;
+       prvm_eval_t *val;
 
-       entnum = G_EDICTNUM(OFS_PARM0);
-       i = G_FLOAT(OFS_PARM1);
+       entnum = PRVM_G_EDICTNUM(OFS_PARM0);
+       i = PRVM_G_FLOAT(OFS_PARM1);
 
        if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
        {
@@ -1502,11 +1366,11 @@ setcolor(clientent, value)
        }
 
        client = svs.clients + entnum-1;
-       if ((val = GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
+       if ((val = PRVM_GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
                val->_float = i;
        client->colors = i;
        client->old_colors = i;
-       client->edict->v->team = (i & 15) + 1;
+       client->edict->fields.server->team = (i & 15) + 1;
 
        MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
        MSG_WriteByte (&sv.reliable_datagram, entnum - 1);
@@ -1589,16 +1453,7 @@ void VM_fopen(void)
                return;
        }
        filename = PRVM_G_STRING(OFS_PARM0);
-       // .. is parent directory on many platforms
-       // / is parent directory on Amiga
-       // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea)
-       // \ is a windows-ism (so it's naughty to use it, / works on all platforms)
-       if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
-       {
-               Con_Printf("VM_fopen: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
-               PRVM_G_FLOAT(OFS_RETURN) = -4;
-               return;
-       }
+
        VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false, false);
        if (VM_FILES[filenum] == NULL && mode == 0)
                VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false, false);
@@ -1887,50 +1742,38 @@ VM_tokenize
 float tokenize(string s)
 =========
 */
-//float(string s) tokenize = #441;
-// takes apart a string into individal words (access them with argv), returns how many
-// this function originally written by KrimZon, made shorter by LordHavoc
-static char **tokens = NULL;
-static int    max_tokens, num_tokens = 0;
+//float(string s) tokenize = #441; // takes apart a string into individal words (access them with argv), returns how many
+//this function originally written by KrimZon, made shorter by LordHavoc
+//20040203: rewritten by LordHavoc (no longer uses allocations)
+int num_tokens = 0;
+char *tokens[256], tokenbuf[4096];
 void VM_tokenize (void)
 {
-       const char *p, *str;
+       int pos;
+       const char *p;
 
        VM_SAFEPARMCOUNT(1,VM_tokenize);
 
-       str = PRVM_G_STRING(OFS_PARM0);
-
-       if (tokens != NULL)
-       {
-               int i;
-               for (i=0;i<num_tokens;i++)
-                       Z_Free(tokens[i]);
-               Z_Free(tokens);
-               num_tokens = 0;
-       }
-
-       tokens = Z_Malloc(strlen(str) * sizeof(char *));
-       max_tokens = strlen(str);
+       p = PRVM_G_STRING(OFS_PARM0);
 
-       for (p = str;COM_ParseToken(&p, false) && num_tokens < max_tokens;num_tokens++)
+       num_tokens = 0;
+       pos = 0;
+       while(COM_ParseToken(&p, false))
        {
-               tokens[num_tokens] = Z_Malloc(strlen(com_token) + 1);
-               strcpy(tokens[num_tokens], com_token);
+               if (num_tokens >= (int)(sizeof(tokens)/sizeof(tokens[0])))
+                       break;
+               if (pos + strlen(com_token) + 1 > sizeof(tokenbuf))
+                       break;
+               tokens[num_tokens++] = tokenbuf + pos;
+               strcpy(tokenbuf + pos, com_token);
+               pos += strlen(com_token) + 1;
        }
 
        PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
 }
 
-/*
-=========
-VM_argv
-
-string argv(float n)
-=========
-*/
-//string(float n) argv = #442;
-// returns a word from the tokenized string (returns nothing for an invalid index)
-// this function originally written by KrimZon, made shorter by LordHavoc
+//string(float n) argv = #442; // returns a word from the tokenized string (returns nothing for an invalid index)
+//this function originally written by KrimZon, made shorter by LordHavoc
 void VM_argv (void)
 {
        int token_num;
@@ -1938,6 +1781,7 @@ void VM_argv (void)
        VM_SAFEPARMCOUNT(1,VM_argv);
 
        token_num = PRVM_G_FLOAT(OFS_PARM0);
+
        if (token_num >= 0 && token_num < num_tokens)
                PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]);
        else
@@ -1948,43 +1792,43 @@ void VM_argv (void)
 //void(entity e, entity tagentity, string tagname) setattachment = #443; // attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag)
 void PF_setattachment (void)
 {
-       edict_t *e = G_EDICT(OFS_PARM0);
-       edict_t *tagentity = G_EDICT(OFS_PARM1);
-       char *tagname = G_STRING(OFS_PARM2);
-       eval_t *v;
+       prvm_edict_t *e = PRVM_G_EDICT(OFS_PARM0);
+       prvm_edict_t *tagentity = PRVM_G_EDICT(OFS_PARM1);
+       char *tagname = PRVM_G_STRING(OFS_PARM2);
+       prvm_eval_t *v;
        int i, modelindex;
        model_t *model;
 
        if (tagentity == NULL)
-               tagentity = sv.edicts;
+               tagentity = prog->edicts;
 
-       v = GETEDICTFIELDVALUE(e, eval_tag_entity);
+       v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_entity);
        if (v)
-               v->edict = EDICT_TO_PROG(tagentity);
+               fields.server->edict = PRVM_EDICT_TO_PROG(tagentity);
 
-       v = GETEDICTFIELDVALUE(e, eval_tag_index);
+       v = PRVM_GETEDICTFIELDVALUE(e, eval_tag_index);
        if (v)
-               v->_float = 0;
-       if (tagentity != NULL && tagentity != sv.edicts && tagname && tagname[0])
+               fields.server->_float = 0;
+       if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
        {
-               modelindex = (int)tagentity->v->modelindex;
+               modelindex = (int)tagentity->fields.server->modelindex;
                if (modelindex >= 0 && modelindex < MAX_MODELS)
                {
                        model = sv.models[modelindex];
-                       if (model->data_overridetagnamesforskin && (unsigned int)tagentity->v->skin < (unsigned int)model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames)
-                               for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames;i++)
-                                       if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].data_overridetagnames[i].name))
-                                               v->_float = i + 1;
+                       if (model->data_overridetagnamesforskin && (unsigned int)tagentity->fields.server->skin < (unsigned int)model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].num_overridetagnames)
+                               for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].num_overridetagnames;i++)
+                                       if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->fields.server->skin].data_overridetagnames[i].name))
+                                               fields.server->_float = i + 1;
                        // FIXME: use a model function to get tag info (need to handle skeletal)
-                       if (v->_float == 0 && model->num_tags)
+                       if (fields.server->_float == 0 && model->num_tags)
                                for (i = 0;i < model->num_tags;i++)
                                        if (!strcmp(tagname, model->data_tags[i].name))
-                                               v->_float = i + 1;
-                       if (v->_float == 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", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity), model->name);
+                                               fields.server->_float = i + 1;
+                       if (fields.server->_float == 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);
                }
                else
-                       Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity));
+                       Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
        }
 }*/
 
index be993f4..ef95c4f 100644 (file)
@@ -187,12 +187,15 @@ float     getserverlistindexforkey(string key)
 #define VM_SAFEPARMCOUNT(p,f)
 #endif
 
-#define        VM_RETURN_EDICT(e)              (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
+#define        VM_RETURN_EDICT(e)              (((int *)prog->globals.generic)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
 
-#define e10 0,0,0,0,0,0,0,0,0,0
+#define e10 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL
 #define e100 e10,e10,e10,e10,e10,e10,e10,e10,e10,e10
 #define e1000 e100,e100,e100,e100,e100,e100,e100,e100,e100,e100
 
+#define VM_STRINGTEMP_BUFFERS 16
+#define VM_STRINGTEMP_LENGTH 4096
+
 // builtins and other general functions
 
 char *VM_GetTempString(void);
index 53f7e5d..ea7c7f3 100644 (file)
@@ -36,9 +36,6 @@ cvar_t        prvm_boundscheck = {0, "prvm_boundscheck", "1"};
 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
 cvar_t prvm_traceqc = {0, "prvm_traceqc", "0"};
 
-ddef_t *PRVM_ED_FindField (const char *name);
-mfunction_t *PRVM_ED_FindFunction (const char *name);
-
 //============================================================================
 // mempool handling
 
@@ -47,14 +44,14 @@ mfunction_t *PRVM_ED_FindFunction (const char *name);
 PRVM_MEM_Alloc
 ===============
 */
-void PRVM_MEM_Alloc()
+void PRVM_MEM_Alloc(void)
 {
        int i;
 
        // reserve space for the null entity aka world
        // check bound of max_edicts
-       prog->max_edicts = bound(1, prog->max_edicts, prog->limit_edicts);
-       prog->num_edicts = bound(1, prog->num_edicts, prog->max_edicts);
+       prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts);
+       prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts);
 
        // edictprivate_size has to be min as big prvm_edict_private_t
        prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t));
@@ -81,7 +78,7 @@ void PRVM_MEM_Alloc()
 PRVM_MEM_IncreaseEdicts
 ===============
 */
-void PRVM_MEM_IncreaseEdicts()
+void PRVM_MEM_IncreaseEdicts(void)
 {
        int             i;
        int             oldmaxedicts = prog->max_edicts;
@@ -170,12 +167,12 @@ PRVM_SetProg
 */
 void PRVM_SetProg(int prognr)
 {
-       if(prognr && prognr < PRVM_MAXPROGS)
+       if(0 <= prognr && prognr < PRVM_MAXPROGS)
        {
                if(prog_list[prognr].loaded)
                        prog = &prog_list[prognr];
                else
-                       PRVM_ERROR("%i(%s) not loaded !\n", prognr, PRVM_NAME);
+                       PRVM_ERROR("%i not loaded !\n", prognr);
                return;
        }
        PRVM_ERROR("Invalid program number %i\n", prognr);
@@ -193,11 +190,9 @@ void PRVM_ED_ClearEdict (prvm_edict_t *e)
        int num;
        memset (e->fields.vp, 0, prog->progs->entityfields * 4);
        e->priv.required->free = false;
-       // LordHavoc: for consistency set these here
-       num = PRVM_NUM_FOR_EDICT(e) - 1;
 
        // AK: Let the init_edict function determine if something needs to be initialized
-       PRVM_GCALL(init_edict)(num);
+       PRVM_GCALL(init_edict)(e);
 }
 
 /*
@@ -221,7 +216,7 @@ prvm_edict_t *PRVM_ED_Alloc (void)
        // AK:  changed i=svs.maxclients+1
        // AK:  changed so the edict 0 wont spawn -> used as reserved/world entity
        //              although the menu/client has no world
-       for (i = 1;i < prog->num_edicts;i++)
+       for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++)
        {
                e = PRVM_EDICT_NUM(i);
                // the first couple seconds of server time can involve a lot of
@@ -233,7 +228,7 @@ prvm_edict_t *PRVM_ED_Alloc (void)
                }
        }
 
-       if (i == MAX_EDICTS)
+       if (i == prog->limit_edicts)
                PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME);
 
        prog->num_edicts++;
@@ -256,8 +251,8 @@ FIXME: walk all entities and NULL out references to this entity
 */
 void PRVM_ED_Free (prvm_edict_t *ed)
 {
-       // dont delete the null entity (world)
-       if(PRVM_NUM_FOR_EDICT(ed) == 0)
+       // dont delete the null entity (world) or reserved edicts
+       if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
                return;
 
        PRVM_GCALL(free_edict)(ed);
@@ -388,7 +383,7 @@ char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
                break;
        case ev_entity:
                n = val->edict;
-               if (n < 0 || n >= MAX_EDICTS)
+               if (n < 0 || n >= prog->limit_edicts)
                        sprintf (line, "entity %i (invalid!)", n);
                else
                        sprintf (line, "entity %i", n);
@@ -470,7 +465,7 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
                dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
                break;
        case ev_function:
-               f = pr_functions + val->function;
+               f = prog->functions + val->function;
                strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
                break;
        case ev_field:
@@ -510,7 +505,7 @@ char *PRVM_GlobalString (int ofs)
        void    *val;
        static char     line[128];
 
-       val = (void *)&prog->globals[ofs];
+       val = (void *)&prog->globals.generic[ofs];
        def = PRVM_ED_GlobalAtOfs(ofs);
        if (!def)
                sprintf (line,"%i(?)", ofs);
@@ -819,7 +814,7 @@ void PRVM_ED_WriteGlobals (qfile_t *f)
 
                name = PRVM_GetString(def->s_name);
                FS_Printf(f,"\"%s\" ", name);
-               FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals[def->ofs]));
+               FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
        }
        FS_Print(f,"}\n");
 }
@@ -885,7 +880,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
        if (ent)
                val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
        else
-               val = (prvm_eval_t *)((int *)prog->globals + key->ofs);
+               val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs);
        switch (key->type & ~DEF_SAVEGLOBAL)
        {
        case ev_string:
@@ -934,7 +929,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
                while (*s && *s <= ' ')
                        s++;
                i = atoi(s);
-               if (i < 0 || i >= MAX_EDICTS)
+               if (i < 0 || i >= prog->limit_edicts)
                        Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME);
                while (i >= prog->max_edicts)
                        PRVM_MEM_IncreaseEdicts();
@@ -942,7 +937,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
                // if SV_IncreaseEdicts was called the base pointer needs to be updated
                if (ent)
                        val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
-               val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i));
+               val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(i));
                break;
 
        case ev_field:
@@ -966,7 +961,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
                break;
 
        default:
-               Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PR_GetString(key->s_name), PRVM_NAME);
+               Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME);
                return false;
        }
        return true;
@@ -1134,9 +1129,12 @@ void PRVM_ED_LoadFromFile (const char *data)
                if (com_token[0] != '{')
                        PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token);
 
-               // CHANGED: this is not conform to ED_LoadFromFile
-               if(!prog->num_edicts)
+               // CHANGED: this is not conform to PR_LoadFromFile
+               if(prog->loadintoworld)
+               {
+                       prog->loadintoworld = false;
                        ent = PRVM_EDICT_NUM(0);
+               }
                else
                        ent = PRVM_ED_Alloc();
 
@@ -1160,7 +1158,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 //
                if(prog->self && prog->flag & PRVM_FE_CLASSNAME)
                {
-                       string_t handle =  *(string_t*)&((float*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")];
+                       string_t handle =  *(string_t*)&((qbyte*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")];
                        if (!handle)
                        {
                                Con_Print("No classname for:\n");
@@ -1230,7 +1228,7 @@ void PRVM_ResetProg()
 PRVM_LoadProgs
 ===============
 */
-void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func)
+void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field)
 {
        int i;
        dstatement_t *st;
@@ -1243,7 +1241,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
        Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, fs_filesize/1024);
 
-       pr_crc = CRC_Block((qbyte *)prog->progs, fs_filesize);
+       prog->filecrc = CRC_Block((qbyte *)prog->progs, fs_filesize);
 
 // byte swap the header
        for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++)
@@ -1251,10 +1249,10 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
 
        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->crc)
+       if (prog->progs->crc != prog->headercrc)
                PRVM_ERROR ("%s: %s system vars have been modified, progdefs.h is out of date", PRVM_NAME, filename);
 
-       //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
+       //prog->functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
        dfunctions = (dfunction_t *)((qbyte *)prog->progs + prog->progs->ofs_functions);
 
        prog->strings = (char *)prog->progs + prog->progs->ofs_strings;
@@ -1275,14 +1273,14 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
        // so allocate a new place for it
        infielddefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_fielddefs);
        //                                                                                              ( + DPFIELDS                       )
-       prog->fielddefs = Mem_Alloc(prog->progs_mempool, prog->progs->numfielddefs * sizeof(ddef_t));
+       prog->fielddefs = Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t));
 
        prog->statements = (dstatement_t *)((qbyte *)prog->progs + prog->progs->ofs_statements);
 
        // moved edict_size calculation down below field adding code
 
        //pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
-       prog->globals = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals);
+       prog->globals.generic = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals);
 
 // byte swap the lumps
        for (i=0 ; i<prog->progs->numstatements ; i++)
@@ -1322,18 +1320,18 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
                prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
        }
 
-/*     // append the darkplaces fields
-       for (i = 0;i < (int) DPFIELDS;i++)
+       // append the required fields
+       for (i = 0;i < (int) numrequiredfields;i++)
        {
-               pr_fielddefs[progs->numfielddefs].type = dpfields[i].type;
-               pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields;
-               pr_fielddefs[progs->numfielddefs].s_name = PR_SetEngineString(dpfields[i].string);
-               if (pr_fielddefs[progs->numfielddefs].type == ev_vector)
-                       progs->entityfields += 3;
+               prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
+               prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
+               prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
+               if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
+                       prog->progs->entityfields += 3;
                else
-                       progs->entityfields++;
-               progs->numfielddefs++;
-       }*/
+                       prog->progs->entityfields++;
+               prog->progs->numfielddefs++;
+       }
 
        // check required functions
        for(i=0 ; i < numrequiredfunc ; i++)
@@ -1341,12 +1339,12 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
                        PRVM_ERROR("%s: %s not found in %s\n",PRVM_NAME, required_func[i], filename);
 
        for (i=0 ; i<prog->progs->numglobals ; i++)
-               ((int *)prog->globals)[i] = LittleLong (((int *)prog->globals)[i]);
+               ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
 
        // moved edict_size calculation down here, below field adding code
-       // LordHavoc: this no longer includes the edict_t header
+       // LordHavoc: this no longer includes the prvm_edict_t header
        prog->edict_size = prog->progs->entityfields * 4;
-       prog->edictareasize = prog->edict_size * MAX_EDICTS;
+       prog->edictareasize = prog->edict_size * prog->limit_edicts;
 
        // LordHavoc: bounds check anything static
        for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
@@ -1649,7 +1647,7 @@ void PRVM_Global_f(void)
        if( !global )
                Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
        else
-               Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( global->type, (prvm_eval_t *) &prog->globals[ global->ofs ] ) );
+               Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) );
        PRVM_End;
 }
 
@@ -1758,43 +1756,43 @@ void PRVM_ProcessError(void)
 }
 
 /*
-int NUM_FOR_EDICT_ERROR(edict_t *e)
+int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
 {
-       Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts);
+       Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
        return 0;
 }
 
-int NUM_FOR_EDICT(edict_t *e)
+int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
 {
        int n;
-       n = e - sv.edicts;
-       if ((unsigned int)n >= MAX_EDICTS)
-               Host_Error ("NUM_FOR_EDICT: bad pointer");
+       n = e - prog->edicts;
+       if ((unsigned int)n >= prog->limit_edicts)
+               Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
        return n;
 }
 
-//int NoCrash_NUM_FOR_EDICT(edict_t *e)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
 //{
-//     return e - sv.edicts;
+//     return e - prog->edicts;
 //}
 
-//#define      EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields))
-//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
-int EDICT_TO_PROG(edict_t *e)
+//#define      PRVM_EDICT_TO_PROG(e) ((qbyte *)(((prvm_edict_t *)e)->v) - (qbyte *)(prog->edictsfields))
+//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
+int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
 {
        int n;
-       n = e - sv.edicts;
-       if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-               Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts);
+       n = e - prog->edicts;
+       if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+               Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, prog->edicts);
        return n;// EXPERIMENTAL
-       //return (qbyte *)e->v - (qbyte *)sv.edictsfields;
+       //return (qbyte *)e->v - (qbyte *)prog->edictsfields;
 }
-edict_t *PROG_TO_EDICT(int n)
+prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
 {
-       if ((unsigned int)n >= (unsigned int)sv.max_edicts)
-               Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
-       return sv.edicts + n; // EXPERIMENTAL
-       //return sv.edicts + ((n) / (progs->entityfields * 4));
+       if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+               Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i\n", n);
+       return prog->edicts + n; // EXPERIMENTAL
+       //return prog->edicts + ((n) / (progs->entityfields * 4));
 }
 */
 
index 428a158..4314b1f 100644 (file)
@@ -265,6 +265,8 @@ void PRVM_PrintState(void)
 
 void PRVM_Crash()
 {
+
+       //TODO: make this more compilant with PR_Crash
        if (prog->depth < 1)
        {
                // kill the stack just to be sure
@@ -316,7 +318,7 @@ int PRVM_EnterFunction (mfunction_t *f)
                PRVM_ERROR ("PRVM_ExecuteProgram: locals stack overflow in %s\n", PRVM_NAME);
 
        for (i=0 ; i < c ; i++)
-               prog->localstack[prog->localstack_used+i] = ((int *)prog->globals)[f->parm_start + i];
+               prog->localstack[prog->localstack_used+i] = ((int *)prog->globals.generic)[f->parm_start + i];
        prog->localstack_used += c;
 
 // copy parameters
@@ -325,7 +327,7 @@ int PRVM_EnterFunction (mfunction_t *f)
        {
                for (j=0 ; j<f->parm_size[i] ; j++)
                {
-                       ((int *)prog->globals)[o] = ((int *)prog->globals)[OFS_PARM0+i*3+j];
+                       ((int *)prog->globals.generic)[o] = ((int *)prog->globals.generic)[OFS_PARM0+i*3+j];
                        o++;
                }
        }
@@ -355,7 +357,7 @@ int PRVM_LeaveFunction (void)
                PRVM_ERROR ("PRVM_ExecuteProgram: locals stack underflow in %s\n", PRVM_NAME);
 
        for (i=0 ; i < c ; i++)
-               ((int *)prog->globals)[prog->xfunction->parm_start + i] = prog->localstack[prog->localstack_used+i];
+               ((int *)prog->globals.generic)[prog->xfunction->parm_start + i] = prog->localstack[prog->localstack_used+i];
 
 // up stack
        prog->depth--;
@@ -378,9 +380,9 @@ PRVM_ExecuteProgram
 ====================
 */
 // LordHavoc: optimized
-#define OPA ((prvm_eval_t *)&prog->globals[(unsigned short) st->a])
-#define OPB ((prvm_eval_t *)&prog->globals[(unsigned short) st->b])
-#define OPC ((prvm_eval_t *)&prog->globals[(unsigned short) st->c])
+#define OPA ((prvm_eval_t *)&prog->globals.generic[(unsigned short) st->a])
+#define OPB ((prvm_eval_t *)&prog->globals.generic[(unsigned short) st->b])
+#define OPC ((prvm_eval_t *)&prog->globals.generic[(unsigned short) st->c])
 extern cvar_t prvm_boundscheck;
 extern cvar_t prvm_traceqc;
 extern int             PRVM_ED_FindFieldOffset (const char *field);
@@ -397,7 +399,7 @@ void PRVM_ExecuteProgram (func_t fnum, const char *errormessage)
        {
                if (prog->self && PRVM_G_INT(prog->self->ofs))
                        PRVM_ED_Print(PRVM_PROG_TO_EDICT(PRVM_G_INT(prog->self->ofs)));
-               PRVM_ERROR ("PR_ExecuteProgram: %s", errormessage);
+               PRVM_ERROR ("PRVM_ExecuteProgram: %s", errormessage);
        }
 
        f = &prog->functions[fnum];
index d147493..07ca7a1 100644 (file)
                                startprofile = profile;