You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
984 lines
23 KiB
984 lines
23 KiB
/* |
|
Copyright (C) 1997-2001 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 the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
|
*/ |
|
|
|
#include "g_local.h" |
|
|
|
typedef struct |
|
{ |
|
char *name; |
|
void (*spawn)(edict_t *ent); |
|
} spawn_t; |
|
|
|
|
|
void SP_item_health (edict_t *self); |
|
void SP_item_health_small (edict_t *self); |
|
void SP_item_health_large (edict_t *self); |
|
void SP_item_health_mega (edict_t *self); |
|
|
|
void SP_info_player_start (edict_t *ent); |
|
void SP_info_player_deathmatch (edict_t *ent); |
|
void SP_info_player_coop (edict_t *ent); |
|
void SP_info_player_intermission (edict_t *ent); |
|
|
|
void SP_func_plat (edict_t *ent); |
|
void SP_func_rotating (edict_t *ent); |
|
void SP_func_button (edict_t *ent); |
|
void SP_func_door (edict_t *ent); |
|
void SP_func_door_secret (edict_t *ent); |
|
void SP_func_door_rotating (edict_t *ent); |
|
void SP_func_water (edict_t *ent); |
|
void SP_func_train (edict_t *ent); |
|
void SP_func_conveyor (edict_t *self); |
|
void SP_func_wall (edict_t *self); |
|
void SP_func_object (edict_t *self); |
|
void SP_func_explosive (edict_t *self); |
|
void SP_func_timer (edict_t *self); |
|
void SP_func_areaportal (edict_t *ent); |
|
void SP_func_clock (edict_t *ent); |
|
void SP_func_killbox (edict_t *ent); |
|
|
|
void SP_trigger_always (edict_t *ent); |
|
void SP_trigger_once (edict_t *ent); |
|
void SP_trigger_multiple (edict_t *ent); |
|
void SP_trigger_relay (edict_t *ent); |
|
void SP_trigger_push (edict_t *ent); |
|
void SP_trigger_hurt (edict_t *ent); |
|
void SP_trigger_key (edict_t *ent); |
|
void SP_trigger_counter (edict_t *ent); |
|
void SP_trigger_elevator (edict_t *ent); |
|
void SP_trigger_gravity (edict_t *ent); |
|
void SP_trigger_monsterjump (edict_t *ent); |
|
|
|
void SP_target_temp_entity (edict_t *ent); |
|
void SP_target_speaker (edict_t *ent); |
|
void SP_target_explosion (edict_t *ent); |
|
void SP_target_changelevel (edict_t *ent); |
|
void SP_target_secret (edict_t *ent); |
|
void SP_target_goal (edict_t *ent); |
|
void SP_target_splash (edict_t *ent); |
|
void SP_target_spawner (edict_t *ent); |
|
void SP_target_blaster (edict_t *ent); |
|
void SP_target_crosslevel_trigger (edict_t *ent); |
|
void SP_target_crosslevel_target (edict_t *ent); |
|
void SP_target_laser (edict_t *self); |
|
void SP_target_help (edict_t *ent); |
|
void SP_target_actor (edict_t *ent); |
|
void SP_target_lightramp (edict_t *self); |
|
void SP_target_earthquake (edict_t *ent); |
|
void SP_target_character (edict_t *ent); |
|
void SP_target_string (edict_t *ent); |
|
|
|
void SP_worldspawn (edict_t *ent); |
|
void SP_viewthing (edict_t *ent); |
|
|
|
void SP_light (edict_t *self); |
|
void SP_light_mine1 (edict_t *ent); |
|
void SP_light_mine2 (edict_t *ent); |
|
void SP_info_null (edict_t *self); |
|
void SP_info_notnull (edict_t *self); |
|
void SP_path_corner (edict_t *self); |
|
void SP_point_combat (edict_t *self); |
|
|
|
void SP_misc_explobox (edict_t *self); |
|
void SP_misc_banner (edict_t *self); |
|
void SP_misc_satellite_dish (edict_t *self); |
|
void SP_misc_actor (edict_t *self); |
|
void SP_misc_gib_arm (edict_t *self); |
|
void SP_misc_gib_leg (edict_t *self); |
|
void SP_misc_gib_head (edict_t *self); |
|
void SP_misc_insane (edict_t *self); |
|
void SP_misc_deadsoldier (edict_t *self); |
|
void SP_misc_viper (edict_t *self); |
|
void SP_misc_viper_bomb (edict_t *self); |
|
void SP_misc_bigviper (edict_t *self); |
|
void SP_misc_strogg_ship (edict_t *self); |
|
void SP_misc_teleporter (edict_t *self); |
|
void SP_misc_teleporter_dest (edict_t *self); |
|
void SP_misc_blackhole (edict_t *self); |
|
void SP_misc_eastertank (edict_t *self); |
|
void SP_misc_easterchick (edict_t *self); |
|
void SP_misc_easterchick2 (edict_t *self); |
|
|
|
void SP_monster_berserk (edict_t *self); |
|
void SP_monster_gladiator (edict_t *self); |
|
void SP_monster_gunner (edict_t *self); |
|
void SP_monster_infantry (edict_t *self); |
|
void SP_monster_soldier_light (edict_t *self); |
|
void SP_monster_soldier (edict_t *self); |
|
void SP_monster_soldier_ss (edict_t *self); |
|
void SP_monster_tank (edict_t *self); |
|
void SP_monster_medic (edict_t *self); |
|
void SP_monster_flipper (edict_t *self); |
|
void SP_monster_chick (edict_t *self); |
|
void SP_monster_parasite (edict_t *self); |
|
void SP_monster_flyer (edict_t *self); |
|
void SP_monster_brain (edict_t *self); |
|
void SP_monster_floater (edict_t *self); |
|
void SP_monster_hover (edict_t *self); |
|
void SP_monster_mutant (edict_t *self); |
|
void SP_monster_supertank (edict_t *self); |
|
void SP_monster_boss2 (edict_t *self); |
|
void SP_monster_jorg (edict_t *self); |
|
void SP_monster_boss3_stand (edict_t *self); |
|
|
|
void SP_monster_commander_body (edict_t *self); |
|
|
|
void SP_turret_breach (edict_t *self); |
|
void SP_turret_base (edict_t *self); |
|
void SP_turret_driver (edict_t *self); |
|
|
|
|
|
spawn_t spawns[] = { |
|
{"item_health", SP_item_health}, |
|
{"item_health_small", SP_item_health_small}, |
|
{"item_health_large", SP_item_health_large}, |
|
{"item_health_mega", SP_item_health_mega}, |
|
|
|
{"info_player_start", SP_info_player_start}, |
|
{"info_player_deathmatch", SP_info_player_deathmatch}, |
|
{"info_player_coop", SP_info_player_coop}, |
|
{"info_player_intermission", SP_info_player_intermission}, |
|
|
|
{"func_plat", SP_func_plat}, |
|
{"func_button", SP_func_button}, |
|
{"func_door", SP_func_door}, |
|
{"func_door_secret", SP_func_door_secret}, |
|
{"func_door_rotating", SP_func_door_rotating}, |
|
{"func_rotating", SP_func_rotating}, |
|
{"func_train", SP_func_train}, |
|
{"func_water", SP_func_water}, |
|
{"func_conveyor", SP_func_conveyor}, |
|
{"func_areaportal", SP_func_areaportal}, |
|
{"func_clock", SP_func_clock}, |
|
{"func_wall", SP_func_wall}, |
|
{"func_object", SP_func_object}, |
|
{"func_timer", SP_func_timer}, |
|
{"func_explosive", SP_func_explosive}, |
|
{"func_killbox", SP_func_killbox}, |
|
|
|
{"trigger_always", SP_trigger_always}, |
|
{"trigger_once", SP_trigger_once}, |
|
{"trigger_multiple", SP_trigger_multiple}, |
|
{"trigger_relay", SP_trigger_relay}, |
|
{"trigger_push", SP_trigger_push}, |
|
{"trigger_hurt", SP_trigger_hurt}, |
|
{"trigger_key", SP_trigger_key}, |
|
{"trigger_counter", SP_trigger_counter}, |
|
{"trigger_elevator", SP_trigger_elevator}, |
|
{"trigger_gravity", SP_trigger_gravity}, |
|
{"trigger_monsterjump", SP_trigger_monsterjump}, |
|
|
|
{"target_temp_entity", SP_target_temp_entity}, |
|
{"target_speaker", SP_target_speaker}, |
|
{"target_explosion", SP_target_explosion}, |
|
{"target_changelevel", SP_target_changelevel}, |
|
{"target_secret", SP_target_secret}, |
|
{"target_goal", SP_target_goal}, |
|
{"target_splash", SP_target_splash}, |
|
{"target_spawner", SP_target_spawner}, |
|
{"target_blaster", SP_target_blaster}, |
|
{"target_crosslevel_trigger", SP_target_crosslevel_trigger}, |
|
{"target_crosslevel_target", SP_target_crosslevel_target}, |
|
{"target_laser", SP_target_laser}, |
|
{"target_help", SP_target_help}, |
|
{"target_actor", SP_target_actor}, |
|
{"target_lightramp", SP_target_lightramp}, |
|
{"target_earthquake", SP_target_earthquake}, |
|
{"target_character", SP_target_character}, |
|
{"target_string", SP_target_string}, |
|
|
|
{"worldspawn", SP_worldspawn}, |
|
{"viewthing", SP_viewthing}, |
|
|
|
{"light", SP_light}, |
|
{"light_mine1", SP_light_mine1}, |
|
{"light_mine2", SP_light_mine2}, |
|
{"info_null", SP_info_null}, |
|
{"func_group", SP_info_null}, |
|
{"info_notnull", SP_info_notnull}, |
|
{"path_corner", SP_path_corner}, |
|
{"point_combat", SP_point_combat}, |
|
|
|
{"misc_explobox", SP_misc_explobox}, |
|
{"misc_banner", SP_misc_banner}, |
|
{"misc_satellite_dish", SP_misc_satellite_dish}, |
|
{"misc_actor", SP_misc_actor}, |
|
{"misc_gib_arm", SP_misc_gib_arm}, |
|
{"misc_gib_leg", SP_misc_gib_leg}, |
|
{"misc_gib_head", SP_misc_gib_head}, |
|
{"misc_insane", SP_misc_insane}, |
|
{"misc_deadsoldier", SP_misc_deadsoldier}, |
|
{"misc_viper", SP_misc_viper}, |
|
{"misc_viper_bomb", SP_misc_viper_bomb}, |
|
{"misc_bigviper", SP_misc_bigviper}, |
|
{"misc_strogg_ship", SP_misc_strogg_ship}, |
|
{"misc_teleporter", SP_misc_teleporter}, |
|
{"misc_teleporter_dest", SP_misc_teleporter_dest}, |
|
{"misc_blackhole", SP_misc_blackhole}, |
|
{"misc_eastertank", SP_misc_eastertank}, |
|
{"misc_easterchick", SP_misc_easterchick}, |
|
{"misc_easterchick2", SP_misc_easterchick2}, |
|
|
|
{"monster_berserk", SP_monster_berserk}, |
|
{"monster_gladiator", SP_monster_gladiator}, |
|
{"monster_gunner", SP_monster_gunner}, |
|
{"monster_infantry", SP_monster_infantry}, |
|
{"monster_soldier_light", SP_monster_soldier_light}, |
|
{"monster_soldier", SP_monster_soldier}, |
|
{"monster_soldier_ss", SP_monster_soldier_ss}, |
|
{"monster_tank", SP_monster_tank}, |
|
{"monster_tank_commander", SP_monster_tank}, |
|
{"monster_medic", SP_monster_medic}, |
|
{"monster_flipper", SP_monster_flipper}, |
|
{"monster_chick", SP_monster_chick}, |
|
{"monster_parasite", SP_monster_parasite}, |
|
{"monster_flyer", SP_monster_flyer}, |
|
{"monster_brain", SP_monster_brain}, |
|
{"monster_floater", SP_monster_floater}, |
|
{"monster_hover", SP_monster_hover}, |
|
{"monster_mutant", SP_monster_mutant}, |
|
{"monster_supertank", SP_monster_supertank}, |
|
{"monster_boss2", SP_monster_boss2}, |
|
{"monster_boss3_stand", SP_monster_boss3_stand}, |
|
{"monster_jorg", SP_monster_jorg}, |
|
|
|
{"monster_commander_body", SP_monster_commander_body}, |
|
|
|
{"turret_breach", SP_turret_breach}, |
|
{"turret_base", SP_turret_base}, |
|
{"turret_driver", SP_turret_driver}, |
|
|
|
{NULL, NULL} |
|
}; |
|
|
|
/* |
|
=============== |
|
ED_CallSpawn |
|
|
|
Finds the spawn function for the entity and calls it |
|
=============== |
|
*/ |
|
void ED_CallSpawn (edict_t *ent) |
|
{ |
|
spawn_t *s; |
|
gitem_t *item; |
|
int i; |
|
|
|
if (!ent->classname) |
|
{ |
|
gi.dprintf ("ED_CallSpawn: NULL classname\n"); |
|
return; |
|
} |
|
|
|
// check item spawn functions |
|
for (i=0,item=itemlist ; i<game.num_items ; i++,item++) |
|
{ |
|
if (!item->classname) |
|
continue; |
|
if (!strcmp(item->classname, ent->classname)) |
|
{ // found it |
|
SpawnItem (ent, item); |
|
return; |
|
} |
|
} |
|
|
|
// check normal spawn functions |
|
for (s=spawns ; s->name ; s++) |
|
{ |
|
if (!strcmp(s->name, ent->classname)) |
|
{ // found it |
|
s->spawn (ent); |
|
return; |
|
} |
|
} |
|
gi.dprintf ("%s doesn't have a spawn function\n", ent->classname); |
|
} |
|
|
|
/* |
|
============= |
|
ED_NewString |
|
============= |
|
*/ |
|
char *ED_NewString (char *string) |
|
{ |
|
char *newb, *new_p; |
|
int i,l; |
|
|
|
l = strlen(string) + 1; |
|
|
|
newb = gi.TagMalloc (l, TAG_LEVEL); |
|
|
|
new_p = newb; |
|
|
|
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; |
|
} |
|
|
|
|
|
|
|
|
|
/* |
|
=============== |
|
ED_ParseField |
|
|
|
Takes a key/value pair and sets the binary values |
|
in an edict |
|
=============== |
|
*/ |
|
void ED_ParseField (char *key, char *value, edict_t *ent) |
|
{ |
|
field_t *f; |
|
byte *b; |
|
float v; |
|
vec3_t vec; |
|
|
|
for (f=fields ; f->name ; f++) |
|
{ |
|
if (!(f->flags & FFL_NOSPAWN) && !Q_stricmp(f->name, key)) |
|
{ // found it |
|
if (f->flags & FFL_SPAWNTEMP) |
|
b = (byte *)&st; |
|
else |
|
b = (byte *)ent; |
|
|
|
switch (f->type) |
|
{ |
|
case F_LSTRING: |
|
*(char **)(b+f->ofs) = ED_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_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; |
|
case F_IGNORE: |
|
break; |
|
} |
|
return; |
|
} |
|
} |
|
gi.dprintf ("%s is not a field\n", key); |
|
} |
|
|
|
/* |
|
==================== |
|
ED_ParseEdict |
|
|
|
Parses an edict out of the given string, returning the new position |
|
ed should be a properly initialized empty edict. |
|
==================== |
|
*/ |
|
char *ED_ParseEdict (char *data, edict_t *ent) |
|
{ |
|
qboolean init; |
|
char keyname[256]; |
|
char *com_token; |
|
|
|
init = false; |
|
memset (&st, 0, sizeof(st)); |
|
|
|
// go through all the dictionary pairs |
|
while (1) |
|
{ |
|
// parse key |
|
com_token = COM_Parse (&data); |
|
if (com_token[0] == '}') |
|
break; |
|
if (!data) |
|
gi.error ("ED_ParseEntity: EOF without closing brace"); |
|
|
|
strncpy (keyname, com_token, sizeof(keyname)-1); |
|
|
|
// parse value |
|
com_token = COM_Parse (&data); |
|
if (!data) |
|
gi.error ("ED_ParseEntity: EOF without closing brace"); |
|
|
|
if (com_token[0] == '}') |
|
gi.error ("ED_ParseEntity: closing brace without data"); |
|
|
|
init = true; |
|
|
|
// keynames with a leading underscore are used for utility comments, |
|
// and are immediately discarded by quake |
|
if (keyname[0] == '_') |
|
continue; |
|
|
|
ED_ParseField (keyname, com_token, ent); |
|
} |
|
|
|
if (!init) |
|
memset (ent, 0, sizeof(*ent)); |
|
|
|
return data; |
|
} |
|
|
|
|
|
/* |
|
================ |
|
G_FindTeams |
|
|
|
Chain together all entities with a matching team field. |
|
|
|
All but the first will have the FL_TEAMSLAVE flag set. |
|
All but the last will have the teamchain field set to the next one |
|
================ |
|
*/ |
|
void G_FindTeams (void) |
|
{ |
|
edict_t *e, *e2, *chain; |
|
int i, j; |
|
int c, c2; |
|
|
|
c = 0; |
|
c2 = 0; |
|
for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++) |
|
{ |
|
if (!e->inuse) |
|
continue; |
|
if (!e->team) |
|
continue; |
|
if (e->flags & FL_TEAMSLAVE) |
|
continue; |
|
chain = e; |
|
e->teammaster = e; |
|
c++; |
|
c2++; |
|
for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++) |
|
{ |
|
if (!e2->inuse) |
|
continue; |
|
if (!e2->team) |
|
continue; |
|
if (e2->flags & FL_TEAMSLAVE) |
|
continue; |
|
if (!strcmp(e->team, e2->team)) |
|
{ |
|
c2++; |
|
chain->teamchain = e2; |
|
e2->teammaster = e; |
|
chain = e2; |
|
e2->flags |= FL_TEAMSLAVE; |
|
} |
|
} |
|
} |
|
|
|
gi.dprintf ("%i teams with %i entities\n", c, c2); |
|
} |
|
|
|
/* |
|
============== |
|
SpawnEntities |
|
|
|
Creates a server's entity / program execution context by |
|
parsing textual entity definitions out of an ent file. |
|
============== |
|
*/ |
|
void SpawnEntities (char *mapname, char *entities, char *spawnpoint) |
|
{ |
|
edict_t *ent; |
|
int inhibit; |
|
char *com_token; |
|
int i; |
|
float skill_level; |
|
|
|
skill_level = floor (skill->value); |
|
if (skill_level < 0) |
|
skill_level = 0; |
|
if (skill_level > 3) |
|
skill_level = 3; |
|
if (skill->value != skill_level) |
|
gi.cvar_forceset("skill", va("%f", skill_level)); |
|
|
|
SaveClientData (); |
|
|
|
gi.FreeTags (TAG_LEVEL); |
|
|
|
memset (&level, 0, sizeof(level)); |
|
memset (g_edicts, 0, game.maxentities * sizeof (g_edicts[0])); |
|
|
|
strncpy (level.mapname, mapname, sizeof(level.mapname)-1); |
|
strncpy (game.spawnpoint, spawnpoint, sizeof(game.spawnpoint)-1); |
|
|
|
// set client fields on player ents |
|
for (i=0 ; i<game.maxclients ; i++) |
|
g_edicts[i+1].client = game.clients + i; |
|
|
|
ent = NULL; |
|
inhibit = 0; |
|
|
|
// parse ents |
|
while (1) |
|
{ |
|
// parse the opening brace |
|
com_token = COM_Parse (&entities); |
|
if (!entities) |
|
break; |
|
if (com_token[0] != '{') |
|
gi.error ("ED_LoadFromFile: found %s when expecting {",com_token); |
|
|
|
if (!ent) |
|
ent = g_edicts; |
|
else |
|
ent = G_Spawn (); |
|
entities = ED_ParseEdict (entities, ent); |
|
|
|
// yet another map hack |
|
if (!Q_stricmp(level.mapname, "command") && !Q_stricmp(ent->classname, "trigger_once") && !Q_stricmp(ent->model, "*27")) |
|
ent->spawnflags &= ~SPAWNFLAG_NOT_HARD; |
|
|
|
// remove things (except the world) from different skill levels or deathmatch |
|
if (ent != g_edicts) |
|
{ |
|
if (deathmatch->value) |
|
{ |
|
if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH ) |
|
{ |
|
G_FreeEdict (ent); |
|
inhibit++; |
|
continue; |
|
} |
|
} |
|
else |
|
{ |
|
if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */ |
|
((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) || |
|
((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) || |
|
(((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD)) |
|
) |
|
{ |
|
G_FreeEdict (ent); |
|
inhibit++; |
|
continue; |
|
} |
|
} |
|
|
|
ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH); |
|
} |
|
|
|
ED_CallSpawn (ent); |
|
} |
|
|
|
gi.dprintf ("%i entities inhibited\n", inhibit); |
|
|
|
#ifdef DEBUG |
|
i = 1; |
|
ent = EDICT_NUM(i); |
|
while (i < globals.num_edicts) { |
|
if (ent->inuse != 0 || ent->inuse != 1) |
|
Com_DPrintf("Invalid entity %d\n", i); |
|
i++, ent++; |
|
} |
|
#endif |
|
|
|
G_FindTeams (); |
|
|
|
PlayerTrail_Init (); |
|
} |
|
|
|
|
|
//=================================================================== |
|
|
|
#if 0 |
|
// cursor positioning |
|
xl <value> |
|
xr <value> |
|
yb <value> |
|
yt <value> |
|
xv <value> |
|
yv <value> |
|
|
|
// drawing |
|
statpic <name> |
|
pic <stat> |
|
num <fieldwidth> <stat> |
|
string <stat> |
|
|
|
// control |
|
if <stat> |
|
ifeq <stat> <value> |
|
ifbit <stat> <value> |
|
endif |
|
|
|
#endif |
|
|
|
char *single_statusbar = |
|
"yb -24 " |
|
|
|
// health |
|
"xv 0 " |
|
"hnum " |
|
"xv 50 " |
|
"pic 0 " |
|
|
|
// ammo |
|
"if 2 " |
|
" xv 100 " |
|
" anum " |
|
" xv 150 " |
|
" pic 2 " |
|
"endif " |
|
|
|
// armor |
|
"if 4 " |
|
" xv 200 " |
|
" rnum " |
|
" xv 250 " |
|
" pic 4 " |
|
"endif " |
|
|
|
// selected item |
|
"if 6 " |
|
" xv 296 " |
|
" pic 6 " |
|
"endif " |
|
|
|
"yb -50 " |
|
|
|
// picked up item |
|
"if 7 " |
|
" xv 0 " |
|
" pic 7 " |
|
" xv 26 " |
|
" yb -42 " |
|
" stat_string 8 " |
|
" yb -50 " |
|
"endif " |
|
|
|
// timer |
|
"if 9 " |
|
" xv 262 " |
|
" num 2 10 " |
|
" xv 296 " |
|
" pic 9 " |
|
"endif " |
|
|
|
// help / weapon icon |
|
"if 11 " |
|
" xv 148 " |
|
" pic 11 " |
|
"endif " |
|
; |
|
|
|
char *dm_statusbar = |
|
"yb -24 " |
|
|
|
// health |
|
"xv 0 " |
|
"hnum " |
|
"xv 50 " |
|
"pic 0 " |
|
|
|
// ammo |
|
"if 2 " |
|
" xv 100 " |
|
" anum " |
|
" xv 150 " |
|
" pic 2 " |
|
"endif " |
|
|
|
// armor |
|
"if 4 " |
|
" xv 200 " |
|
" rnum " |
|
" xv 250 " |
|
" pic 4 " |
|
"endif " |
|
|
|
// selected item |
|
"if 6 " |
|
" xv 296 " |
|
" pic 6 " |
|
"endif " |
|
|
|
"yb -50 " |
|
|
|
// picked up item |
|
"if 7 " |
|
" xv 0 " |
|
" pic 7 " |
|
" xv 26 " |
|
" yb -42 " |
|
" stat_string 8 " |
|
" yb -50 " |
|
"endif " |
|
|
|
// timer |
|
"if 9 " |
|
" xv 246 " |
|
" num 2 10 " |
|
" xv 296 " |
|
" pic 9 " |
|
"endif " |
|
|
|
// help / weapon icon |
|
"if 11 " |
|
" xv 148 " |
|
" pic 11 " |
|
"endif " |
|
|
|
// frags |
|
"xr -50 " |
|
"yt 2 " |
|
"num 3 14 " |
|
|
|
// spectator |
|
"if 17 " |
|
"xv 0 " |
|
"yb -58 " |
|
"string2 \"SPECTATOR MODE\" " |
|
"endif " |
|
|
|
// chase camera |
|
"if 16 " |
|
"xv 0 " |
|
"yb -68 " |
|
"string \"Chasing\" " |
|
"xv 64 " |
|
"stat_string 16 " |
|
"endif " |
|
; |
|
|
|
|
|
/*QUAKED worldspawn (0 0 0) ? |
|
|
|
Only used for the world. |
|
"sky" environment map name |
|
"skyaxis" vector axis for rotating sky |
|
"skyrotate" speed of rotation in degrees/second |
|
"sounds" music cd track number |
|
"gravity" 800 is default gravity |
|
"message" text to print at user logon |
|
*/ |
|
void SP_worldspawn (edict_t *ent) |
|
{ |
|
ent->movetype = MOVETYPE_PUSH; |
|
ent->solid = SOLID_BSP; |
|
ent->inuse = true; // since the world doesn't use G_Spawn() |
|
ent->s.modelindex = 1; // world model is always index 1 |
|
|
|
//--------------- |
|
|
|
// reserve some spots for dead player bodies for coop / deathmatch |
|
InitBodyQue (); |
|
|
|
// set configstrings for items |
|
SetItemNames (); |
|
|
|
if (st.nextmap) |
|
strcpy (level.nextmap, st.nextmap); |
|
|
|
// make some data visible to the server |
|
|
|
if (ent->message && ent->message[0]) |
|
{ |
|
gi.configstring (CS_NAME, ent->message); |
|
strncpy (level.level_name, ent->message, sizeof(level.level_name)); |
|
} |
|
else |
|
strncpy (level.level_name, level.mapname, sizeof(level.level_name)); |
|
|
|
if (st.sky && st.sky[0]) |
|
gi.configstring (CS_SKY, st.sky); |
|
else |
|
gi.configstring (CS_SKY, "unit1_"); |
|
|
|
gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) ); |
|
|
|
gi.configstring (CS_SKYAXIS, va("%f %f %f", |
|
st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) ); |
|
|
|
gi.configstring (CS_CDTRACK, va("%i", ent->sounds) ); |
|
|
|
gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) ); |
|
|
|
// status bar program |
|
if (deathmatch->value) |
|
gi.configstring (CS_STATUSBAR, dm_statusbar); |
|
else |
|
gi.configstring (CS_STATUSBAR, single_statusbar); |
|
|
|
//--------------- |
|
|
|
|
|
// help icon for statusbar |
|
gi.imageindex ("i_help"); |
|
level.pic_health = gi.imageindex ("i_health"); |
|
gi.imageindex ("help"); |
|
gi.imageindex ("field_3"); |
|
|
|
if (!st.gravity) |
|
gi.cvar_set("sv_gravity", "800"); |
|
else |
|
gi.cvar_set("sv_gravity", st.gravity); |
|
|
|
snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime |
|
|
|
PrecacheItem (FindItem ("Blaster")); |
|
|
|
gi.soundindex ("player/lava1.wav"); |
|
gi.soundindex ("player/lava2.wav"); |
|
|
|
gi.soundindex ("misc/pc_up.wav"); |
|
gi.soundindex ("misc/talk1.wav"); |
|
|
|
gi.soundindex ("misc/udeath.wav"); |
|
|
|
// gibs |
|
gi.soundindex ("items/respawn1.wav"); |
|
|
|
// sexed sounds |
|
gi.soundindex ("*death1.wav"); |
|
gi.soundindex ("*death2.wav"); |
|
gi.soundindex ("*death3.wav"); |
|
gi.soundindex ("*death4.wav"); |
|
gi.soundindex ("*fall1.wav"); |
|
gi.soundindex ("*fall2.wav"); |
|
gi.soundindex ("*gurp1.wav"); // drowning damage |
|
gi.soundindex ("*gurp2.wav"); |
|
gi.soundindex ("*jump1.wav"); // player jump |
|
gi.soundindex ("*pain25_1.wav"); |
|
gi.soundindex ("*pain25_2.wav"); |
|
gi.soundindex ("*pain50_1.wav"); |
|
gi.soundindex ("*pain50_2.wav"); |
|
gi.soundindex ("*pain75_1.wav"); |
|
gi.soundindex ("*pain75_2.wav"); |
|
gi.soundindex ("*pain100_1.wav"); |
|
gi.soundindex ("*pain100_2.wav"); |
|
|
|
// sexed models |
|
// THIS ORDER MUST MATCH THE DEFINES IN g_local.h |
|
// you can add more, max 15 |
|
gi.modelindex ("#w_blaster.md2"); |
|
gi.modelindex ("#w_shotgun.md2"); |
|
gi.modelindex ("#w_sshotgun.md2"); |
|
gi.modelindex ("#w_machinegun.md2"); |
|
gi.modelindex ("#w_chaingun.md2"); |
|
gi.modelindex ("#a_grenades.md2"); |
|
gi.modelindex ("#w_glauncher.md2"); |
|
gi.modelindex ("#w_rlauncher.md2"); |
|
gi.modelindex ("#w_hyperblaster.md2"); |
|
gi.modelindex ("#w_railgun.md2"); |
|
gi.modelindex ("#w_bfg.md2"); |
|
|
|
//------------------- |
|
|
|
gi.soundindex ("player/gasp1.wav"); // gasping for air |
|
gi.soundindex ("player/gasp2.wav"); // head breaking surface, not gasping |
|
|
|
gi.soundindex ("player/watr_in.wav"); // feet hitting water |
|
gi.soundindex ("player/watr_out.wav"); // feet leaving water |
|
|
|
gi.soundindex ("player/watr_un.wav"); // head going underwater |
|
|
|
gi.soundindex ("player/u_breath1.wav"); |
|
gi.soundindex ("player/u_breath2.wav"); |
|
|
|
gi.soundindex ("items/pkup.wav"); // bonus item pickup |
|
gi.soundindex ("world/land.wav"); // landing thud |
|
gi.soundindex ("misc/h2ohit1.wav"); // landing splash |
|
|
|
gi.soundindex ("items/damage.wav"); |
|
gi.soundindex ("items/protect.wav"); |
|
gi.soundindex ("items/protect4.wav"); |
|
gi.soundindex ("weapons/noammo.wav"); |
|
|
|
gi.soundindex ("infantry/inflies1.wav"); |
|
|
|
sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/arm/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/bone/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/bone2/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/chest/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/skull/tris.md2"); |
|
gi.modelindex ("models/objects/gibs/head2/tris.md2"); |
|
|
|
// |
|
// Setup light animation tables. 'a' is total darkness, 'z' is doublebright. |
|
// |
|
|
|
// 0 normal |
|
gi.configstring(CS_LIGHTS+0, "m"); |
|
|
|
// 1 FLICKER (first variety) |
|
gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo"); |
|
|
|
// 2 SLOW STRONG PULSE |
|
gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba"); |
|
|
|
// 3 CANDLE (first variety) |
|
gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg"); |
|
|
|
// 4 FAST STROBE |
|
gi.configstring(CS_LIGHTS+4, "mamamamamama"); |
|
|
|
// 5 GENTLE PULSE 1 |
|
gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj"); |
|
|
|
// 6 FLICKER (second variety) |
|
gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno"); |
|
|
|
// 7 CANDLE (second variety) |
|
gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm"); |
|
|
|
// 8 CANDLE (third variety) |
|
gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa"); |
|
|
|
// 9 SLOW STROBE (fourth variety) |
|
gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz"); |
|
|
|
// 10 FLUORESCENT FLICKER |
|
gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma"); |
|
|
|
// 11 SLOW PULSE NOT FADE TO BLACK |
|
gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba"); |
|
|
|
// styles 32-62 are assigned by the light program for switchable lights |
|
|
|
// 63 testing |
|
gi.configstring(CS_LIGHTS+63, "a"); |
|
} |
|
|
|
|