rpgxef/code/game/g_spawn.cpp

// Copyright (C) 1999-2000 Id Software, Inc.
//

#include "g_local.h"
#include "g_spawn.h"
#include "g_items.h"
#include "g_lua.h"
#include "g_syscalls.h"

field_t fields[] = {
	{ "classname", FOFS(classname), F_LSTRING },
	{ "origin", FOFS(s.origin), F_VECTOR },
	{ "model", FOFS(model), F_LSTRING },
	{ "model2", FOFS(model2), F_LSTRING },
	{ "spawnflags", FOFS(spawnflags), F_INT },
	{ "speed", FOFS(speed), F_FLOAT },
	{ "target", FOFS(target), F_LSTRING },
	{ "paintarget", FOFS(paintarget), F_LSTRING },
	{ "targetname", FOFS(targetname), F_LSTRING },
	{ "message", FOFS(message), F_LSTRING },
	{ "team", FOFS(team), F_LSTRING },
	{ "splashDamage", FOFS(splashDamage), F_INT },
	{ "splashRadius", FOFS(splashRadius), F_INT },
	{ "wait", FOFS(wait), F_FLOAT },
	{ "random", FOFS(random), F_FLOAT },
	{ "count", FOFS(count), F_INT },
	{ "material", FOFS(s.powerups), F_INT },
	{ "health", FOFS(health), F_INT },
	{ "light", 0, F_IGNORE },
	{ "dmg", FOFS(damage), F_INT },
	{ "angles", FOFS(s.angles), F_VECTOR },
	{ "angle", FOFS(s.angles), F_ANGLEHACK },
	{ "pos2", FOFS(pos2), F_VECTOR },
	{ "apos1", FOFS(apos1), F_VECTOR },
	{ "apos2", FOFS(apos2), F_VECTOR },
	{ "swapname", FOFS(swapname), F_LSTRING },		//RPG-X Modification | Phenix | 13/06/2004
	{ "truename", FOFS(truename), F_LSTRING },
	{ "falsename", FOFS(falsename), F_LSTRING },
	{ "truetarget", FOFS(truetarget), F_LSTRING },
	{ "falsetarget", FOFS(falsetarget), F_LSTRING },
	{ "booleanstate", FOFS(booleanstate), F_INT },
	{ "distance", FOFS(distance), F_FLOAT },	// VALKYRIE: for rotating doors
	{ "targetname2", FOFS(targetname2), F_LSTRING },
	{ "bluename", FOFS(bluename), F_LSTRING },
	{ "greensnd", FOFS(greensound), F_LSTRING },
	{ "yellowsnd", FOFS(yellowsound), F_LSTRING },
	{ "redsnd", FOFS(redsound), F_LSTRING },
	{ "bluesnd", FOFS(bluesound), F_LSTRING },
	{ "targetShaderName", FOFS(targetShaderName), F_LSTRING },
	{ "targetShaderNewName", FOFS(targetShaderNewName), F_LSTRING },
#ifdef G_LUA
	{ "luaThink", FOFS(luaThink), F_LSTRING },
	{ "luaTouch", FOFS(luaTouch), F_LSTRING },
	{ "luaUse", FOFS(luaUse), F_LSTRING },
	{ "luaHurt", FOFS(luaHurt), F_LSTRING },
	{ "luaDie", FOFS(luaDie), F_LSTRING },
	{ "luaFree", FOFS(luaFree), F_LSTRING },
	{ "luaTrigger", FOFS(luaTrigger), F_LSTRING },
	{ "luaReached", FOFS(luaReached), F_LSTRING },
	{ "luaReachedAngular", FOFS(luaReachedAngular), F_LSTRING },
	{ "luaSpawn", FOFS(luaSpawn), F_LSTRING },

	{ "luaParm1", FOFS(luaParm1), F_LSTRING },
	{ "luaParm2", FOFS(luaParm2), F_LSTRING },
	{ "luaParm3", FOFS(luaParm3), F_LSTRING },
	{ "luaParm4", FOFS(luaParm4), F_LSTRING },
	{ "luaEntity", FOFS(luaEntity), F_INT },
#endif
	{ "startRGBA", FOFS(startRGBA), F_VECTOR4 },
	{ "finalRGBA", FOFS(finalRGBA), F_VECTOR4 },
	{ NULL }
};

