mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-12-23 02:51:09 +00:00
7c1d9d2b84
I'd forgotten that ED_ConvertToPlist mangled light into light_lev and single component angle values into a vector. This fixes much of the breakage in qflight (but not the light levels)
535 lines
12 KiB
C
535 lines
12 KiB
C
/*
|
|
pr_parse.c
|
|
|
|
map and savegame parsing
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#include "qfalloca.h"
|
|
|
|
#if defined(_WIN32) && defined(HAVE_MALLOC_H)
|
|
#include <malloc.h>
|
|
#endif
|
|
|
|
#include "QF/cbuf.h"
|
|
#include "QF/crc.h"
|
|
#include "QF/cvar.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/hash.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/progs.h"
|
|
#include "QF/qdefs.h"
|
|
#include "QF/qfplist.h"
|
|
#include "QF/qendian.h"
|
|
#include "QF/quakefs.h"
|
|
#include "QF/script.h"
|
|
#include "QF/sys.h"
|
|
#include "QF/zone.h"
|
|
#include "QF/va.h"
|
|
|
|
#include "compat.h"
|
|
|
|
/*
|
|
PR_UglyValueString
|
|
|
|
Returns a string describing *data in a type specific manner
|
|
Easier to parse than PR_ValueString
|
|
*/
|
|
static const char *
|
|
PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val)
|
|
{
|
|
static dstring_t *line = 0;
|
|
ddef_t *def;
|
|
dfunction_t *f;
|
|
|
|
if (!line)
|
|
line = dstring_new ();
|
|
|
|
type &= ~DEF_SAVEGLOBAL;
|
|
|
|
switch (type) {
|
|
case ev_string:
|
|
dsprintf (line, "%s", PR_GetString (pr, val->string_var));
|
|
break;
|
|
case ev_entity:
|
|
dsprintf (line, "%d",
|
|
NUM_FOR_BAD_EDICT (pr, PROG_TO_EDICT (pr, val->entity_var)));
|
|
break;
|
|
case ev_func:
|
|
f = pr->pr_functions + val->func_var;
|
|
dsprintf (line, "%s", PR_GetString (pr, f->s_name));
|
|
break;
|
|
case ev_field:
|
|
def = PR_FieldAtOfs (pr, val->integer_var);
|
|
dsprintf (line, "%s", PR_GetString (pr, def->s_name));
|
|
break;
|
|
case ev_void:
|
|
dstring_copystr (line, "void");
|
|
break;
|
|
case ev_float:
|
|
dsprintf (line, "%.9g", val->float_var);
|
|
break;
|
|
case ev_integer:
|
|
dsprintf (line, "%d", val->integer_var);
|
|
break;
|
|
case ev_vector:
|
|
dsprintf (line, "%.9g %.9g %.9g", VectorExpand (val->vector_var));
|
|
break;
|
|
case ev_quat:
|
|
dsprintf (line, "%.9g %.9g %.9g %.9g", QuatExpand (val->quat_var));
|
|
break;
|
|
default:
|
|
dsprintf (line, "bad type %i", type);
|
|
break;
|
|
}
|
|
|
|
return line->str;
|
|
}
|
|
|
|
VISIBLE plitem_t *
|
|
ED_EntityDict (progs_t *pr, edict_t *ed)
|
|
{
|
|
plitem_t *entity = PL_NewDictionary ();
|
|
pr_uint_t i;
|
|
int j;
|
|
int type;
|
|
const char *name;
|
|
const char *value;
|
|
pr_type_t *v;
|
|
|
|
if (!ed->free) {
|
|
for (i = 0; i < pr->progs->numfielddefs; i++) {
|
|
ddef_t *d = &pr->pr_fielddefs[i];
|
|
|
|
name = PR_GetString (pr, d->s_name);
|
|
if (!name[0])
|
|
continue; // skip unnamed fields
|
|
if (name[strlen (name) - 2] == '_')
|
|
continue; // skip _x, _y, _z vars
|
|
|
|
v = &ed->v[d->ofs];
|
|
|
|
// if the value is still all 0, skip the field
|
|
type = d->type & ~DEF_SAVEGLOBAL;
|
|
for (j = 0; j < pr_type_size[type]; j++)
|
|
if (v[j].integer_var)
|
|
break;
|
|
if (j == pr_type_size[type])
|
|
continue;
|
|
|
|
value = PR_UglyValueString (pr, type, v);
|
|
PL_D_AddObject (entity, name, PL_NewString (value));
|
|
}
|
|
}
|
|
return entity;
|
|
}
|
|
|
|
/*
|
|
ARCHIVING GLOBALS
|
|
|
|
FIXME: need to tag constants, doesn't really work
|
|
*/
|
|
|
|
VISIBLE plitem_t *
|
|
ED_GlobalsDict (progs_t *pr)
|
|
{
|
|
plitem_t *globals = PL_NewDictionary ();
|
|
pr_uint_t i;
|
|
const char *name;
|
|
const char *value;
|
|
ddef_t *def;
|
|
int type;
|
|
|
|
for (i = 0; i < pr->progs->numglobaldefs; i++) {
|
|
def = &pr->pr_globaldefs[i];
|
|
type = def->type;
|
|
if (!(def->type & DEF_SAVEGLOBAL))
|
|
continue;
|
|
type &= ~DEF_SAVEGLOBAL;
|
|
|
|
if (type != ev_string && type != ev_float && type != ev_entity)
|
|
continue;
|
|
|
|
name = PR_GetString (pr, def->s_name);
|
|
value = PR_UglyValueString (pr, type, &pr->pr_globals[def->ofs]);
|
|
PL_D_AddObject (globals, name, PL_NewString (value));
|
|
}
|
|
return globals;
|
|
}
|
|
|
|
|
|
static int
|
|
ED_NewString (progs_t *pr, const char *string)
|
|
{
|
|
char *new, *new_p;
|
|
int i, l;
|
|
|
|
l = strlen (string) + 1;
|
|
new = alloca (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 PR_SetString (pr, new);
|
|
}
|
|
|
|
|
|
/*
|
|
ED_ParseEval
|
|
|
|
Can parse either fields or globals
|
|
returns false if error
|
|
*/
|
|
VISIBLE qboolean
|
|
ED_ParseEpair (progs_t *pr, pr_type_t *base, ddef_t *key, const char *s)
|
|
{
|
|
int i;
|
|
char *string;
|
|
ddef_t *def;
|
|
char *v, *w;
|
|
pr_type_t *d;
|
|
dfunction_t *func;
|
|
|
|
d = &base[key->ofs];
|
|
|
|
switch (key->type & ~DEF_SAVEGLOBAL) {
|
|
case ev_string:
|
|
d->string_var = ED_NewString (pr, s);
|
|
break;
|
|
|
|
case ev_float:
|
|
d->float_var = atof (s);
|
|
break;
|
|
|
|
case ev_vector:
|
|
string = strdup (s);
|
|
v = string;
|
|
w = string;
|
|
for (i = 0; i < 3; i++) {
|
|
while (*v && *v != ' ')
|
|
v++;
|
|
*v = 0;
|
|
d->vector_var[i] = atof (w);
|
|
w = v = v + 1;
|
|
}
|
|
free (string);
|
|
break;
|
|
|
|
case ev_entity:
|
|
d->entity_var = EDICT_TO_PROG (pr, EDICT_NUM (pr, atoi (s)));
|
|
break;
|
|
|
|
case ev_field:
|
|
def = PR_FindField (pr, s);
|
|
if (!def) {
|
|
Sys_Printf ("Can't find field %s\n", s);
|
|
return false;
|
|
}
|
|
d->integer_var = G_INT (pr, def->ofs);
|
|
break;
|
|
|
|
case ev_func:
|
|
func = PR_FindFunction (pr, s);
|
|
if (!func) {
|
|
Sys_Printf ("Can't find function %s\n", s);
|
|
return false;
|
|
}
|
|
d->func_var = func - pr->pr_functions;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
ED_ParseOld
|
|
|
|
The entities are directly placed in the array, rather than allocated with
|
|
ED_Alloc, because otherwise an error loading the map would have entity
|
|
number references out of order.
|
|
|
|
Creates a server's entity / program execution context by
|
|
parsing textual entity definitions out of an ent file.
|
|
|
|
Used for both fresh maps and savegame loads. A fresh map would also need
|
|
to call ED_CallSpawnFunctions () to let the objects initialize themselves.
|
|
*/
|
|
|
|
VISIBLE plitem_t *
|
|
ED_ConvertToPlist (script_t *script, int nohack)
|
|
{
|
|
plitem_t *plist = PL_NewArray ();
|
|
plitem_t *ent;
|
|
plitem_t *key;
|
|
plitem_t *value;
|
|
const char *token;
|
|
int anglehack;
|
|
|
|
while (Script_GetToken (script, 1)) {
|
|
token = script->token->str;
|
|
if (!strequal (token, "{"))
|
|
Sys_Error ("ED_ConvertToPlist: EOF without closing brace");
|
|
ent = PL_NewDictionary ();
|
|
while (1) {
|
|
if (!Script_GetToken (script, 1))
|
|
Sys_Error ("ED_ConvertToPlist: EOF without closing brace");
|
|
token = script->token->str;
|
|
if (strequal (token, "}"))
|
|
break;
|
|
anglehack = 0;
|
|
if (!nohack && strequal (token, "angle")) {
|
|
key = PL_NewString ("angles");
|
|
anglehack = 1;
|
|
} else if (!nohack && strequal (token, "light")) {
|
|
key = PL_NewString ("light_lev");
|
|
} else {
|
|
key = PL_NewString (token);
|
|
}
|
|
if (!Script_TokenAvailable (script, 0))
|
|
Sys_Error ("ED_ConvertToPlist: EOL without value");
|
|
Script_GetToken (script, 0);
|
|
token = script->token->str;
|
|
if (strequal (token, "}"))
|
|
Sys_Error ("ED_ConvertToPlist: closing brace without data");
|
|
if (anglehack)
|
|
value = PL_NewString (va ("0 %s 0", token));
|
|
else
|
|
value = PL_NewString (token);
|
|
PL_D_AddObject (ent, PL_String (key), value);
|
|
PL_Free (key);
|
|
}
|
|
PL_A_AddObject (plist, ent);
|
|
}
|
|
return plist;
|
|
}
|
|
|
|
|
|
VISIBLE void
|
|
ED_InitGlobals (progs_t *pr, plitem_t *globals)
|
|
{
|
|
ddef_t vector_def;
|
|
ddef_t *global;
|
|
plitem_t *keys;
|
|
int count;
|
|
const char *global_name;
|
|
const char *value;
|
|
|
|
keys = PL_D_AllKeys (globals);
|
|
count = PL_A_NumObjects (keys);
|
|
while (count--) {
|
|
global_name = PL_String (PL_ObjectAtIndex (keys, count));
|
|
value = PL_String (PL_ObjectForKey (globals, global_name));
|
|
global = PR_FindGlobal (pr, global_name);
|
|
//FIXME should this be here?
|
|
//This is a hardcoded fix for a design mistake in the original qcc
|
|
//(saving global vector components rather than the whole vector).
|
|
if (!global) {
|
|
int len = strlen (global_name);
|
|
const char *tag = global_name + len - 2;
|
|
if (len > 2 && tag[0] == '_' && strchr ("xyz", tag[1])) {
|
|
char *vector_name = strdup (global_name);
|
|
vector_name[len - 2] = 0;
|
|
global = PR_FindGlobal (pr, vector_name);
|
|
if (global) {
|
|
if ((global->type & ~DEF_SAVEGLOBAL) == ev_vector) {
|
|
vector_def = *global;
|
|
vector_def.ofs += tag[1] - 'x';
|
|
vector_def.type = ev_float;
|
|
global = &vector_def;
|
|
} else {
|
|
global = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!global) {
|
|
Sys_Printf ("'%s' is not a global\n", global_name);
|
|
continue;
|
|
}
|
|
if (!ED_ParseEpair (pr, pr->pr_globals, global, value))
|
|
PR_Error (pr, "ED_InitGlobals: parse error");
|
|
}
|
|
PL_Free (keys);
|
|
}
|
|
|
|
VISIBLE void
|
|
ED_InitEntity (progs_t *pr, plitem_t *entity, edict_t *ent)
|
|
{
|
|
ddef_t *field;
|
|
plitem_t *keys;
|
|
const char *field_name;
|
|
const char *value;
|
|
int count;
|
|
int init = 0;
|
|
|
|
keys = PL_D_AllKeys (entity);
|
|
count = PL_A_NumObjects (keys);
|
|
while (count--) {
|
|
field_name = PL_String (PL_ObjectAtIndex (keys, count));
|
|
value = PL_String (PL_ObjectForKey (entity, field_name));
|
|
field = PR_FindField (pr, field_name);
|
|
if (!field) {
|
|
if (!pr->parse_field
|
|
|| !pr->parse_field (pr, field_name, value)) {
|
|
Sys_Printf ("'%s' is not a field\n", field_name);
|
|
continue;
|
|
}
|
|
} else {
|
|
if (!ED_ParseEpair (pr, ent->v, field, value))
|
|
PR_Error (pr, "ED_InitEntity: parse error");
|
|
}
|
|
init = 1;
|
|
}
|
|
PL_Free (keys);
|
|
if (!init)
|
|
ent->free = 1;
|
|
}
|
|
|
|
static void
|
|
ED_SpawnEntities (progs_t *pr, plitem_t *entity_list)
|
|
{
|
|
edict_t *ent;
|
|
int inhibit = 0;
|
|
plitem_t *entity;
|
|
plitem_t *item;
|
|
int i;
|
|
int count;
|
|
const char *classname;
|
|
dfunction_t *func;
|
|
pr_int_t max_edicts = pr->pr_edictareasize / pr->pr_edict_size;
|
|
|
|
max_edicts -= *pr->num_edicts;
|
|
count = PL_A_NumObjects (entity_list);
|
|
for (i = 0; i < count; i++) {
|
|
entity = PL_ObjectAtIndex (entity_list, i);
|
|
|
|
item = PL_ObjectForKey (entity, "classname");
|
|
if (!item)
|
|
PR_Error (pr, "no classname for entity %d", i);
|
|
classname = PL_String (item);
|
|
if (strequal (classname, "worldspawn"))
|
|
ent = EDICT_NUM (pr, 0);
|
|
else
|
|
ent = ED_Alloc (pr);
|
|
|
|
// don't allow the last edict to be used, as otherwise we can't detect
|
|
// too many edicts
|
|
if (NUM_FOR_EDICT (pr, ent) >= pr->max_edicts - 1)
|
|
PR_Error (pr, "too many entities: %d > %d", count, max_edicts);
|
|
|
|
ED_InitEntity (pr, entity, ent);
|
|
|
|
// remove things from different skill levels or deathmatch
|
|
if (pr->prune_edict && pr->prune_edict (pr, ent)) {
|
|
ED_Free (pr, ent);
|
|
inhibit++;
|
|
continue;
|
|
}
|
|
|
|
//XXX should the field be checked instead of going direct?
|
|
func = PR_FindFunction (pr, classname);
|
|
if (!func) {
|
|
Sys_Printf ("No spawn function for :\n");
|
|
ED_Print (pr, ent);
|
|
ED_Free (pr, ent);
|
|
continue;
|
|
}
|
|
|
|
*pr->globals.self = EDICT_TO_PROG (pr, ent);
|
|
PR_ExecuteProgram (pr, func - pr->pr_functions);
|
|
if (pr->flush)
|
|
pr->flush ();
|
|
}
|
|
}
|
|
|
|
VISIBLE plitem_t *
|
|
ED_Parse (progs_t *pr, const char *data)
|
|
{
|
|
script_t *script;
|
|
plitem_t *entity_list = 0;
|
|
|
|
script = Script_New ();
|
|
Script_Start (script, "ent data", data);
|
|
|
|
if (Script_GetToken (script, 1)) {
|
|
if (strequal (script->token->str, "(")) {
|
|
// new style (plist) entity data
|
|
entity_list = PL_GetPropertyList (data);
|
|
} else {
|
|
// oldstyle entity data
|
|
Script_UngetToken (script);
|
|
entity_list = ED_ConvertToPlist (script, 0);
|
|
}
|
|
}
|
|
Script_Delete (script);
|
|
return entity_list;
|
|
}
|
|
|
|
VISIBLE void
|
|
ED_LoadFromFile (progs_t *pr, const char *data)
|
|
{
|
|
plitem_t *entity_list;
|
|
|
|
if (pr->edict_parse) {
|
|
PR_PushFrame (pr);
|
|
PR_RESET_PARAMS (pr);
|
|
P_INT (pr, 0) = PR_SetTempString (pr, data);
|
|
PR_ExecuteProgram (pr, pr->edict_parse);
|
|
PR_PopFrame (pr);
|
|
return;
|
|
}
|
|
entity_list = ED_Parse (pr, data);
|
|
if (entity_list) {
|
|
ED_SpawnEntities (pr, entity_list);
|
|
PL_Free (entity_list);
|
|
}
|
|
}
|
|
|
|
VISIBLE void
|
|
ED_EntityParseFunction (progs_t *pr)
|
|
{
|
|
pr->edict_parse = P_FUNCTION (pr, 0);
|
|
}
|