/*
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_misc_redeploy(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},
                    {"misc_redeploy", SP_misc_redeploy},

                    {"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(const 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(const char *key, const char *value, edict_t *ent) {
  field_t *f;

  for(f = fields; f->name; f++) {
    if((f->flags & FFL_NOSPAWN) || Q_stricmp(f->name, key)) {
      continue;
    }

    // found it
    struct field_value fv = {.type = f->type};
    switch(fv.type) {
    case F_LSTRING:
      fv.string = ED_NewString(value);
      break;
    case F_VECTOR:
      sscanf(value, "%f %f %f", &fv.vector[0], &fv.vector[1], &fv.vector[2]);
      break;
    case F_INT:
      fv.integer = atoi(value);
      break;
    case F_FLOAT:
    case F_ANGLEHACK:
      fv.floating = atof(value);
      break;
    case F_IGNORE:
      return;
    default:
      gi.dprintf("savefile field encountered in ED_ParseField");
      break;
    }

    if(f->flags & FFL_SPAWNTEMP) {
      f->set_temp(&st, fv);
    } else {
      f->set(ent, fv);
    }

    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.
====================
*/
const char *ED_ParseEdict(const char *data, edict_t *ent) {
  bool init;
  char keyname[256];
  const 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);
}

void initialize_worlds(void);

/*
==============
SpawnEntities

Creates a server's entity / program execution context by
parsing textual entity definitions out of an ent file.
==============
*/
void SpawnEntities(int cmodel_index, const char *mapname, const char *entities, const 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));

  if(cmodel_index == CMODEL_A) {
    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;

    initialize_worlds();
  }

  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(cmodel_index == CMODEL_A && !ent)
      ent = g_edicts;
    else
      ent = G_Spawn(cmodel_index);
    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(strcmp(ent->classname, "info_player_start") == 0) {
          ent->spawnflags &= ~SPAWNFLAG_NOT_DEATHMATCH;
          ent->classname = "misc_redeploy";
        }

        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();

  if(cmodel_index == CMODEL_A) {
    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 = ent->s.cmodel_index + 1; // world model is always index 1

  if(st.nextmap)
    strcpy(level.nextmap, st.nextmap);

  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));

  gi.configstring(CS_CDTRACK, va("%i", ent->sounds));
}

void initialize_worlds(void) {
  // reserve some spots for dead player bodies for coop / deathmatch
  InitBodyQue();

  // set configstrings for items
  SetItemNames();

  // make some data visible to the server

  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");

  // TEST CODE
  // const char *maps[] = {"maps/q2dm2.bsp", "maps/q2dm3.bsp", "maps/q2dm4.bsp", "maps/q2dm5.bsp",
  //                       "maps/q2dm6.bsp", "maps/q2dm7.bsp", "maps/q2dm8.bsp"};

  // int b, c;
  // do {
  //   b = rand() % (sizeof(maps) / sizeof(maps[0]));
  //   c = rand() % (sizeof(maps) / sizeof(maps[0]));
  // } while(b == c);

  // edict_t *other = G_Spawn(CMODEL_B);
  // gi.setmodel(other, maps[b]);

  // edict_t *other2 = G_Spawn(CMODEL_C);
  // gi.setmodel(other2, maps[c]);
}