qboolean	G_SpawnString(const char *key, const char *defaultString, char **out) {
	int		i;

	if (!level.spawning) {
		*out = (char *)defaultString;
	}

	for (i = 0; i < level.numSpawnVars; i++) {
		if (!strcmp(key, level.spawnVars[i][0])) {
			*out = level.spawnVars[i][1];
			return qtrue;
		}
	}

	*out = (char *)defaultString;
	return qfalse;
}

qboolean G_SpawnFloat(const char *key, const char *defaultString, float *out) {
	char		*s;
	qboolean	present;

	present = G_SpawnString(key, defaultString, &s);
	*out = atof(s);
	return present;
}

qboolean	G_SpawnInt(const char *key, const char *defaultString, int *out) {
	char		*s;
	qboolean	present;

	present = G_SpawnString(key, defaultString, &s);
	*out = atoi(s);
	return present;
}

qboolean	G_SpawnVector(const char *key, const char *defaultString, float *out) {
	char		*s;
	qboolean	present;

	present = G_SpawnString(key, defaultString, &s);
	sscanf(s, "%f %f %f", &out[0], &out[1], &out[2]);
	return present;
}

qboolean	G_SpawnVector4(const char *key, const char *defaultString, float *out) {
	char		*s;
	qboolean	present;

	present = G_SpawnString(key, defaultString, &s);
	sscanf(s, "%f %f %f %f", &out[0], &out[1], &out[2], &out[3]);
	return present;
}

typedef struct {
	char	*name;
	void(*spawn)(gentity_t *ent);
} spawn_t;


