2
Copyright (C) 1996-1997 Id Software, Inc.
4
This program is free software; you can redistribute it and/or
5
modify it under the terms of the GNU General Public License
6
as published by the Free Software Foundation; either version 2
7
of the License, or (at your option) any later version.
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13
See the GNU General Public License for more details.
15
You should have received a copy of the GNU General Public License
16
along with this program; if not, write to the Free Software
17
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
// sv_edict.c -- entity dictionary
27
dfunction_t *pr_functions;
30
ddef_t *pr_globaldefs;
31
dstatement_t *pr_statements;
32
globalvars_t *pr_global_struct;
33
float *pr_globals; // same as pr_global_struct
34
int pr_edict_size; // in bytes
36
qbool pr_z_ext_clientcommand;
37
pr_cmdfunction_t pr_cmdfunctions[MAX_PR_CMDFUNCTIONS];
38
int pr_numcmdfunctions;
40
int type_size[8] = {1,sizeof(void *)/4,1,3,1,1,sizeof(void *)/4,sizeof(void *)/4};
42
func_t SpectatorConnect, SpectatorThink, SpectatorDisconnect;
43
func_t BotConnect, BotDisconnect, BotPreThink, BotPostThink;
45
int fofs_maxspeed, fofs_gravity;
46
int fofs_forwardmove, fofs_sidemove, fofs_upmove;
48
int fofs_vw_index, fofs_vw_frame;
52
ddef_t *ED_FieldAtOfs (int ofs);
53
qbool ED_ParseEpair (void *base, ddef_t *key, char *s);
60
Sets everything to NULL and mark as used
63
void ED_ClearEdict (edict_t *e)
65
memset (&e->v, 0, progs->entityfields * 4);
73
Either finds a free edict, or allocates a new one.
74
Try to avoid reusing an entity that was recently freed, because it
75
can cause the client to think the entity morphed into something else
76
instead of being removed and recreated, which can cause interpolated
77
angles and bad trails.
80
edict_t *ED_Alloc (void)
85
for ( i=MAX_CLIENTS+1 ; i<sv.num_edicts ; i++)
88
// the first couple seconds of server time can involve a lot of
89
// freeing and allocating, so relax the replacement policy
90
if (!e->inuse && ( e->freetime < 2 || sv.time - e->freetime > 0.5 ) )
99
Com_Printf ("WARNING: ED_Alloc: no free edicts\n");
100
i--; // step on whatever is the last edict
116
Marks the edict as free
117
FIXME: walk all entities and NULL out references to this entity
120
void ED_Free (edict_t *ed)
122
SV_UnlinkEdict (ed); // unlink from world bsp
126
ed->v.takedamage = 0;
127
ed->v.modelindex = 0;
131
VectorClear (ed->v.origin);
132
VectorClear (ed->v.angles);
133
ed->v.nextthink = -1;
136
ed->freetime = sv.time;
139
//===========================================================================
146
ddef_t *ED_GlobalAtOfs (int ofs)
151
for (i=0 ; i<progs->numglobaldefs ; i++)
153
def = &pr_globaldefs[i];
165
ddef_t *ED_FieldAtOfs (int ofs)
170
for (i=0 ; i<progs->numfielddefs ; i++)
172
def = &pr_fielddefs[i];
184
ddef_t *ED_FindField (char *name)
189
for (i=0 ; i<progs->numfielddefs ; i++)
191
def = &pr_fielddefs[i];
192
if (!strcmp(PR_GetString(def->s_name),name) )
204
ddef_t *ED_FindGlobal (char *name)
209
for (i=0 ; i<progs->numglobaldefs ; i++)
211
def = &pr_globaldefs[i];
212
if (!strcmp(PR_GetString(def->s_name),name) )
224
dfunction_t *ED_FindFunction (char *name)
229
for (i=0 ; i<progs->numfunctions ; i++)
231
func = &pr_functions[i];
232
if (!strcmp(PR_GetString(func->s_name),name) )
238
func_t ED_FindFunctionOffset (char *name)
242
func = ED_FindFunction (name);
243
return func ? (func_t)(func - pr_functions) : 0;
246
int ED_FindFieldOffset (char *field)
249
d = ED_FindField(field);
260
Returns a string describing *data in a type specific manner
263
char *PR_ValueString (etype_t type, eval_t *val)
265
static char line[256];
269
type &= ~DEF_SAVEGLOBAL;
274
sprintf (line, "%s", PR_GetString(val->string));
277
sprintf (line, "entity %i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)) );
280
f = pr_functions + val->function;
281
sprintf (line, "%s()", PR_GetString(f->s_name));
284
def = ED_FieldAtOfs ( val->_int );
285
sprintf (line, ".%s", PR_GetString(def->s_name));
288
sprintf (line, "void");
291
sprintf (line, "%5.1f", val->_float);
294
sprintf (line, "'%5.1f %5.1f %5.1f'", val->vector[0], val->vector[1], val->vector[2]);
297
sprintf (line, "pointer");
300
sprintf (line, "bad type %i", type);
311
Returns a string describing *data in a type specific manner
312
Easier to parse than PR_ValueString
315
char *PR_UglyValueString (etype_t type, eval_t *val)
317
static char line[256];
321
type &= ~DEF_SAVEGLOBAL;
326
sprintf (line, "%s", PR_GetString(val->string));
329
sprintf (line, "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
332
f = pr_functions + val->function;
333
sprintf (line, "%s", PR_GetString(f->s_name));
336
def = ED_FieldAtOfs ( val->_int );
337
sprintf (line, "%s", PR_GetString(def->s_name));
340
sprintf (line, "void");
343
sprintf (line, "%f", val->_float);
346
sprintf (line, "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
349
sprintf (line, "bad type %i", type);
360
Returns a string with a description and the contents of a global,
361
padded to 20 field width
364
char *PR_GlobalString (int ofs)
370
static char line[128];
372
val = (void *)&pr_globals[ofs];
373
def = ED_GlobalAtOfs(ofs);
375
sprintf (line,"%i(?""?""?)", ofs); // separate the ?'s to shut up gcc
378
s = PR_ValueString (def->type, val);
379
sprintf (line,"%i(%s)%s", ofs, PR_GetString(def->s_name), s);
390
char *PR_GlobalStringNoContents (int ofs)
394
static char line[128];
396
def = ED_GlobalAtOfs(ofs);
398
sprintf (line,"%i(?""?""?)", ofs); // separate the ?'s to shut up gcc
400
sprintf (line,"%i(%s)", ofs, PR_GetString(def->s_name));
418
void ED_Print (edict_t *ed)
429
Com_Printf ("FREE\n");
433
for (i=1 ; i<progs->numfielddefs ; i++)
435
d = &pr_fielddefs[i];
436
name = PR_GetString(d->s_name);
437
if (name[strlen(name)-2] == '_')
438
continue; // skip _x, _y, _z vars
440
v = (int *)((char *)&ed->v + d->ofs*4);
442
// if the value is still all 0, skip the field
443
type = d->type & ~DEF_SAVEGLOBAL;
445
for (j=0 ; j<type_size[type] ; j++)
448
if (j == type_size[type])
451
Com_Printf ("%s",name);
456
Com_Printf ("%s\n", PR_ValueString(d->type, (eval_t *)v));
467
void ED_Write (FILE *f, edict_t *ed)
483
for (i=1 ; i<progs->numfielddefs ; i++)
485
d = &pr_fielddefs[i];
486
name = PR_GetString(d->s_name);
487
if (name[strlen(name)-2] == '_')
488
continue; // skip _x, _y, _z vars
490
v = (int *)((char *)&ed->v + d->ofs*4);
492
// if the value is still all 0, skip the field
493
type = d->type & ~DEF_SAVEGLOBAL;
494
for (j=0 ; j<type_size[type] ; j++)
497
if (j == type_size[type])
500
fprintf (f,"\"%s\" ",name);
501
fprintf (f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v));
507
void ED_PrintNum (int ent)
509
ED_Print (EDICT_NUM(ent));
516
For debugging, prints all the entities in the current server
519
void ED_PrintEdicts_f (void)
523
if (sv.state != ss_active)
526
Com_Printf ("%i entities\n", sv.num_edicts);
527
for (i=0 ; i<sv.num_edicts ; i++)
529
if (!EDICT_NUM(i)->inuse)
531
Com_Printf ("\nEDICT %i:\n",i);
540
For debugging, prints a single edict
543
void ED_PrintEdict_f (void)
547
if (sv.state != ss_active)
550
i = Q_atoi (Cmd_Argv(1));
551
Com_Printf ("\n EDICT %i:\n",i);
562
void ED_EdictCount_f (void)
566
int active, models, solid, step;
568
if (sv.state != ss_active)
571
active = models = solid = step = 0;
572
for (i=0 ; i<sv.num_edicts ; i++)
582
if (ent->v.movetype == MOVETYPE_STEP)
586
Com_Printf ("num_edicts:%3i\n", sv.num_edicts);
587
Com_Printf ("active :%3i\n", active);
588
Com_Printf ("view :%3i\n", models);
589
Com_Printf ("touch :%3i\n", solid);
590
Com_Printf ("step :%3i\n", step);
595
==============================================================================
599
FIXME: need to tag constants, doesn't really work
600
==============================================================================
608
void ED_WriteGlobals (FILE *f)
616
for (i=0 ; i<progs->numglobaldefs ; i++)
618
def = &pr_globaldefs[i];
620
if ( !(def->type & DEF_SAVEGLOBAL) )
622
type &= ~DEF_SAVEGLOBAL;
624
if (type != ev_string
626
&& type != ev_entity)
629
name = PR_GetString(def->s_name);
630
fprintf (f,"\"%s\" ", name);
631
fprintf (f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
641
void ED_ParseGlobals (char *data)
649
data = COM_Parse (data);
650
if (com_token[0] == '}')
653
Host_Error ("ED_ParseEntity: EOF without closing brace");
655
strcpy (keyname, com_token);
658
data = COM_Parse (data);
660
Host_Error ("ED_ParseEntity: EOF without closing brace");
662
if (com_token[0] == '}')
663
Host_Error ("ED_ParseEntity: closing brace without data");
665
key = ED_FindGlobal (keyname);
668
Com_Printf ("%s is not a global\n", keyname);
672
if (!ED_ParseEpair ((void *)pr_globals, key, com_token))
673
Host_Error ("ED_ParseGlobals: parse error");
677
//============================================================================
685
char *ED_NewString (char *string)
690
l = strlen(string) + 1;
691
new = Hunk_Alloc (l);
694
for (i=0 ; i< l ; i++)
696
if (string[i] == '\\' && i < l-1)
699
if (string[i] == 'n')
705
*new_p++ = string[i];
716
Can parse either fields or globals
717
returns false if error
720
qbool ED_ParseEpair (void *base, ddef_t *key, char *s)
729
d = (void *)((int *)base + key->ofs);
731
switch (key->type & ~DEF_SAVEGLOBAL)
734
*(string_t *)d = PR_SetString(ED_NewString (s));
738
*(float *)d = atof (s);
745
for (i=0 ; i<3 ; i++)
747
while (*v && *v != ' ')
750
((float *)d)[i] = atof (w);
756
*(int *)d = EDICT_TO_PROG(EDICT_NUM(atoi (s)));
760
def = ED_FindField (s);
763
Com_Printf ("Can't find field %s\n", s);
766
*(int *)d = G_INT(def->ofs);
770
func = ED_FindFunction (s);
773
Com_Printf ("Can't find function %s\n", s);
776
*(func_t *)d = func - pr_functions;
789
Parses an edict out of the given string, returning the new position
790
ed should be a properly initialized empty edict.
791
Used for initial level load and for savegames.
794
char *ED_ParseEdict (char *data, edict_t *ent)
797
qbool anglehack, skyhack;
804
if (ent != sv.edicts) // hack
805
memset (&ent->v, 0, progs->entityfields * 4);
807
// go through all the dictionary pairs
811
data = COM_Parse (data);
812
if (com_token[0] == '}')
815
Host_Error ("ED_ParseEntity: EOF without closing brace");
817
// anglehack is to allow QuakeEd to write single scalar angles
818
// and allow them to be turned into vectors. (FIXME...)
819
if (!strcmp(com_token, "angle"))
821
strcpy (com_token, "angles");
827
// FIXME: change light to _light to get rid of this hack
828
if (!strcmp(com_token, "light"))
829
strcpy (com_token, "light_lev"); // hack for single light def
831
strcpy (keyname, com_token);
834
data = COM_Parse (data);
836
Host_Error ("ED_ParseEntity: EOF without closing brace");
838
if (com_token[0] == '}')
839
Host_Error ("ED_ParseEntity: closing brace without data");
844
if (ent == sv.edicts && (!strcmp(keyname, "sky") || !strcmp(keyname, "skyname")))
847
strlcpy (sv.sky, com_token, sizeof(sv.sky));
848
if (strstr(sv.sky, ".."))
852
// keynames with a leading underscore are used for utility comments,
853
// and are immediately discarded by quake
854
if (keyname[0] == '_')
857
key = ED_FindField (keyname);
861
Com_Printf ("%s is not a field\n", keyname);
868
strcpy (temp, com_token);
869
sprintf (com_token, "0 %s 0", temp);
872
if (!ED_ParseEpair ((void *)&ent->v, key, com_token))
873
Host_Error ("ED_ParseEdict: parse error");
887
The entities are directly placed in the array, rather than allocated with
888
ED_Alloc, because otherwise an error loading the map would have entity
889
number references out of order.
891
Creates a server's entity / program execution context by
892
parsing textual entity definitions out of an ent file.
894
Used for both fresh maps and savegame loads. A fresh map would also need
895
to call ED_CallSpawnFunctions () to let the objects initialize themselves.
898
void ED_LoadFromFile (char *data)
906
pr_global_struct->time = sv.time;
911
// parse the opening brace
912
data = COM_Parse (data);
915
if (com_token[0] != '{')
916
Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
922
data = ED_ParseEdict (data, ent);
924
// remove things from different skill levels or deathmatch
925
if (deathmatch.value)
927
if (((int)ent->v.spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
934
else if ((current_skill == 0 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_EASY))
935
|| (current_skill == 1 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_MEDIUM))
936
|| (current_skill >= 2 && ((int)ent->v.spawnflags & SPAWNFLAG_NOT_HARD)) )
944
// immediately call spawn function
946
if (!ent->v.classname)
948
Com_Printf ("No classname for:\n");
954
// look for the spawn function
955
func = ED_FindFunction ( PR_GetString(ent->v.classname) );
959
Com_Printf ("No spawn function for:\n");
965
pr_global_struct->self = EDICT_TO_PROG(ent);
966
PR_ExecuteProgram (func - pr_functions);
970
Com_DPrintf ("%i entities inhibited\n", inhibit);
974
void PR_CheckExtensions (void)
976
pr_z_ext_clientcommand = false;
978
if (ED_FindGlobal("z_ext_clientcommand"))
979
pr_z_ext_clientcommand = true;
986
Enumerate all Cmd_* functions (z_ext_clientcommand extension)
989
void PR_FindCmdFunctions (void)
995
pr_numcmdfunctions = 0;
997
if (!pr_z_ext_clientcommand)
1000
for (i=0 ; i<progs->numfunctions ; i++)
1002
func = &pr_functions[i];
1003
name = PR_GetString(func->s_name);
1004
if (!strncmp(name, "Cmd_", 4)) {
1005
strlcpy (pr_cmdfunctions[pr_numcmdfunctions].name, name + 4, sizeof(pr_cmdfunctions[0].name));
1006
pr_cmdfunctions[pr_numcmdfunctions].funcnum = i;
1007
pr_numcmdfunctions++;
1008
if (pr_numcmdfunctions == MAX_PR_CMDFUNCTIONS)
1019
void PR_LoadProgs (void)
1023
static int lumpsize[6] = { sizeof(dstatement_t), sizeof(ddef_t),
1024
sizeof(ddef_t), sizeof(dfunction_t), 4, 4 };
1027
if (!deathmatch.value)
1029
int hunk_mark = Hunk_LowMark ();
1031
progs = (dprograms_t *) FS_LoadHunkFile ("spprogs.dat");
1033
if (!file_from_gamedir) {
1034
// spprogs.dat is not from gamedir, this is possibly not what we wanted
1035
// look for qwprogs.dat in gamedir
1037
FS_FOpenFile ("qwprogs.dat", &f);
1040
// it exists, but where's it from?
1041
if (file_from_gamedir) {
1042
// throw away spprogs and load qwprogs instead
1043
Hunk_FreeToLowMark (hunk_mark);
1050
progs = (dprograms_t *)FS_LoadHunkFile ("qwprogs.dat");
1052
Host_Error ("PR_LoadProgs: couldn't load qwprogs.dat");
1054
if (fs_filesize < sizeof(*progs))
1055
Host_Error("progs.dat is corrupt");
1057
Com_DPrintf ("Programs occupy %iK.\n", fs_filesize/1024);
1059
// add prog crc to the serverinfo
1060
sprintf (num, "%i", CRC_Block ((byte *)progs, fs_filesize));
1061
Info_SetValueForStarKey (svs.info, "*progs", num, MAX_SERVERINFO_STRING);
1063
// byte swap the header
1064
for (i = 0; i < sizeof(*progs)/4; i++)
1065
((int *)progs)[i] = LittleLong ( ((int *)progs)[i] );
1067
if (progs->version != PROG_VERSION)
1068
Host_Error ("progs.dat has wrong version number (%i should be %i)", progs->version, PROG_VERSION);
1069
if (progs->crc != PROGHEADER_CRC)
1070
Host_Error ("You must have the qwprogs.dat from QuakeWorld installed");
1072
// check lump offsets and sizes
1073
for (i = 0; i < 6; i ++) {
1074
if (((int *)progs)[i*2 + 2] < sizeof(*progs)
1075
|| ((int *)progs)[i*2 + 2] + ((int *)progs)[i*2 + 3]*lumpsize[i] > fs_filesize)
1076
Host_Error("progs.dat is corrupt");
1079
pr_functions = (dfunction_t *)((byte *)progs + progs->ofs_functions);
1080
pr_strings = (char *)progs + progs->ofs_strings;
1081
pr_globaldefs = (ddef_t *)((byte *)progs + progs->ofs_globaldefs);
1082
pr_fielddefs = (ddef_t *)((byte *)progs + progs->ofs_fielddefs);
1083
pr_statements = (dstatement_t *)((byte *)progs + progs->ofs_statements);
1084
pr_global_struct = (globalvars_t *)((byte *)progs + progs->ofs_globals);
1086
pr_globals = (float *)pr_global_struct;
1090
pr_edict_size = progs->entityfields * 4 + sizeof (edict_t) - sizeof(entvars_t);
1092
// byte swap the lumps
1093
for (i=0 ; i<progs->numstatements ; i++)
1095
pr_statements[i].op = LittleShort(pr_statements[i].op);
1096
pr_statements[i].a = LittleShort(pr_statements[i].a);
1097
pr_statements[i].b = LittleShort(pr_statements[i].b);
1098
pr_statements[i].c = LittleShort(pr_statements[i].c);
1101
for (i=0 ; i<progs->numfunctions; i++)
1103
pr_functions[i].first_statement = LittleLong (pr_functions[i].first_statement);
1104
pr_functions[i].parm_start = LittleLong (pr_functions[i].parm_start);
1105
pr_functions[i].s_name = LittleLong (pr_functions[i].s_name);
1106
pr_functions[i].s_file = LittleLong (pr_functions[i].s_file);
1107
pr_functions[i].numparms = LittleLong (pr_functions[i].numparms);
1108
pr_functions[i].locals = LittleLong (pr_functions[i].locals);
1111
for (i=0 ; i<progs->numglobaldefs ; i++)
1113
pr_globaldefs[i].type = LittleShort (pr_globaldefs[i].type);
1114
pr_globaldefs[i].ofs = LittleShort (pr_globaldefs[i].ofs);
1115
pr_globaldefs[i].s_name = LittleLong (pr_globaldefs[i].s_name);
1118
for (i=0 ; i<progs->numfielddefs ; i++)
1120
pr_fielddefs[i].type = LittleShort (pr_fielddefs[i].type);
1121
if (pr_fielddefs[i].type & DEF_SAVEGLOBAL)
1122
Host_Error ("PR_LoadProgs: pr_fielddefs[i].type & DEF_SAVEGLOBAL");
1123
pr_fielddefs[i].ofs = LittleShort (pr_fielddefs[i].ofs);
1124
pr_fielddefs[i].s_name = LittleLong (pr_fielddefs[i].s_name);
1127
for (i=0 ; i<progs->numglobals ; i++)
1128
((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
1130
// find optional QC-exported functions
1131
SpectatorConnect = ED_FindFunctionOffset ("SpectatorConnect");
1132
SpectatorThink = ED_FindFunctionOffset ("SpectatorThink");
1133
SpectatorDisconnect = ED_FindFunctionOffset ("SpectatorDisconnect");
1134
BotConnect = ED_FindFunctionOffset ("BotConnect");
1135
BotDisconnect = ED_FindFunctionOffset ("BotDisconnect");
1136
BotPreThink = ED_FindFunctionOffset ("BotPreThink");
1137
BotPostThink = ED_FindFunctionOffset ("BotPostThink");
1139
// find optional QC-exported fields
1140
fofs_maxspeed = ED_FindFieldOffset ("maxspeed");
1141
fofs_gravity = ED_FindFieldOffset ("gravity");
1142
fofs_forwardmove = ED_FindFieldOffset ("forwardmove");
1143
fofs_sidemove = ED_FindFieldOffset ("sidemove");
1144
fofs_upmove = ED_FindFieldOffset ("upmove");
1146
fofs_vw_index = ED_FindFieldOffset ("vw_index");
1147
fofs_vw_frame = ED_FindFieldOffset ("vw_frame");
1150
PR_CheckExtensions ();
1151
PR_FindCmdFunctions ();
1162
Cmd_AddCommand ("edict", ED_PrintEdict_f);
1163
Cmd_AddCommand ("edicts", ED_PrintEdicts_f);
1164
Cmd_AddCommand ("edictcount", ED_EdictCount_f);
1165
Cmd_AddCommand ("profile", PR_Profile_f);
1170
edict_t *EDICT_NUM(int n)
1172
if (n < 0 || n >= MAX_EDICTS)
1173
Host_Error ("EDICT_NUM: bad number %i", n);
1174
return (edict_t *)((byte *)sv.edicts+ (n)*pr_edict_size);
1177
int NUM_FOR_EDICT(edict_t *e)
1181
b = (byte *)e - (byte *)sv.edicts;
1182
b = b / pr_edict_size;
1184
if (b < 0 || b >= sv.num_edicts)
1185
Host_Error ("NUM_FOR_EDICT: bad pointer");
added
removed
zq-repo/zquake/source/pr_edict.c
