X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=pr_edict.c;h=1fe3079ddc41b957f52803ca179574be2d31d170;hp=2a77bac1d4df77add0a2927f635045d3f2c6103d;hb=f9d8bc7ea04ff91fcbd90fe50a299b37724b349b;hpb=089076bb769d5306e81d587fd611c4c687d7bf2d diff --git a/pr_edict.c b/pr_edict.c index 2a77bac1..1fe3079d 100644 --- a/pr_edict.c +++ b/pr_edict.c @@ -22,25 +22,29 @@ 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; 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; +int pr_numknownstrings; +const char **pr_knownstrings; + unsigned short pr_crc; -mempool_t *progs_mempool; -mempool_t *edictstring_mempool; +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"}; @@ -71,18 +75,8 @@ cvar_t pr_boundscheck = {0, "pr_boundscheck", "1"}; // LordHavoc: prints every opcode as it executes - warning: this is significant spew cvar_t pr_traceqc = {0, "pr_traceqc", "0"}; -#define MAX_FIELD_LEN 64 -#define GEFV_CACHESIZE 2 - -typedef struct { - ddef_t *pcache; - char field[MAX_FIELD_LEN]; -} gefv_cache; - -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; @@ -92,6 +86,8 @@ int eval_button5; int eval_button6; int eval_button7; int eval_button8; +int eval_buttonuse; +int eval_buttonchat; int eval_glow_size; int eval_glow_trail; int eval_glow_color; @@ -122,6 +118,18 @@ int eval_viewzoom; int eval_clientcolors; int eval_tag_entity; int eval_tag_index; +int eval_light_lev; +int eval_color; +int eval_style; +int eval_pflags; +int eval_cursor_active; +int eval_cursor_screen; +int eval_cursor_trace_start; +int eval_cursor_trace_endpos; +int eval_cursor_trace_ent; +int eval_colormod; +int eval_playermodel; +int eval_playerskin; mfunction_t *SV_PlayerPhysicsQC; mfunction_t *EndFrameQC; @@ -146,6 +154,8 @@ void FindEdictFieldOffsets(void) eval_button6 = FindFieldOffset("button6"); eval_button7 = FindFieldOffset("button7"); eval_button8 = FindFieldOffset("button8"); + eval_buttonuse = FindFieldOffset("buttonuse"); + eval_buttonchat = FindFieldOffset("buttonchat"); eval_glow_size = FindFieldOffset("glow_size"); eval_glow_trail = FindFieldOffset("glow_trail"); eval_glow_color = FindFieldOffset("glow_color"); @@ -176,13 +186,25 @@ void FindEdictFieldOffsets(void) eval_clientcolors = FindFieldOffset("clientcolors"); eval_tag_entity = FindFieldOffset("tag_entity"); eval_tag_index = FindFieldOffset("tag_index"); + eval_light_lev = FindFieldOffset("light_lev"); + eval_color = FindFieldOffset("color"); + eval_style = FindFieldOffset("style"); + eval_pflags = FindFieldOffset("pflags"); + eval_cursor_active = FindFieldOffset("cursor_active"); + eval_cursor_screen = FindFieldOffset("cursor_screen"); + eval_cursor_trace_start = FindFieldOffset("cursor_trace_start"); + eval_cursor_trace_endpos = FindFieldOffset("cursor_trace_endpos"); + eval_cursor_trace_ent = FindFieldOffset("cursor_trace_ent"); + eval_colormod = FindFieldOffset("colormod"); + eval_playermodel = FindFieldOffset("playermodel"); + 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"); } /* @@ -192,18 +214,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) { - e->v->colormap = num + 1; - e->v->team = (svs.clients[num].colors & 15) + 1; - e->v->netname = PR_SetString(svs.clients[num].name); + prvm_eval_t *val; + // set colormap and team on newly created player entity + e->fields.server->colormap = num + 1; + e->fields.server->team = (svs.clients[num].colors & 15) + 1; + // set netname/clientcolors back to client values so that + // DP_SV_CLIENTNAME and DPV_SV_CLIENTCOLORS will not immediately + // reset them + 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 ) + PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel); + if( eval_playerskin ) + PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin); } } @@ -218,17 +252,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; @@ -238,10 +272,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; @@ -255,23 +289,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; } //=========================================================================== @@ -327,7 +361,7 @@ ddef_t *ED_FindField (const char *name) for (i=0 ; inumfielddefs ; 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; @@ -346,7 +380,7 @@ ddef_t *ED_FindGlobal (const char *name) for (i=0 ; inumglobaldefs ; 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; @@ -355,18 +389,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 ; inumfunctions ; 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; @@ -380,8 +414,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; @@ -393,40 +427,40 @@ char *PR_ValueString (etype_t type, eval_t *val) switch (type) { case ev_string: - snprintf (line, sizeof (line), "%s", PR_GetString(val->string)); + 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) - snprintf (line, sizeof (line), "entity %i (invalid!)", n); + dpsnprintf (line, sizeof (line), "entity %i (invalid!)", n); else - snprintf (line, sizeof (line), "entity %i", n); + dpsnprintf (line, sizeof (line), "entity %i", n); break; case ev_function: - f = pr_functions + val->function; - snprintf (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 ); - snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name)); + dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name)); break; case ev_void: - snprintf (line, sizeof (line), "void"); + dpsnprintf (line, sizeof (line), "void"); break; case ev_float: // LordHavoc: changed from %5.1f to %10.4f - snprintf (line, sizeof (line), "%10.4f", val->_float); + dpsnprintf (line, sizeof (line), "%10.4f", val->_float); break; case ev_vector: // LordHavoc: changed from %5.1f to %10.4f - snprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]); + dpsnprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]); break; case ev_pointer: - snprintf (line, sizeof (line), "pointer"); + dpsnprintf (line, sizeof (line), "pointer"); break; default: - snprintf (line, sizeof (line), "bad type %i", type); + dpsnprintf (line, sizeof (line), "bad type %i", type); break; } @@ -441,11 +475,11 @@ 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; - char *s; + const char *s; ddef_t *def; mfunction_t *f; @@ -457,7 +491,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') @@ -477,27 +511,27 @@ char *PR_UglyValueString (etype_t type, eval_t *val) line[i] = '\0'; break; case ev_entity: - snprintf (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; - snprintf (line, sizeof (line), "%s", PR_GetString(f->s_name)); + f = prog->functions + val->function; + strlcpy (line, PRVM_GetString (f->s_name), sizeof (line)); break; case ev_field: def = ED_FieldAtOfs ( val->_int ); - snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name)); + dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name)); break; case ev_void: - snprintf (line, sizeof (line), "void"); + dpsnprintf (line, sizeof (line), "void"); break; case ev_float: - snprintf (line, sizeof (line), "%f", val->_float); + dpsnprintf (line, sizeof (line), "%f", val->_float); break; case ev_vector: - snprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); + dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]); break; default: - snprintf (line, sizeof (line), "bad type %i", type); + dpsnprintf (line, sizeof (line), "bad type %i", type); break; } @@ -523,11 +557,11 @@ char *PR_GlobalString (int ofs) val = (void *)&pr_globals[ofs]; def = ED_GlobalAtOfs(ofs); if (!def) - snprintf (line, sizeof (line), "%i(?)", ofs); + dpsnprintf (line, sizeof (line), "%i(?)", ofs); else { s = PR_ValueString (def->type, val); - snprintf (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); @@ -546,9 +580,9 @@ char *PR_GlobalStringNoContents (int ofs) def = ED_GlobalAtOfs(ofs); if (!def) - snprintf (line, sizeof (line), "%i(?)", ofs); + dpsnprintf (line, sizeof (line), "%i(?)", ofs); else - snprintf (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++) @@ -568,28 +602,28 @@ 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; int *v; int i, j; - char *name; + const char *name; int type; char tempstring[8192], tempstring2[260]; // temporary string buffers - if (ed->e->free) + if (ed->priv.server->free) { - Con_Printf ("FREE\n"); + Con_Print("FREE\n"); return; } tempstring[0] = 0; - snprintf (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 ; inumfielddefs ; 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 @@ -606,7 +640,7 @@ void ED_Print (edict_t *ed) if (strlen(name) > 256) { - strncpy(tempstring2, name, 256); + memcpy (tempstring2, name, 256); tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; tempstring2[259] = 0; name = tempstring2; @@ -616,10 +650,10 @@ 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) { - strncpy(tempstring2, name, 256); + memcpy(tempstring2, name, 256); tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; tempstring2[259] = 0; name = tempstring2; @@ -628,12 +662,12 @@ void ED_Print (edict_t *ed) strlcat (tempstring, "\n", sizeof (tempstring)); if (strlen(tempstring) >= 4096) { - Con_Printf("%s", tempstring); + Con_Print(tempstring); tempstring[0] = 0; } } if (tempstring[0]) - Con_Printf("%s", tempstring); + Con_Print(tempstring); } /* @@ -643,26 +677,26 @@ 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; int i, j; - char *name; + const char *name; int type; - FS_Printf (f, "{\n"); + FS_Print(f, "{\n"); - if (ed->e->free) + if (ed->priv.server->free) { - FS_Printf (f, "}\n"); + FS_Print(f, "}\n"); return; } for (i=1 ; inumfielddefs ; 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 @@ -676,16 +710,16 @@ void ED_Write (qfile_t *f, edict_t *ed) if (j == type_size[type]) continue; - FS_Printf (f,"\"%s\" ",name); - FS_Printf (f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v)); + FS_Printf(f,"\"%s\" ",name); + FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (prvm_eval_t *)v)); } - FS_Printf (f, "}\n"); + FS_Print(f, "}\n"); } void ED_PrintNum (int ent) { - ED_Print (EDICT_NUM(ent)); + ED_Print(PRVM_EDICT_NUM(ent)); } /* @@ -699,8 +733,8 @@ void ED_PrintEdicts (void) { int i; - Con_Printf ("%i entities\n", sv.num_edicts); - for (i=0 ; inum_edicts); + for (i=0 ; inum_edicts ; i++) ED_PrintNum (i); } @@ -716,9 +750,9 @@ void ED_PrintEdict_f (void) int i; i = atoi (Cmd_Argv(1)); - if (i >= sv.num_edicts) + if (i < 0 || i >= prog->num_edicts) { - Con_Printf("Bad edict number\n"); + Con_Print("Bad edict number\n"); return; } ED_PrintNum (i); @@ -734,29 +768,29 @@ 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 ; inum_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 ("active :%3i\n", active); - Con_Printf ("view :%3i\n", models); - Con_Printf ("touch :%3i\n", solid); - Con_Printf ("step :%3i\n", step); + 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); + Con_Printf("step :%3i\n", step); } @@ -778,10 +812,10 @@ void ED_WriteGlobals (qfile_t *f) { ddef_t *def; int i; - char *name; + const char *name; int type; - FS_Printf (f,"{\n"); + FS_Print(f,"{\n"); for (i=0 ; inumglobaldefs ; i++) { def = &pr_globaldefs[i]; @@ -793,11 +827,11 @@ void ED_WriteGlobals (qfile_t *f) if (type != ev_string && type != ev_float && type != ev_entity) continue; - name = PR_GetString(def->s_name); - FS_Printf (f,"\"%s\" ", name); - FS_Printf (f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs])); + name = PRVM_GetString(def->s_name); + FS_Printf(f,"\"%s\" ", name); + FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (prvm_eval_t *)&pr_globals[def->ofs])); } - FS_Printf (f,"}\n"); + FS_Print(f,"}\n"); } /* @@ -809,15 +843,15 @@ 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) { - Con_Printf("edictset \n"); + Con_Print("edictset \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) { @@ -858,7 +892,7 @@ void ED_ParseGlobals (const char *data) key = ED_FindGlobal (keyname); if (!key) { - Con_DPrintf ("'%s' is not a global\n", keyname); + Con_DPrintf("'%s' is not a global\n", keyname); continue; } @@ -870,38 +904,6 @@ void ED_ParseGlobals (const char *data) //============================================================================ -/* -============= -ED_NewString -============= -*/ -char *ED_NewString (const char *string) -{ - char *new, *new_p; - int i,l; - - l = strlen(string) + 1; - new = Mem_Alloc(edictstring_mempool, l); - new_p = new; - - for (i=0 ; i< l ; i++) - { - if (string[i] == '\\' && i < l-1) - { - i++; - if (string[i] == 'n') - *new_p++ = '\n'; - else - *new_p++ = '\\'; - } - else - *new_p++ = string[i]; - } - - return new; -} - - /* ============= ED_ParseEval @@ -910,21 +912,39 @@ 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; + 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: - val->string = PR_SetString(ED_NewString(s)); + l = strlen(s) + 1; + new_p = PR_AllocString(l); + val->string = PR_SetQCString(new_p); + for (i = 0;i < l;i++) + { + if (s[i] == '\\' && i < l-1) + { + i++; + if (s[i] == 'n') + *new_p++ = '\n'; + else if (s[i] == 'r') + *new_p++ = '\r'; + else + *new_p++ = s[i]; + } + else + *new_p++ = s[i]; + } break; case ev_float: @@ -938,13 +958,12 @@ qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s) { while (*s && *s <= ' ') s++; - if (!*s) - break; - val->vector[i] = atof(s); + if (*s) + val->vector[i] = atof(s); + else + val->vector[i] = 0; while (*s > ' ') s++; - if (!*s) - break; } break; @@ -954,12 +973,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: @@ -969,21 +988,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); + //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); + 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; @@ -998,7 +1018,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; @@ -1009,7 +1029,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 @@ -1058,7 +1078,7 @@ const char *ED_ParseEdict (const char *data, edict_t *ent) key = ED_FindField (keyname); if (!key) { - Con_DPrintf ("'%s' is not a field\n", keyname); + Con_DPrintf("'%s' is not a field\n", keyname); continue; } @@ -1066,7 +1086,7 @@ const char *ED_ParseEdict (const char *data, edict_t *ent) { char temp[32]; strlcpy (temp, com_token, sizeof (temp)); - snprintf (com_token, sizeof (com_token), "0 %s 0", temp); + dpsnprintf (com_token, sizeof (com_token), "0 %s 0", temp); } if (!ED_ParseEpair(ent, key, com_token)) @@ -1074,7 +1094,7 @@ const char *ED_ParseEdict (const char *data, edict_t *ent) } if (!init) - ent->e->free = true; + ent->priv.server->free = true; return data; } @@ -1097,7 +1117,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; @@ -1106,7 +1126,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) @@ -1118,64 +1138,66 @@ 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); parsed++; // remove things from different skill levels or deathmatch - if (deathmatch.integer) + if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC { - if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH)) + if (deathmatch.integer) + { + if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH)) + { + ED_Free (ent); + inhibited++; + continue; + } + } + 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++; 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 ))) - { - ED_Free (ent); - inhibited++; - continue; - } - // // immediately call spawn function // - if (!ent->v->classname) + if (!ent->fields.server->classname) { - Con_Printf ("No classname for:\n"); - ED_Print (ent); + Con_Print("No classname for:\n"); + ED_Print(ent); ED_Free (ent); continue; } // 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) { if (developer.integer) // don't confuse non-developers with errors { - Con_Printf ("No spawn function for:\n"); - ED_Print (ent); + Con_Print("No spawn function for:\n"); + ED_Print(ent); } ED_Free (ent); continue; } - pr_global_struct->self = EDICT_TO_PROG(ent); - PR_ExecuteProgram (func - pr_functions, ""); + 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++; } - Con_DPrintf ("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died); + Con_DPrintf("%i entities parsed, %i inhibited, %i spawned (%i removed self, %i stayed)\n", parsed, inhibited, spawned, died, spawned - died); } @@ -1190,42 +1212,57 @@ dpfield_t; dpfield_t dpfields[] = { - {ev_float, "gravity"}, + {ev_entity, "cursor_trace_ent"}, + {ev_entity, "drawonlytoclient"}, + {ev_entity, "exteriormodeltoclient"}, + {ev_entity, "nodrawtoclient"}, + {ev_entity, "tag_entity"}, + {ev_entity, "viewmodelforclient"}, + {ev_float, "alpha"}, + {ev_float, "ammo_cells1"}, + {ev_float, "ammo_lava_nails"}, + {ev_float, "ammo_multi_rockets"}, + {ev_float, "ammo_nails1"}, + {ev_float, "ammo_plasma"}, + {ev_float, "ammo_rockets1"}, + {ev_float, "ammo_shells1"}, {ev_float, "button3"}, {ev_float, "button4"}, {ev_float, "button5"}, {ev_float, "button6"}, {ev_float, "button7"}, {ev_float, "button8"}, + {ev_float, "buttonchat"}, + {ev_float, "buttonuse"}, + {ev_float, "clientcolors"}, + {ev_float, "cursor_active"}, + {ev_float, "fullbright"}, + {ev_float, "glow_color"}, {ev_float, "glow_size"}, {ev_float, "glow_trail"}, - {ev_float, "glow_color"}, - {ev_float, "items2"}, - {ev_float, "scale"}, - {ev_float, "alpha"}, - {ev_float, "renderamt"}, - {ev_float, "rendermode"}, - {ev_float, "fullbright"}, - {ev_float, "ammo_shells1"}, - {ev_float, "ammo_nails1"}, - {ev_float, "ammo_lava_nails"}, - {ev_float, "ammo_rockets1"}, - {ev_float, "ammo_multi_rockets"}, - {ev_float, "ammo_cells1"}, - {ev_float, "ammo_plasma"}, + {ev_float, "gravity"}, {ev_float, "idealpitch"}, - {ev_float, "pitch_speed"}, - {ev_entity, "viewmodelforclient"}, - {ev_entity, "nodrawtoclient"}, - {ev_entity, "exteriormodeltoclient"}, - {ev_entity, "drawonlytoclient"}, + {ev_float, "items2"}, + {ev_float, "light_lev"}, + {ev_float, "pflags"}, {ev_float, "ping"}, - {ev_vector, "movement"}, + {ev_float, "pitch_speed"}, {ev_float, "pmodel"}, + {ev_float, "renderamt"}, // HalfLife support + {ev_float, "rendermode"}, // HalfLife support + {ev_float, "scale"}, + {ev_float, "style"}, + {ev_float, "tag_index"}, + {ev_float, "viewzoom"}, + {ev_vector, "color"}, + {ev_vector, "colormod"}, + {ev_vector, "cursor_screen"}, + {ev_vector, "cursor_trace_endpos"}, + {ev_vector, "cursor_trace_start"}, + {ev_vector, "movement"}, {ev_vector, "punchvector"}, - {ev_float, "clientcolors"}, - {ev_entity, "tag_entity"}, - {ev_float, "tag_index"} + {ev_string, "playermodel"}, + {ev_string, "playerskin"} }; /* @@ -1234,31 +1271,23 @@ PR_LoadProgs =============== */ extern void PR_Cmd_Reset (void); -void PR_LoadProgs (void) +void PR_LoadProgs (const char *progsname) { int i; dstatement_t *st; ddef_t *infielddefs; - void *temp; dfunction_t *dfunctions; -// flush the non-C variable lookup cache - for (i=0 ; iversion != PROG_VERSION) Host_Error ("progs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION); - if (progs->crc != PROGHEADER_CRC) + 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; + pr_stringssize = 0; + for (i = 0;i < progs->numstrings;i++) + { + if (progs->ofs_strings + pr_stringssize >= fs_filesize) + Host_Error ("progs.dat strings go past end of file\n"); + pr_stringssize += strlen (pr_strings + pr_stringssize) + 1; + } + pr_numknownstrings = 0; + pr_maxknownstrings = 0; + pr_knownstrings = NULL; + pr_globaldefs = (ddef_t *)((qbyte *)progs + progs->ofs_globaldefs); // we need to expand the fielddefs list to include all the engine fields, // so allocate a new place for it infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs); - pr_fielddefs = Mem_Alloc(progs_mempool, (progs->numfielddefs + DPFIELDS) * sizeof(ddef_t)); + pr_fielddefs = PR_Alloc((progs->numfielddefs + DPFIELDS) * sizeof(ddef_t)); + prog->functions = PR_Alloc(sizeof(mfunction_t) * progs->numfunctions); pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements); @@ -1297,16 +1339,15 @@ void PR_LoadProgs (void) pr_statements[i].c = LittleShort(pr_statements[i].c); } - pr_functions = Mem_Alloc(progs_mempool, sizeof(mfunction_t) * progs->numfunctions); 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 ; inumglobaldefs ; i++) @@ -1331,7 +1372,7 @@ void PR_LoadProgs (void) { pr_fielddefs[progs->numfielddefs].type = dpfields[i].type; pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields; - pr_fielddefs[progs->numfielddefs].s_name = PR_SetString(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 @@ -1343,9 +1384,9 @@ void PR_LoadProgs (void) ((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++) @@ -1456,25 +1497,26 @@ void PR_Fields_f (void) { int i, j, ednum, used, usedamount; int *counts; - char tempstring[5000], tempstring2[260], *name; - edict_t *ed; + const char *name; + char tempstring[5000], tempstring2[260]; + prvm_edict_t *ed; ddef_t *d; int *v; if (!sv.active) { - Con_Printf("no progs loaded\n"); + Con_Print("no progs loaded\n"); 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); @@ -1495,7 +1537,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) @@ -1525,13 +1567,13 @@ void PR_Fields_f (void) strlcat (tempstring, "pointer ", sizeof (tempstring)); break; default: - snprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL); + dpsnprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL); strlcat (tempstring, tempstring2, sizeof (tempstring)); break; } if (strlen(name) > 256) { - strncpy(tempstring2, name, 256); + memcpy(tempstring2, name, 256); tempstring2[256] = tempstring2[257] = tempstring2[258] = '.'; tempstring2[259] = 0; name = tempstring2; @@ -1539,12 +1581,12 @@ void PR_Fields_f (void) strcat (tempstring, name); for (j = strlen(name);j < 25;j++) strcat(tempstring, " "); - snprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]); + dpsnprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]); strlcat (tempstring, tempstring2, sizeof (tempstring)); strlcat (tempstring, "\n", sizeof (tempstring)); if (strlen(tempstring) >= 4096) { - Con_Printf("%s", tempstring); + Con_Print(tempstring); tempstring[0] = 0; } if (counts[i]) @@ -1554,7 +1596,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) @@ -1562,11 +1604,11 @@ void PR_Globals_f (void) int i; if (!sv.active) { - Con_Printf("no progs loaded\n"); + Con_Print("no progs loaded\n"); 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); } @@ -1618,57 +1660,190 @@ void PR_Init (void) Cvar_RegisterVariable (&pr_boundscheck); Cvar_RegisterVariable (&pr_traceqc); - progs_mempool = Mem_AllocPool("progs.dat"); - edictstring_mempool = Mem_AllocPool("edict strings"); + serverprogs_mempool = Mem_AllocPool("server progs", 0, NULL); PR_Cmd_Init(); } -// LordHavoc: turned EDICT_NUM into a #define for speed reasons -edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline) +/* +=============== +PR_Shutdown +=============== +*/ +extern void PR_Cmd_Shutdown(void); +void PR_Shutdown (void) +{ + PR_Cmd_Shutdown(); + + Mem_FreePool(&serverprogs_mempool); +} + +void *_PR_Alloc(size_t buffersize, const char *filename, int fileline) +{ + return _Mem_Alloc(serverprogs_mempool, buffersize, filename, fileline); +} + +void _PR_Free(void *buffer, const char *filename, int fileline) { - Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline); + _Mem_Free(buffer, filename, fileline); +} + +void _PR_FreeAll(const char *filename, int fileline) +{ + progs = NULL; + pr_fielddefs = NULL; + prog->functions = NULL; + _Mem_EmptyPool(serverprogs_mempool, filename, 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 ("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 *PRVM_GetString(int num) +{ + if (num >= 0 && num < pr_stringssize) + return pr_strings + num; + else if (num < 0 && num >= -pr_numknownstrings) + { + num = -1 - num; + if (!pr_knownstrings[num]) + Host_Error("PRVM_GetString: attempt to get string that is already freed\n"); + return pr_knownstrings[num]; + } + else + { + Host_Error("PRVM_GetString: invalid string offset %i\n", num); + return ""; + } +} + +int PR_SetQCString(const char *s) +{ + int i; + if (!s) + return 0; + if (s >= pr_strings && s <= pr_strings + pr_stringssize) + return s - pr_strings; + for (i = 0;i < pr_numknownstrings;i++) + if (pr_knownstrings[i] == s) + return -1 - i; + Host_Error("PR_SetQCString: unknown string\n"); + return -1 - i; +} + +int PRVM_SetEngineString(const char *s) +{ + int i; + if (!s) + return 0; + if (s >= pr_strings && s <= pr_strings + pr_stringssize) + 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; + // new unknown engine string + if (developer.integer >= 3) + Con_Printf("new engine string %p\n", s); + for (i = 0;i < pr_numknownstrings;i++) + if (!pr_knownstrings[i]) + break; + if (i >= pr_numknownstrings) + { + if (i >= pr_maxknownstrings) + { + const char **oldstrings = pr_knownstrings; + pr_maxknownstrings += 128; + pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *)); + if (pr_numknownstrings) + memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *)); + } + pr_numknownstrings++; + } + pr_knownstrings[i] = s; + return -1 - i; +} + +char *PR_AllocString(int bufferlength) +{ + int i; + if (!bufferlength) + return 0; + for (i = 0;i < pr_numknownstrings;i++) + if (!pr_knownstrings[i]) + break; + if (i >= pr_numknownstrings) + { + if (i >= pr_maxknownstrings) + { + const char **oldstrings = pr_knownstrings; + pr_maxknownstrings += 128; + pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *)); + if (pr_numknownstrings) + memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *)); + } + pr_numknownstrings++; + } + return (char *)(pr_knownstrings[i] = PR_Alloc(bufferlength)); +} + +void PR_FreeString(char *s) +{ + int i; + if (!s) + Host_Error("PR_FreeString: attempt to free a NULL string\n"); + if (s >= pr_strings && s <= pr_strings + pr_stringssize) + Host_Error("PR_FreeString: attempt to free a constant string\n"); + for (i = 0;i < pr_numknownstrings;i++) + if (pr_knownstrings[i] == s) + break; + if (i == pr_numknownstrings) + Host_Error("PR_FreeString: attempt to free a non-existent or already freed string\n"); + PR_Free((char *)pr_knownstrings[i]); + pr_knownstrings[i] = NULL; +} +