spawn_t	spawns[] = {
	// info entities don't do anything at all, but provide positional
	// information for things controlled by other processes
	{ "info_player_start", SP_info_player_deathmatch },

	{ "NPC_BioHulk", SP_info_player_deathmatch },
	{ "NPC_starfleet", SP_info_player_deathmatch },
	{ "NPC_starfleet_random", SP_info_player_deathmatch },
	{ "NPC_Tuvok", SP_info_player_deathmatch },
	{ "NPC_Kim", SP_info_player_deathmatch },
	{ "NPC_Doctor", SP_info_player_deathmatch },
	{ "NPC_Paris", SP_info_player_deathmatch },
	{ "NPC_Torres", SP_info_player_deathmatch },
	{ "NPC_Janeway", SP_info_player_deathmatch },
	{ "NPC_Seven", SP_info_player_deathmatch },
	{ "NPC_Chakotay", SP_info_player_deathmatch },
	{ "NPC_Neelix", SP_info_player_deathmatch },
	{ "NPC_Vorik", SP_info_player_deathmatch },
	{ "NPC_Foster", SP_info_player_deathmatch },
	{ "NPC_Munro", SP_info_player_deathmatch },
	{ "NPC_MunroScav", SP_info_player_deathmatch },
	{ "NPC_Telsia", SP_info_player_deathmatch },
	{ "NPC_Biessman", SP_info_player_deathmatch },
	{ "NPC_Chang", SP_info_player_deathmatch },
	{ "NPC_Chell", SP_info_player_deathmatch },
	{ "NPC_Jurot", SP_info_player_deathmatch },
	{ "NPC_borg", SP_info_player_deathmatch },
	{ "NPC_klingon", SP_info_player_deathmatch },
	{ "NPC_Malon", SP_info_player_deathmatch },
	{ "NPC_Hirogen", SP_info_player_deathmatch },
	{ "NPC_Hirogen_Alpha", SP_info_player_deathmatch },
	{ "NPC_Imperial", SP_info_player_deathmatch },
	{ "NPC_Imperial_Blue", SP_info_player_deathmatch },
	{ "NPC_Imperial_Gold", SP_info_player_deathmatch },
	{ "NPC_Imperial_Raider", SP_info_player_deathmatch },
	{ "NPC_Stasis", SP_info_player_deathmatch },
	{ "NPC_Species8472", SP_info_player_deathmatch },
	{ "NPC_Reaver", SP_info_player_deathmatch },
	{ "NPC_ReaverGuard", SP_info_player_deathmatch },
	{ "NPC_Avatar", SP_info_player_deathmatch },
	{ "NPC_Vohrsoth", SP_info_player_deathmatch },
	{ "NPC_Desperado", SP_info_player_deathmatch },
	{ "NPC_Paladin", SP_info_player_deathmatch },
	{ "NPC_ChaoticaGuard", SP_info_player_deathmatch },
	{ "NPC_Chaotica", SP_info_player_deathmatch },
	{ "NPC_CaptainProton", SP_info_player_deathmatch },
	{ "NPC_SatansRobot", SP_info_player_deathmatch },
	{ "NPC_Buster", SP_info_player_deathmatch },
	{ "NPC_Goodheart", SP_info_player_deathmatch },

	{ "info_player_deathmatch", SP_info_player_deathmatch },
	{ "info_player_intermission", SP_info_player_intermission },
	{ "info_null", SP_info_null },
	{ "info_notnull", SP_info_notnull },
	{ "info_camp", SP_info_camp },

	{ "func_plat", SP_func_plat },
	{ "func_button", SP_func_button },
	{ "func_door", SP_func_door },
	{ "func_forcefield", SP_func_forcefield },
	{ "func_static", SP_func_static },
	{ "func_rotating", SP_func_rotating },
	{ "func_bobbing", SP_func_bobbing },
	{ "func_pendulum", SP_func_pendulum },
	{ "func_train", SP_func_train },
	{ "func_group", SP_info_null },
	{ "func_timer", SP_func_timer },			// rename trigger_timer?
	{ "func_usable", SP_func_usable },
	{ "func_breakable", SP_func_breakable },
	{ "func_door_rotating", SP_func_door_rotating },
	{ "func_brushmodel", SP_func_brushmodel }, // Hijack me haha
	{ "func_lightchange", SP_func_lightchange },
	{ "func_targetmover", SP_func_targetmover },
	{ "func_stasis_door", SP_func_stasis_door },

	// Triggers are brush objects that cause an effect when contacted
	// by a living player, usually involving firing targets.
	// While almost everything could be done with
	// a single trigger class and different targets, triggered effects
	// could not be client side predicted (push and teleport).
	{ "trigger_always", SP_trigger_always },
	{ "trigger_multiple", SP_trigger_multiple },
	{ "trigger_push", SP_trigger_push },
	{ "trigger_teleport", SP_trigger_teleport },
	{ "trigger_hurt", SP_trigger_hurt },
	{ "trigger_transporter", SP_trigger_transporter },
	{ "trigger_radiation", SP_trigger_radiation },

	// targets perform no action by themselves, but must be triggered
	// by another entity
	{ "target_give", SP_target_give },
	{ "target_remove_powerups", SP_target_remove_powerups },
	{ "target_delay", SP_target_delay },
	{ "target_speaker", SP_target_speaker },
	{ "target_print", SP_target_print },
	{ "target_laser", SP_target_laser },
	{ "target_teleporter", SP_target_teleporter },
	{ "target_relay", SP_target_relay },
	{ "target_kill", SP_target_kill },
	{ "target_position", SP_info_notnull },
	{ "target_location", SP_target_location },
	{ "target_push", SP_target_push },
	{ "target_counter", SP_target_counter },
	{ "target_objective", SP_target_objective },
	{ "target_boolean", SP_target_boolean }, // RPG-X | Phenix | 13/06/2004
	{ "target_gravity", SP_target_gravity },	//RPG-X Phenix/J2J 03/08/04
	{ "target_shake", SP_target_shake },	//RPG-X Phenix/J2J 16/11/04
	{ "target_evosuit", SP_target_evosuit },	//RPG-X Phenix/J2J 16/11/04 - RedTechie: Fixed a typo you have evo suit pointing to shake function
	{ "target_turbolift", SP_target_turbolift },
	{ "target_doorlock", SP_target_doorLock }, //RPG-X | GSIO01 | 08/05/2009
	{ "target_repair", SP_target_repair },	 //RPG-X | GSIO01 | 09/05/2009
	{ "target_alert", SP_target_alert },	//RPG-X | GSIO01
	{ "target_warp", SP_target_warp },	//RPG-X | GSIO01 | 19/05/2009
	{ "target_deactivate", SP_target_deactivate },
	{ "target_serverchange", SP_target_serverchange },
	{ "target_levelchange", SP_target_levelchange },
	{ "target_shaderremap", SP_target_shaderremap },
	{ "target_selfdestruct", SP_target_selfdestruct },
	{ "target_safezone", SP_target_zone },
	{ "target_zone", SP_target_zone },
	{ "target_shiphealth", SP_target_shiphealth },
	{ "target_sequence", SP_target_sequence },

	{ "light", SP_light },
	{ "path_corner", SP_path_corner },

	{ "misc_teleporter_dest", SP_info_notnull },
	{ "misc_model", SP_misc_model },
	{ "misc_model_breakable", SP_misc_model_breakable },
	{ "misc_portal_surface", SP_misc_portal_surface },
	{ "misc_portal_camera", SP_misc_portal_camera },
	{ "misc_turret", SP_misc_turret },
	{ "misc_laser", SP_laser_arm },
	{ "misc_ammo_station", SP_misc_ammo_station },

	{ "shooter_rocket", SP_shooter_rocket },
	{ "shooter_grenade", SP_shooter_grenade },
	{ "shooter_plasma", SP_shooter_plasma },
	{ "shooter_torpedo", SP_shooter_torpedo },

	{ "team_CTF_redplayer", SP_info_player_deathmatch },
	{ "team_CTF_blueplayer", SP_info_player_deathmatch },

	{ "team_CTF_redspawn", SP_info_player_deathmatch },
	{ "team_CTF_bluespawn", SP_info_player_deathmatch },

	// extra Trek stuff
	{ "fx_spark", SP_fx_spark },
	{ "fx_steam", SP_fx_steam },
	{ "fx_bolt", SP_fx_bolt },
	{ "fx_transporter", SP_fx_transporter },
	{ "fx_drip", SP_fx_drip },
	{ "fx_fountain", SP_fx_fountain },
	{ "fx_surface_explosion", SP_fx_surface_explosion },
	{ "fx_blow_chunks", SP_fx_blow_chunks },
	{ "fx_smoke", SP_fx_smoke },
	{ "fx_electrical_explosion", SP_fx_electrical_explosion },
	{ "fx_phaser", SP_fx_phaser },
	{ "fx_torpedo", SP_fx_torpedo },
	{ "fx_particle_fire", SP_fx_particleFire },
	{ "fx_fire", SP_fx_fire },

	// Additional ports from SP by Harry Young
	{ "fx_cooking_steam", SP_fx_cooking_steam },
	{ "fx_elecfire", SP_fx_electricfire },
	//{"fx_forge_bolt",					SP_fx_forge_bolt},
	//{"fx_plasma",					SP_fx_plasma},
	//{"fx_energy_stream",			SP_fx_stream},
	//{"fx_transporter_stream",		SP_fx_transporter_stream},
	//{"fx_explosion_trail",			SP_fx_explosion_trail},
	//{"fx_borg_energy_beam",			SP_fx_borg_energy_beam},
	{ "fx_shimmery_thing", SP_fx_shimmery_thing },
	{ "fx_borg_bolt", SP_fx_borg_bolt },

	{ "func_mover", SP_func_mover },
	{ "path_point", SP_path_point },

	// ui entities
	{ "ui_transporter", SP_ui_transporter },
	{ "ui_msd", SP_ui_msd },
	{ "ui_holodeck", SP_ui_holodeck },

	{ "ref_tag", SP_info_notnull },

	// cinematic entities
	{ "cinematic_camera", SP_cinematic_camera },

	{ 0, 0 }
};

/*
===============
G_CallSpawn

Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn(gentity_t *ent) {
	spawn_t	*s;
	gitem_t	*item;

	if (ent->classname == NULL) {
		G_Printf("G_CallSpawn: NULL classname\n");
		return qfalse;
	}

	// check item spawn functions
	for (item = bg_itemlist + 1; item->classname; item++) {
		if (!strcmp(item->classname, ent->classname)) {	// found it
			if (item->giType == IT_TEAM && g_gametype.integer != GT_CTF) {
				return qfalse;
			}
			G_SpawnItem(ent, item);

#ifdef G_LUA
			if (ent->luaSpawn) {
				LuaHook_G_EntitySpawn(ent->luaSpawn, ent->s.number);
			}
#endif

			return qtrue;
		}
	}

	// check normal spawn functions
	for (s = spawns; s->name; s++) {
		if (!strcmp(s->name, ent->classname)) {
			// found it
			s->spawn(ent);

			return qtrue;
		}
	}

	if (Q_stricmp("item_botroam", ent->classname) != 0) {//suppress error message about botroams as those are actually valid
		DEVELOPER(G_Printf(S_COLOR_RED "%s doesn't have a spawn function\n", ent->classname););
	}

#ifdef G_LUA
	if (ent->luaSpawn) {
		LuaHook_G_EntitySpawn(ent->luaSpawn, ent->s.number);
	}
#endif

	return qfalse;
}

/*
=============
G_NewString

Builds a copy of the string, translating \n to real linefeeds
so message texts can be multi-line
=============
*/
char *G_NewString(const char *string) {
	char	*newb, *new_p;
	int		i, l;

	if (string == NULL) {
		return NULL;
	}

	l = strlen(string) + 1;

	newb = (char *)G_Alloc(l);

	if (newb == NULL) {
		return NULL;
	}

	new_p = newb;

	// turn \n into a real linefeed
	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 newb;
}




/*
===============
G_ParseField

Takes a key/value pair and sets the binary values
in a gentity
===============
*/
qboolean G_ParseField(const char *key, const char *value, gentity_t *ent) {
	field_t	*f;
	byte	*b;
	float	v;
	vec3_t	vec;
	vec4_t  vec4;

	for (f = fields; f->name; f++) {
		if (!Q_stricmp(f->name, key)) {
			// found it
			b = (byte *)ent;

			switch (f->type) {
				case F_LSTRING:
					*(char **)(b + f->ofs) = G_NewString(value);
					break;
				case F_VECTOR:
					sscanf(value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
					((float *)(b + f->ofs))[0] = vec[0];
					((float *)(b + f->ofs))[1] = vec[1];
					((float *)(b + f->ofs))[2] = vec[2];
					break;
				case F_VECTOR4:
					sscanf(value, "%f %f %f %f", &vec4[0], &vec[1], &vec[2], &vec[3]);
					((float *)(b + f->ofs))[0] = vec4[0];
					((float *)(b + f->ofs))[0] = vec4[1];
					((float *)(b + f->ofs))[0] = vec4[2];
					((float *)(b + f->ofs))[0] = vec4[3];
					break;
				case F_INT:
					*(int *)(b + f->ofs) = atoi(value);
					break;
				case F_FLOAT:
					*(float *)(b + f->ofs) = atof(value);
					break;
				case F_ANGLEHACK:
					v = atof(value);
					((float *)(b + f->ofs))[0] = 0;
					((float *)(b + f->ofs))[1] = v;
					((float *)(b + f->ofs))[2] = 0;
					break;
				default:
				case F_IGNORE:
					return qfalse;
					break;
			}
			return qtrue;
		}
	}
	return qfalse;
}




/*
===================
G_SpawnGEntityFromSpawnVars

Spawn an entity and fill in all of the level fields from
level.spawnVars[], then call the class specfic spawn function
===================
*/
void G_SpawnGEntityFromSpawnVars(void) {
	int			i;
	gentity_t	*ent;
	char		*s, *value, *gametypeName;
	static char *gametypeNames[] = { "ffa", "tournament", "single", "team", "ctf" };

	// get the next free entity
	ent = G_Spawn();

	for (i = 0; i < level.numSpawnVars; i++) {
		G_ParseField(level.spawnVars[i][0], level.spawnVars[i][1], ent);
	}

	// check for "notteam" / "notfree" flags
	if (g_gametype.integer == GT_SINGLE_PLAYER) {
		G_SpawnInt("notsingle", "0", &i);
		if (i) {
			G_FreeEntity(ent);
			return;
		}
	}
	if (g_gametype.integer >= GT_TEAM) {
		G_SpawnInt("notteam", "0", &i);
		if (i) {
			G_FreeEntity(ent);
			return;
		}
	} else {
		G_SpawnInt("notfree", "0", &i);
		if (i) {
			G_FreeEntity(ent);
			return;
		}
	}

	if (G_SpawnString("gametype", "", &value)) {
		if (g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE) {
			gametypeName = gametypeNames[g_gametype.integer];
			s = strstr(value, gametypeName);
			if (!s) {
				G_FreeEntity(ent);
				return;
			}
		}
	}

	// move editor origin to pos
	VectorCopy(ent->s.origin, ent->s.pos.trBase);
	VectorCopy(ent->s.origin, ent->r.currentOrigin);

	// if we didn't get a classname, don't bother spawning anything
	if (!G_CallSpawn(ent)) {
		G_FreeEntity(ent);
	}
}



/*
====================
G_AddSpawnVarToken
====================
*/
char *G_AddSpawnVarToken(const char *string) {
	int		l;
	char	*dest;

	l = strlen(string);
	if (level.numSpawnVarChars + l + 1 > MAX_SPAWN_VARS_CHARS) {
		G_Error("G_AddSpawnVarToken: MAX_SPAWN_VARS");
	}

	dest = level.spawnVarChars + level.numSpawnVarChars;
	memcpy(dest, string, l + 1);

	level.numSpawnVarChars += l + 1;

	return dest;
}

/*
====================
G_ParseSpawnVars

Parses a brace bounded set of key / value pairs out of the
level's entity strings into level.spawnVars[]

This does not actually spawn an entity.
====================
*/
qboolean G_ParseSpawnVars(void) {
	char		keyname[MAX_TOKEN_CHARS];
	char		com_token[MAX_TOKEN_CHARS];

	level.numSpawnVars = 0;
	level.numSpawnVarChars = 0;

	// parse the opening brace
	if (!trap_GetEntityToken(com_token, sizeof(com_token))) {
		// end of spawn string
		return qfalse;
	}
	if (com_token[0] != '{') {
		G_Error("G_ParseSpawnVars: found %s when expecting {", com_token);
	}

	// go through all the key / value pairs
	while (1) {
		// parse key
		if (!trap_GetEntityToken(keyname, sizeof(keyname))) {
			Com_Printf(S_COLOR_RED "G_ParseSpawnVars: Keyname - %s\n", keyname);
			G_Error("G_ParseSpawnVars: EOF without closing brace");
		}

		if (keyname[0] == '}') {
			break;
		}

		// parse value	
		if (!trap_GetEntityToken(com_token, sizeof(com_token))) {
			Com_Printf(S_COLOR_RED "G_ParseSpawnVars: Token - %s\n", com_token);
			G_Error("G_ParseSpawnVars: EOF without closing brace");
		}

		if (com_token[0] == '}') {
			G_Error("G_ParseSpawnVars: closing brace without data");
		}
		if (level.numSpawnVars == MAX_SPAWN_VARS) {
			G_Error("G_ParseSpawnVars: MAX_SPAWN_VARS");
		}
		level.spawnVars[level.numSpawnVars][0] = G_AddSpawnVarToken(keyname);
		level.spawnVars[level.numSpawnVars][1] = G_AddSpawnVarToken(com_token);
		level.numSpawnVars++;
	}

	return qtrue;
}



/*QUAKED worldspawn (0 0 0) ?
-----DESCRIPTION-----
Every map should have exactly one worldspawn.
It holds some general information on the map.

-----SPAWNFLAGS-----
none

-----KEYS-----
"music" - path to WAV or MP3 files (e.g. "music\intro.mp3 music\loopfile.mp3")
"gravity" - 800 is default gravity
"message" - Text to print during connection process

Keys irrelevant for RPG-X
"fraglimit" - overrides server's limit
"capturelimit" - overrides server's capturelimit (use with team AddScores)
"timelimit" - overrides server's timelimit
"timelimitWinningTeam" - "red" or "blue" - this team will win when the timelimit runs out

q3map2:
"_blocksize" block size for unconditional BSP subdivisions
"_celshader" use the specified cel shader for the world
"_lightmapscale" set the lightmapscale for the world
"_ignoreleaks" when set, no leak test is performed
"_foghull" must be set to a sky shader when _fog is used
"_fog" if set, the whole map is fogged using the given shader name
"gridsize" resolution of the light grid
"_ambient" amount of ambient light
"_minvertexlight" amount of minimum vertex light
"_mingridlight" amount of minimum grid light
"_minlight" amount of minimum light
"_keepLights" if set, light entities are not stripped from the BSP file when compiling
"_style42rgbgen" |rgbGen|-like shader definition string for light style 42 (works the same way for all style numbers)
"_style42alphagen" |alphaGen|-like shader definition string for light style 42 (works the same way for all style numbers)
*/
void SP_worldspawn(void) {
	char	*s;

	G_SpawnString("classname", "", &s);
	if (Q_stricmp(s, "worldspawn")) {
		G_Error("SP_worldspawn: The first entity isn't 'worldspawn'");
	}

	// make some data visible to connecting client
	trap_SetConfigstring(CS_GAME_VERSION, GAME_VERSION);

	trap_SetConfigstring(CS_LEVEL_START_TIME, va("%i", level.startTime));

	G_SpawnString("music", "", &s);
	trap_SetConfigstring(CS_MUSIC, s);

	G_SpawnString("message", "", &s);
	trap_SetConfigstring(CS_MESSAGE, s);				// map specific message

	trap_SetConfigstring(CS_MOTD, g_motd.string);		// message of the day
	trap_SetConfigstring(CS_CON_FAIL, rpg_passMessage.string);

	G_SpawnString("gravity", "800", &s);
	trap_Cvar_Set("g_gravity", s);

	//FIXME: in some cases, want to carry over from previous running of this map
	G_SpawnString("fraglimit", "0", &s);
	if (s && atoi(s) != 0) {
		trap_Cvar_Set("fraglimit", s);
	}
	G_SpawnString("capturelimit", "0", &s);
	if (s && atoi(s) != 0) {
		trap_Cvar_Set("capturelimit", s);
	}
	G_SpawnString("timelimit", "0", &s);
	if (s && atoi(s) != 0) {
		trap_Cvar_Set("timelimit", s);
	}
	G_SpawnString("timelimitWinningTeam", "", &s);
	if (s) {
		trap_Cvar_Set("timelimitWinningTeam", s);
	}

	g_entities[ENTITYNUM_WORLD].s.number = ENTITYNUM_WORLD;
	g_entities[ENTITYNUM_WORLD].classname = "worldspawn";

	// see if we want a warmup time
	trap_SetConfigstring(CS_WARMUP, "");
	if (g_restarted.integer) {
		level.warmupTime = 0;
	}
}


/*
==============
G_SpawnEntitiesFromString

Parses textual entity definitions out of an entstring and spawns gentities.
==============
*/
void G_SpawnEntitiesFromString(void) {
	// allow calls to G_Spawn*()
	level.spawning = qtrue;
	level.numSpawnVars = 0;

	// the worldspawn is not an actual entity, but it still
	// has a "spawn" function to perform any global setup
	// needed by a level (setting configstrings or cvars, etc)
	if (!G_ParseSpawnVars()) {
		G_Error("SpawnEntities: no entities");
	}
	SP_worldspawn();

	// parse ents
	while (G_ParseSpawnVars()) {
		G_SpawnGEntityFromSpawnVars();
	}

	level.spawning = qfalse;			// any future calls to G_Spawn*() will be errors
}