g_spawn.c File Reference

#include "g_local.h"

Go to the source code of this file.

Classes
struct	spawn_func_t
struct	spawn_field_t

Functions
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)
void	ED_CallSpawn (edict_t *ent)
static char *	ED_NewString (const char *string)
static qboolean	ED_ParseField (const spawn_field_t *fields, const char *key, const char *value, byte *b)
void	ED_ParseEdict (const char **data, edict_t *ent)
void	G_FindTeams (void)
void	SpawnEntities (const char *mapname, const char *entities, const char *spawnpoint)

Variables
static const spawn_func_t	spawn_funcs []
static const spawn_field_t	spawn_fields []
static const spawn_field_t	temp_fields []
static const char	single_statusbar []
static const char	dm_statusbar []

Function Documentation

ED_CallSpawn()

void ED_CallSpawn

(

edict_t *

ent

)

Definition at line 340 of file g_spawn.c.

{
    const spawn_func_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 = spawn_funcs ; 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);
}

Referenced by medic_cable_attack(), SpawnEntities(), and use_target_spawner().

ED_NewString()

static char* ED_NewString ( const char *  string )

static

Definition at line 378 of file g_spawn.c.

{
    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;
}

Referenced by ED_ParseField().

ED_ParseEdict()

void ED_ParseEdict	(	const char **	data,
		edict_t *	ent
	)

Definition at line 467 of file g_spawn.c.

{
    qboolean    init;
    char        *key, *value;
 
    init = qfalse;
    memset(&st, 0, sizeof(st));
 
// go through all the dictionary pairs
    while (1) {
        // parse key
        key = COM_Parse(data);
        if (key[0] == '}')
            break;
        if (!*data)
            gi.error("%s: EOF without closing brace", __func__);
 
        // parse value
        value = COM_Parse(data);
        if (!*data)
            gi.error("%s: EOF without closing brace", __func__);
 
        if (value[0] == '}')
            gi.error("%s: closing brace without data", __func__);
 
        init = qtrue;
 
        // keynames with a leading underscore are used for utility comments,
        // and are immediately discarded by quake
        if (key[0] == '_')
            continue;
 
        if (!ED_ParseField(spawn_fields, key, value, (byte *)ent)) {
            if (!ED_ParseField(temp_fields, key, value, (byte *)&st)) {
                gi.dprintf("%s: %s is not a field\n", __func__, key);
            }
        }
    }
 
    if (!init)
        memset(ent, 0, sizeof(*ent));
}

Referenced by SpawnEntities().

ED_ParseField()

static qboolean ED_ParseField ( const spawn_field_t *  fields, const char *  key, const char *  value, byte *  b  )

static

Definition at line 414 of file g_spawn.c.

{
    const spawn_field_t *f;
    float   v;
    vec3_t  vec;
 
    for (f = fields ; f->name ; f++) {
        if (!Q_stricmp(f->name, key)) {
            // found it
            switch (f->type) {
            case F_LSTRING:
                *(char **)(b + f->ofs) = ED_NewString(value);
                break;
            case F_VECTOR:
                if (sscanf(value, "%f %f %f", &vec[0], &vec[1], &vec[2]) != 3) {
                    gi.dprintf("%s: couldn't parse '%s'\n", __func__, key);
                    VectorClear(vec);
                }
                ((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;
            default:
                break;
            }
            return qtrue;
        }
    }
    return qfalse;
}

Referenced by ED_ParseEdict().

G_FindTeams()

void G_FindTeams

(

void

)

Definition at line 521 of file g_spawn.c.

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

Referenced by SpawnEntities().

SP_func_areaportal()

void SP_func_areaportal

(

edict_t *

ent

)

Definition at line 42 of file g_misc.c.

{
    ent->use = Use_Areaportal;
    ent->count = 0;     // always start closed;
}

SP_func_button()

void SP_func_button

(

edict_t *

ent

)

Definition at line 726 of file g_func.c.

{
    vec3_t  abs_movedir;
    float   dist;
 
    G_SetMovedir(ent->s.angles, ent->movedir);
    ent->movetype = MOVETYPE_STOP;
    ent->solid = SOLID_BSP;
    gi.setmodel(ent, ent->model);
 
    if (ent->sounds != 1)
        ent->moveinfo.sound_start = gi.soundindex("switches/butn2.wav");
 
    if (!ent->speed)
        ent->speed = 40;
    if (!ent->accel)
        ent->accel = ent->speed;
    if (!ent->decel)
        ent->decel = ent->speed;
 
    if (!ent->wait)
        ent->wait = 3;
    if (!st.lip)
        st.lip = 4;
 
    VectorCopy(ent->s.origin, ent->pos1);
    abs_movedir[0] = fabs(ent->movedir[0]);
    abs_movedir[1] = fabs(ent->movedir[1]);
    abs_movedir[2] = fabs(ent->movedir[2]);
    dist = abs_movedir[0] * ent->size[0] + abs_movedir[1] * ent->size[1] + abs_movedir[2] * ent->size[2] - st.lip;
    VectorMA(ent->pos1, dist, ent->movedir, ent->pos2);
 
    ent->use = button_use;
    ent->s.effects |= EF_ANIM01;
 
    if (ent->health) {
        ent->max_health = ent->health;
        ent->die = button_killed;
        ent->takedamage = DAMAGE_YES;
    } else if (! ent->targetname)
        ent->touch = button_touch;
 
    ent->moveinfo.state = STATE_BOTTOM;
 
    ent->moveinfo.speed = ent->speed;
    ent->moveinfo.accel = ent->accel;
    ent->moveinfo.decel = ent->decel;
    ent->moveinfo.wait = ent->wait;
    VectorCopy(ent->pos1, ent->moveinfo.start_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.start_angles);
    VectorCopy(ent->pos2, ent->moveinfo.end_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.end_angles);
 
    gi.linkentity(ent);
}

SP_func_clock()

void SP_func_clock

(

edict_t *

ent

)

Definition at line 1670 of file g_misc.c.

{
    if (!self->target) {
        gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    if ((self->spawnflags & 2) && (!self->count)) {
        gi.dprintf("%s with no count at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    if ((self->spawnflags & 1) && (!self->count))
        self->count = 60 * 60;;
 
    func_clock_reset(self);
 
    self->message = gi.TagMalloc(CLOCK_MESSAGE_SIZE, TAG_LEVEL);
 
    self->think = func_clock_think;
 
    if (self->spawnflags & 4)
        self->use = func_clock_use;
    else
        self->nextthink = level.time + 1;
}

SP_func_conveyor()

void SP_func_conveyor

(

edict_t *

self

)

Definition at line 1734 of file g_func.c.

{
    if (!self->speed)
        self->speed = 100;
 
    if (!(self->spawnflags & 1)) {
        self->count = self->speed;
        self->speed = 0;
    }
 
    self->use = func_conveyor_use;
 
    gi.setmodel(self, self->model);
    self->solid = SOLID_BSP;
    gi.linkentity(self);
}

SP_func_door()

void SP_func_door

(

edict_t *

ent

)

Definition at line 1078 of file g_func.c.

{
    vec3_t  abs_movedir;
 
    if (ent->sounds != 1) {
        ent->moveinfo.sound_start = gi.soundindex("doors/dr1_strt.wav");
        ent->moveinfo.sound_middle = gi.soundindex("doors/dr1_mid.wav");
        ent->moveinfo.sound_end = gi.soundindex("doors/dr1_end.wav");
    }
 
    G_SetMovedir(ent->s.angles, ent->movedir);
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_BSP;
    gi.setmodel(ent, ent->model);
 
    ent->blocked = door_blocked;
    ent->use = door_use;
 
    if (!ent->speed)
        ent->speed = 100;
    if (deathmatch->value)
        ent->speed *= 2;
 
    if (!ent->accel)
        ent->accel = ent->speed;
    if (!ent->decel)
        ent->decel = ent->speed;
 
    if (!ent->wait)
        ent->wait = 3;
    if (!st.lip)
        st.lip = 8;
    if (!ent->dmg)
        ent->dmg = 2;
 
    // calculate second position
    VectorCopy(ent->s.origin, ent->pos1);
    abs_movedir[0] = fabs(ent->movedir[0]);
    abs_movedir[1] = fabs(ent->movedir[1]);
    abs_movedir[2] = fabs(ent->movedir[2]);
    ent->moveinfo.distance = abs_movedir[0] * ent->size[0] + abs_movedir[1] * ent->size[1] + abs_movedir[2] * ent->size[2] - st.lip;
    VectorMA(ent->pos1, ent->moveinfo.distance, ent->movedir, ent->pos2);
 
    // if it starts open, switch the positions
    if (ent->spawnflags & DOOR_START_OPEN) {
        VectorCopy(ent->pos2, ent->s.origin);
        VectorCopy(ent->pos1, ent->pos2);
        VectorCopy(ent->s.origin, ent->pos1);
    }
 
    ent->moveinfo.state = STATE_BOTTOM;
 
    if (ent->health) {
        ent->takedamage = DAMAGE_YES;
        ent->die = door_killed;
        ent->max_health = ent->health;
    } else if (ent->targetname && ent->message) {
        gi.soundindex("misc/talk.wav");
        ent->touch = door_touch;
    }
 
    ent->moveinfo.speed = ent->speed;
    ent->moveinfo.accel = ent->accel;
    ent->moveinfo.decel = ent->decel;
    ent->moveinfo.wait = ent->wait;
    VectorCopy(ent->pos1, ent->moveinfo.start_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.start_angles);
    VectorCopy(ent->pos2, ent->moveinfo.end_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.end_angles);
 
    if (ent->spawnflags & 16)
        ent->s.effects |= EF_ANIM_ALL;
    if (ent->spawnflags & 64)
        ent->s.effects |= EF_ANIM_ALLFAST;
 
    // to simplify logic elsewhere, make non-teamed doors into a team of one
    if (!ent->team)
        ent->teammaster = ent;
 
    gi.linkentity(ent);
 
    ent->nextthink = level.time + FRAMETIME;
    if (ent->health || ent->targetname)
        ent->think = Think_CalcMoveSpeed;
    else
        ent->think = Think_SpawnDoorTrigger;
}

SP_func_door_rotating()

void SP_func_door_rotating

(

edict_t *

ent

)

Definition at line 1196 of file g_func.c.

{
    VectorClear(ent->s.angles);
 
    // set the axis of rotation
    VectorClear(ent->movedir);
    if (ent->spawnflags & DOOR_X_AXIS)
        ent->movedir[2] = 1.0;
    else if (ent->spawnflags & DOOR_Y_AXIS)
        ent->movedir[0] = 1.0;
    else // Z_AXIS
        ent->movedir[1] = 1.0;
 
    // check for reverse rotation
    if (ent->spawnflags & DOOR_REVERSE)
        VectorNegate(ent->movedir, ent->movedir);
 
    if (!st.distance) {
        gi.dprintf("%s at %s with no distance set\n", ent->classname, vtos(ent->s.origin));
        st.distance = 90;
    }
 
    VectorCopy(ent->s.angles, ent->pos1);
    VectorMA(ent->s.angles, st.distance, ent->movedir, ent->pos2);
    ent->moveinfo.distance = st.distance;
 
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_BSP;
    gi.setmodel(ent, ent->model);
 
    ent->blocked = door_blocked;
    ent->use = door_use;
 
    if (!ent->speed)
        ent->speed = 100;
    if (!ent->accel)
        ent->accel = ent->speed;
    if (!ent->decel)
        ent->decel = ent->speed;
 
    if (!ent->wait)
        ent->wait = 3;
    if (!ent->dmg)
        ent->dmg = 2;
 
    if (ent->sounds != 1) {
        ent->moveinfo.sound_start = gi.soundindex("doors/dr1_strt.wav");
        ent->moveinfo.sound_middle = gi.soundindex("doors/dr1_mid.wav");
        ent->moveinfo.sound_end = gi.soundindex("doors/dr1_end.wav");
    }
 
    // if it starts open, switch the positions
    if (ent->spawnflags & DOOR_START_OPEN) {
        VectorCopy(ent->pos2, ent->s.angles);
        VectorCopy(ent->pos1, ent->pos2);
        VectorCopy(ent->s.angles, ent->pos1);
        VectorNegate(ent->movedir, ent->movedir);
    }
 
    if (ent->health) {
        ent->takedamage = DAMAGE_YES;
        ent->die = door_killed;
        ent->max_health = ent->health;
    }
 
    if (ent->targetname && ent->message) {
        gi.soundindex("misc/talk.wav");
        ent->touch = door_touch;
    }
 
    ent->moveinfo.state = STATE_BOTTOM;
    ent->moveinfo.speed = ent->speed;
    ent->moveinfo.accel = ent->accel;
    ent->moveinfo.decel = ent->decel;
    ent->moveinfo.wait = ent->wait;
    VectorCopy(ent->s.origin, ent->moveinfo.start_origin);
    VectorCopy(ent->pos1, ent->moveinfo.start_angles);
    VectorCopy(ent->s.origin, ent->moveinfo.end_origin);
    VectorCopy(ent->pos2, ent->moveinfo.end_angles);
 
    if (ent->spawnflags & 16)
        ent->s.effects |= EF_ANIM_ALL;
 
    // to simplify logic elsewhere, make non-teamed doors into a team of one
    if (!ent->team)
        ent->teammaster = ent;
 
    gi.linkentity(ent);
 
    ent->nextthink = level.time + FRAMETIME;
    if (ent->health || ent->targetname)
        ent->think = Think_CalcMoveSpeed;
    else
        ent->think = Think_SpawnDoorTrigger;
}

SP_func_door_secret()

void SP_func_door_secret

(

edict_t *

ent

)

Definition at line 1855 of file g_func.c.

{
    vec3_t  forward, right, up;
    float   side;
    float   width;
    float   length;
 
    ent->moveinfo.sound_start = gi.soundindex("doors/dr1_strt.wav");
    ent->moveinfo.sound_middle = gi.soundindex("doors/dr1_mid.wav");
    ent->moveinfo.sound_end = gi.soundindex("doors/dr1_end.wav");
 
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_BSP;
    gi.setmodel(ent, ent->model);
 
    ent->blocked = door_secret_blocked;
    ent->use = door_secret_use;
 
    if (!(ent->targetname) || (ent->spawnflags & SECRET_ALWAYS_SHOOT)) {
        ent->health = 0;
        ent->takedamage = DAMAGE_YES;
        ent->die = door_secret_die;
    }
 
    if (!ent->dmg)
        ent->dmg = 2;
 
    if (!ent->wait)
        ent->wait = 5;
 
    ent->moveinfo.accel =
        ent->moveinfo.decel =
            ent->moveinfo.speed = 50;
 
    // calculate positions
    AngleVectors(ent->s.angles, forward, right, up);
    VectorClear(ent->s.angles);
    side = 1.0 - (ent->spawnflags & SECRET_1ST_LEFT);
    if (ent->spawnflags & SECRET_1ST_DOWN)
        width = fabs(DotProduct(up, ent->size));
    else
        width = fabs(DotProduct(right, ent->size));
    length = fabs(DotProduct(forward, ent->size));
    if (ent->spawnflags & SECRET_1ST_DOWN)
        VectorMA(ent->s.origin, -1 * width, up, ent->pos1);
    else
        VectorMA(ent->s.origin, side * width, right, ent->pos1);
    VectorMA(ent->pos1, length, forward, ent->pos2);
 
    if (ent->health) {
        ent->takedamage = DAMAGE_YES;
        ent->die = door_killed;
        ent->max_health = ent->health;
    } else if (ent->targetname && ent->message) {
        gi.soundindex("misc/talk.wav");
        ent->touch = door_touch;
    }
 
    ent->classname = "func_door";
 
    gi.linkentity(ent);
}

SP_func_explosive()

void SP_func_explosive

(

edict_t *

self

)

Definition at line 771 of file g_misc.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(self);
        return;
    }
 
    self->movetype = MOVETYPE_PUSH;
 
    gi.modelindex("models/objects/debris1/tris.md2");
    gi.modelindex("models/objects/debris2/tris.md2");
 
    gi.setmodel(self, self->model);
 
    if (self->spawnflags & 1) {
        self->svflags |= SVF_NOCLIENT;
        self->solid = SOLID_NOT;
        self->use = func_explosive_spawn;
    } else {
        self->solid = SOLID_BSP;
        if (self->targetname)
            self->use = func_explosive_use;
    }
 
    if (self->spawnflags & 2)
        self->s.effects |= EF_ANIM_ALL;
    if (self->spawnflags & 4)
        self->s.effects |= EF_ANIM_ALLFAST;
 
    if (self->use != func_explosive_use) {
        if (!self->health)
            self->health = 100;
        self->die = func_explosive_explode;
        self->takedamage = DAMAGE_YES;
    }
 
    gi.linkentity(self);
}

SP_func_killbox()

void SP_func_killbox

(

edict_t *

ent

)

Definition at line 1927 of file g_func.c.

{
    gi.setmodel(ent, ent->model);
    ent->use = use_killbox;
    ent->svflags = SVF_NOCLIENT;
}

SP_func_object()

void SP_func_object

(

edict_t *

self

)

Definition at line 646 of file g_misc.c.

{
    gi.setmodel(self, self->model);
 
    self->mins[0] += 1;
    self->mins[1] += 1;
    self->mins[2] += 1;
    self->maxs[0] -= 1;
    self->maxs[1] -= 1;
    self->maxs[2] -= 1;
 
    if (!self->dmg)
        self->dmg = 100;
 
    if (self->spawnflags == 0) {
        self->solid = SOLID_BSP;
        self->movetype = MOVETYPE_PUSH;
        self->think = func_object_release;
        self->nextthink = level.time + 2 * FRAMETIME;
    } else {
        self->solid = SOLID_NOT;
        self->movetype = MOVETYPE_PUSH;
        self->use = func_object_use;
        self->svflags |= SVF_NOCLIENT;
    }
 
    if (self->spawnflags & 2)
        self->s.effects |= EF_ANIM_ALL;
    if (self->spawnflags & 4)
        self->s.effects |= EF_ANIM_ALLFAST;
 
    self->clipmask = MASK_MONSTERSOLID;
 
    gi.linkentity(self);
}

SP_func_plat()

void SP_func_plat

(

edict_t *

ent

)

Definition at line 483 of file g_func.c.

{
    VectorClear(ent->s.angles);
    ent->solid = SOLID_BSP;
    ent->movetype = MOVETYPE_PUSH;
 
    gi.setmodel(ent, ent->model);
 
    ent->blocked = plat_blocked;
 
    if (!ent->speed)
        ent->speed = 20;
    else
        ent->speed *= 0.1;
 
    if (!ent->accel)
        ent->accel = 5;
    else
        ent->accel *= 0.1;
 
    if (!ent->decel)
        ent->decel = 5;
    else
        ent->decel *= 0.1;
 
    if (!ent->dmg)
        ent->dmg = 2;
 
    if (!st.lip)
        st.lip = 8;
 
    // pos1 is the top position, pos2 is the bottom
    VectorCopy(ent->s.origin, ent->pos1);
    VectorCopy(ent->s.origin, ent->pos2);
    if (st.height)
        ent->pos2[2] -= st.height;
    else
        ent->pos2[2] -= (ent->maxs[2] - ent->mins[2]) - st.lip;
 
    ent->use = Use_Plat;
 
    plat_spawn_inside_trigger(ent);     // the "start moving" trigger
 
    if (ent->targetname) {
        ent->moveinfo.state = STATE_UP;
    } else {
        VectorCopy(ent->pos2, ent->s.origin);
        gi.linkentity(ent);
        ent->moveinfo.state = STATE_BOTTOM;
    }
 
    ent->moveinfo.speed = ent->speed;
    ent->moveinfo.accel = ent->accel;
    ent->moveinfo.decel = ent->decel;
    ent->moveinfo.wait = ent->wait;
    VectorCopy(ent->pos1, ent->moveinfo.start_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.start_angles);
    VectorCopy(ent->pos2, ent->moveinfo.end_origin);
    VectorCopy(ent->s.angles, ent->moveinfo.end_angles);
 
    ent->moveinfo.sound_start = gi.soundindex("plats/pt1_strt.wav");
    ent->moveinfo.sound_middle = gi.soundindex("plats/pt1_mid.wav");
    ent->moveinfo.sound_end = gi.soundindex("plats/pt1_end.wav");
}

SP_func_rotating()

void SP_func_rotating

(

edict_t *

ent

)

Definition at line 587 of file g_func.c.

{
    ent->solid = SOLID_BSP;
    if (ent->spawnflags & 32)
        ent->movetype = MOVETYPE_STOP;
    else
        ent->movetype = MOVETYPE_PUSH;
 
    // set the axis of rotation
    VectorClear(ent->movedir);
    if (ent->spawnflags & 4)
        ent->movedir[2] = 1.0;
    else if (ent->spawnflags & 8)
        ent->movedir[0] = 1.0;
    else // Z_AXIS
        ent->movedir[1] = 1.0;
 
    // check for reverse rotation
    if (ent->spawnflags & 2)
        VectorNegate(ent->movedir, ent->movedir);
 
    if (!ent->speed)
        ent->speed = 100;
    if (!ent->dmg)
        ent->dmg = 2;
 
//  ent->moveinfo.sound_middle = "doors/hydro1.wav";
 
    ent->use = rotating_use;
    if (ent->dmg)
        ent->blocked = rotating_blocked;
 
    if (ent->spawnflags & 1)
        ent->use(ent, NULL, NULL);
 
    if (ent->spawnflags & 64)
        ent->s.effects |= EF_ANIM_ALL;
    if (ent->spawnflags & 128)
        ent->s.effects |= EF_ANIM_ALLFAST;
 
    gi.setmodel(ent, ent->model);
    gi.linkentity(ent);
}

SP_func_timer()

void SP_func_timer

(

edict_t *

self

)

Definition at line 1692 of file g_func.c.

{
    if (!self->wait)
        self->wait = 1.0;
 
    self->use = func_timer_use;
    self->think = func_timer_think;
 
    if (self->random >= self->wait) {
        self->random = self->wait - FRAMETIME;
        gi.dprintf("func_timer at %s has random >= wait\n", vtos(self->s.origin));
    }
 
    if (self->spawnflags & 1) {
        self->nextthink = level.time + 1.0 + st.pausetime + self->delay + self->wait + crandom() * self->random;
        self->activator = self;
    }
 
    self->svflags = SVF_NOCLIENT;
}

SP_func_train()

void SP_func_train

(

edict_t *

ent

)

Definition at line 1562 of file g_func.c.

{
    self->movetype = MOVETYPE_PUSH;
 
    VectorClear(self->s.angles);
    self->blocked = train_blocked;
    if (self->spawnflags & TRAIN_BLOCK_STOPS)
        self->dmg = 0;
    else {
        if (!self->dmg)
            self->dmg = 100;
    }
    self->solid = SOLID_BSP;
    gi.setmodel(self, self->model);
 
    if (st.noise)
        self->moveinfo.sound_middle = gi.soundindex(st.noise);
 
    if (!self->speed)
        self->speed = 100;
 
    self->moveinfo.speed = self->speed;
    self->moveinfo.accel = self->moveinfo.decel = self->moveinfo.speed;
 
    self->use = train_use;
 
    gi.linkentity(self);
 
    if (self->target) {
        // start trains on the second frame, to make sure their targets have had
        // a chance to spawn
        self->nextthink = level.time + FRAMETIME;
        self->think = func_train_find;
    } else {
        gi.dprintf("func_train without a target at %s\n", vtos(self->absmin));
    }
}

SP_func_wall()

void SP_func_wall

(

edict_t *

self

)

Definition at line 573 of file g_misc.c.

{
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel(self, self->model);
 
    if (self->spawnflags & 8)
        self->s.effects |= EF_ANIM_ALL;
    if (self->spawnflags & 16)
        self->s.effects |= EF_ANIM_ALLFAST;
 
    // just a wall
    if ((self->spawnflags & 7) == 0) {
        self->solid = SOLID_BSP;
        gi.linkentity(self);
        return;
    }
 
    // it must be TRIGGER_SPAWN
    if (!(self->spawnflags & 1)) {
//      gi.dprintf("func_wall missing TRIGGER_SPAWN\n");
        self->spawnflags |= 1;
    }
 
    // yell if the spawnflags are odd
    if (self->spawnflags & 4) {
        if (!(self->spawnflags & 2)) {
            gi.dprintf("func_wall START_ON without TOGGLE\n");
            self->spawnflags |= 2;
        }
    }
 
    self->use = func_wall_use;
    if (self->spawnflags & 4) {
        self->solid = SOLID_BSP;
    } else {
        self->solid = SOLID_NOT;
        self->svflags |= SVF_NOCLIENT;
    }
    gi.linkentity(self);
}

SP_func_water()

void SP_func_water

(

edict_t *

ent

)

Definition at line 1308 of file g_func.c.

{
    vec3_t  abs_movedir;
 
    G_SetMovedir(self->s.angles, self->movedir);
    self->movetype = MOVETYPE_PUSH;
    self->solid = SOLID_BSP;
    gi.setmodel(self, self->model);
 
    switch (self->sounds) {
    default:
        break;
 
    case 1: // water
        self->moveinfo.sound_start = gi.soundindex("world/mov_watr.wav");
        self->moveinfo.sound_end = gi.soundindex("world/stp_watr.wav");
        break;
 
    case 2: // lava
        self->moveinfo.sound_start = gi.soundindex("world/mov_watr.wav");
        self->moveinfo.sound_end = gi.soundindex("world/stp_watr.wav");
        break;
    }
 
    // calculate second position
    VectorCopy(self->s.origin, self->pos1);
    abs_movedir[0] = fabs(self->movedir[0]);
    abs_movedir[1] = fabs(self->movedir[1]);
    abs_movedir[2] = fabs(self->movedir[2]);
    self->moveinfo.distance = abs_movedir[0] * self->size[0] + abs_movedir[1] * self->size[1] + abs_movedir[2] * self->size[2] - st.lip;
    VectorMA(self->pos1, self->moveinfo.distance, self->movedir, self->pos2);
 
    // if it starts open, switch the positions
    if (self->spawnflags & DOOR_START_OPEN) {
        VectorCopy(self->pos2, self->s.origin);
        VectorCopy(self->pos1, self->pos2);
        VectorCopy(self->s.origin, self->pos1);
    }
 
    VectorCopy(self->pos1, self->moveinfo.start_origin);
    VectorCopy(self->s.angles, self->moveinfo.start_angles);
    VectorCopy(self->pos2, self->moveinfo.end_origin);
    VectorCopy(self->s.angles, self->moveinfo.end_angles);
 
    self->moveinfo.state = STATE_BOTTOM;
 
    if (!self->speed)
        self->speed = 25;
    self->moveinfo.accel = self->moveinfo.decel = self->moveinfo.speed = self->speed;
 
    if (!self->wait)
        self->wait = -1;
    self->moveinfo.wait = self->wait;
 
    self->use = door_use;
 
    if (self->wait == -1)
        self->spawnflags |= DOOR_TOGGLE;
 
    self->classname = "func_door";
 
    gi.linkentity(self);
}

SP_info_notnull()

void SP_info_notnull

(

edict_t *

self

)

Definition at line 497 of file g_misc.c.

{
    VectorCopy(self->s.origin, self->absmin);
    VectorCopy(self->s.origin, self->absmax);
}

SP_info_null()

void SP_info_null

(

edict_t *

self

)

Definition at line 488 of file g_misc.c.

{
    G_FreeEdict(self);
}

SP_info_player_coop()

void SP_info_player_coop

(

edict_t *

ent

)

Definition at line 130 of file p_client.c.

{
    if (!coop->value) {
        G_FreeEdict(self);
        return;
    }
 
    if ((Q_stricmp(level.mapname, "jail2") == 0)   ||
        (Q_stricmp(level.mapname, "jail4") == 0)   ||
        (Q_stricmp(level.mapname, "mine1") == 0)   ||
        (Q_stricmp(level.mapname, "mine2") == 0)   ||
        (Q_stricmp(level.mapname, "mine3") == 0)   ||
        (Q_stricmp(level.mapname, "mine4") == 0)   ||
        (Q_stricmp(level.mapname, "lab") == 0)     ||
        (Q_stricmp(level.mapname, "boss1") == 0)   ||
        (Q_stricmp(level.mapname, "fact3") == 0)   ||
        (Q_stricmp(level.mapname, "biggun") == 0)  ||
        (Q_stricmp(level.mapname, "space") == 0)   ||
        (Q_stricmp(level.mapname, "command") == 0) ||
        (Q_stricmp(level.mapname, "power2") == 0) ||
        (Q_stricmp(level.mapname, "strike") == 0)) {
        // invoke one of our gross, ugly, disgusting hacks
        self->think = SP_FixCoopSpots;
        self->nextthink = level.time + FRAMETIME;
    }
}

SP_info_player_deathmatch()

void SP_info_player_deathmatch

(

edict_t *

ent

)

Definition at line 117 of file p_client.c.

{
    if (!deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
    SP_misc_teleporter_dest(self);
}

SP_info_player_intermission()

void SP_info_player_intermission

(

edict_t *

ent

)

SP_info_player_start()

void SP_info_player_start

(

edict_t *

ent

)

Definition at line 103 of file p_client.c.

{
    if (!coop->value)
        return;
    if (Q_stricmp(level.mapname, "security") == 0) {
        // invoke one of our gross, ugly, disgusting hacks
        self->think = SP_CreateCoopSpots;
        self->nextthink = level.time + FRAMETIME;
    }
}

SP_item_health()

void SP_item_health

(

edict_t *

self

)

Definition at line 2071 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/medium/tris.md2";
    self->count = 10;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/n_health.wav");
}

SP_item_health_large()

void SP_item_health_large

(

edict_t *

self

)

Definition at line 2102 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/large/tris.md2";
    self->count = 25;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/l_health.wav");
}

SP_item_health_mega()

void SP_item_health_mega

(

edict_t *

self

)

Definition at line 2117 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/mega_h/tris.md2";
    self->count = 100;
    SpawnItem(self, FindItem("Health"));
    gi.soundindex("items/m_health.wav");
    self->style = HEALTH_IGNORE_MAX | HEALTH_TIMED;
}

SP_item_health_small()

void SP_item_health_small

(

edict_t *

self

)

Definition at line 2086 of file g_items.c.

{
    if (deathmatch->value && ((int)dmflags->value & DF_NO_HEALTH)) {
        G_FreeEdict(self);
        return;
    }
 
    self->model = "models/items/healing/stimpack/tris.md2";
    self->count = 2;
    SpawnItem(self, FindItem("Health"));
    self->style = HEALTH_IGNORE_MAX;
    gi.soundindex("items/s_health.wav");
}

SP_light()

void SP_light

(

edict_t *

self

)

Definition at line 525 of file g_misc.c.

{
    // no targeted lights in deathmatch, because they cause global messages
    if (!self->targetname || deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    if (self->style >= 32) {
        self->use = light_use;
        if (self->spawnflags & START_OFF)
            gi.configstring(CS_LIGHTS + self->style, "a");
        else
            gi.configstring(CS_LIGHTS + self->style, "m");
    }
}

SP_light_mine1()

void SP_light_mine1

(

edict_t *

ent

)

Definition at line 1411 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    ent->s.modelindex = gi.modelindex("models/objects/minelite/light1/tris.md2");
    gi.linkentity(ent);
}

SP_light_mine2()

void SP_light_mine2

(

edict_t *

ent

)

Definition at line 1422 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    ent->s.modelindex = gi.modelindex("models/objects/minelite/light2/tris.md2");
    gi.linkentity(ent);
}

SP_misc_actor()

void SP_misc_actor

(

edict_t *

self

)

Definition at line 399 of file m_actor.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    if (!self->targetname) {
        gi.dprintf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    if (!self->target) {
        gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("players/male/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    if (!self->health)
        self->health = 100;
    self->mass = 200;
 
    self->pain = actor_pain;
    self->die = actor_die;
 
    self->monsterinfo.stand = actor_stand;
    self->monsterinfo.walk = actor_walk;
    self->monsterinfo.run = actor_run;
    self->monsterinfo.attack = actor_attack;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = NULL;
 
    self->monsterinfo.aiflags |= AI_GOOD_GUY;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &actor_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
 
    // actors always start in a dormant state, they *must* be used to get going
    self->use = actor_use;
}

SP_misc_banner()

void SP_misc_banner

(

edict_t *

self

)

Definition at line 1142 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_NOT;
    ent->s.modelindex = gi.modelindex("models/objects/banner/tris.md2");
    ent->s.frame = rand() % 16;
    gi.linkentity(ent);
 
    ent->think = misc_banner_think;
    ent->nextthink = level.time + FRAMETIME;
}

SP_misc_bigviper()

void SP_misc_bigviper

(

edict_t *

self

)

Definition at line 1255 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    VectorSet(ent->mins, -176, -120, -24);
    VectorSet(ent->maxs, 176, 120, 72);
    ent->s.modelindex = gi.modelindex("models/ships/bigviper/tris.md2");
    gi.linkentity(ent);
}

SP_misc_blackhole()

void SP_misc_blackhole

(

edict_t *

self

)

Definition at line 986 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_NOT;
    VectorSet(ent->mins, -64, -64, 0);
    VectorSet(ent->maxs, 64, 64, 8);
    ent->s.modelindex = gi.modelindex("models/objects/black/tris.md2");
    ent->s.renderfx = RF_TRANSLUCENT;
    ent->use = misc_blackhole_use;
    ent->think = misc_blackhole_think;
    ent->nextthink = level.time + 2 * FRAMETIME;
    gi.linkentity(ent);
}

SP_misc_deadsoldier()

void SP_misc_deadsoldier

(

edict_t *

self

)

Definition at line 1170 of file g_misc.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(ent);
        return;
    }
 
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    ent->s.modelindex = gi.modelindex("models/deadbods/dude/tris.md2");
 
    // Defaults to frame 0
    if (ent->spawnflags & 2)
        ent->s.frame = 1;
    else if (ent->spawnflags & 4)
        ent->s.frame = 2;
    else if (ent->spawnflags & 8)
        ent->s.frame = 3;
    else if (ent->spawnflags & 16)
        ent->s.frame = 4;
    else if (ent->spawnflags & 32)
        ent->s.frame = 5;
    else
        ent->s.frame = 0;
 
    VectorSet(ent->mins, -16, -16, 0);
    VectorSet(ent->maxs, 16, 16, 16);
    ent->deadflag = DEAD_DEAD;
    ent->takedamage = DAMAGE_YES;
    ent->svflags |= SVF_MONSTER | SVF_DEADMONSTER;
    ent->die = misc_deadsoldier_die;
    ent->monsterinfo.aiflags |= AI_GOOD_GUY;
 
    gi.linkentity(ent);
}

SP_misc_easterchick()

void SP_misc_easterchick

(

edict_t *

self

)

Definition at line 1040 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    VectorSet(ent->mins, -32, -32, 0);
    VectorSet(ent->maxs, 32, 32, 32);
    ent->s.modelindex = gi.modelindex("models/monsters/bitch/tris.md2");
    ent->s.frame = 208;
    ent->think = misc_easterchick_think;
    ent->nextthink = level.time + 2 * FRAMETIME;
    gi.linkentity(ent);
}

SP_misc_easterchick2()

void SP_misc_easterchick2

(

edict_t *

self

)

Definition at line 1067 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    VectorSet(ent->mins, -32, -32, 0);
    VectorSet(ent->maxs, 32, 32, 32);
    ent->s.modelindex = gi.modelindex("models/monsters/bitch/tris.md2");
    ent->s.frame = 248;
    ent->think = misc_easterchick2_think;
    ent->nextthink = level.time + 2 * FRAMETIME;
    gi.linkentity(ent);
}

SP_misc_eastertank()

void SP_misc_eastertank

(

edict_t *

self

)

Definition at line 1013 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    VectorSet(ent->mins, -32, -32, -16);
    VectorSet(ent->maxs, 32, 32, 32);
    ent->s.modelindex = gi.modelindex("models/monsters/tank/tris.md2");
    ent->s.frame = 254;
    ent->think = misc_eastertank_think;
    ent->nextthink = level.time + 2 * FRAMETIME;
    gi.linkentity(ent);
}

SP_misc_explobox()

void SP_misc_explobox

(

edict_t *

self

)

Definition at line 918 of file g_misc.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(self);
        return;
    }
 
    gi.modelindex("models/objects/debris1/tris.md2");
    gi.modelindex("models/objects/debris2/tris.md2");
    gi.modelindex("models/objects/debris3/tris.md2");
 
    self->solid = SOLID_BBOX;
    self->movetype = MOVETYPE_STEP;
 
    self->model = "models/objects/barrels/tris.md2";
    self->s.modelindex = gi.modelindex(self->model);
    VectorSet(self->mins, -16, -16, 0);
    VectorSet(self->maxs, 16, 16, 40);
 
    if (!self->mass)
        self->mass = 400;
    if (!self->health)
        self->health = 10;
    if (!self->dmg)
        self->dmg = 150;
 
    self->die = barrel_delay;
    self->takedamage = DAMAGE_YES;
    self->monsterinfo.aiflags = AI_NOSTEP;
 
    self->touch = barrel_touch;
 
    self->think = M_droptofloor;
    self->nextthink = level.time + 2 * FRAMETIME;
 
    gi.linkentity(self);
}

SP_misc_gib_arm()

void SP_misc_gib_arm

(

edict_t *

self

)

Definition at line 1434 of file g_misc.c.

{
    gi.setmodel(ent, "models/objects/gibs/arm/tris.md2");
    ent->solid = SOLID_NOT;
    ent->s.effects |= EF_GIB;
    ent->takedamage = DAMAGE_YES;
    ent->die = gib_die;
    ent->movetype = MOVETYPE_TOSS;
    ent->svflags |= SVF_MONSTER;
    ent->deadflag = DEAD_DEAD;
    ent->avelocity[0] = random() * 200;
    ent->avelocity[1] = random() * 200;
    ent->avelocity[2] = random() * 200;
    ent->think = G_FreeEdict;
    ent->nextthink = level.time + 30;
    gi.linkentity(ent);
}

SP_misc_gib_head()

void SP_misc_gib_head

(

edict_t *

self

)

Definition at line 1476 of file g_misc.c.

{
    gi.setmodel(ent, "models/objects/gibs/head/tris.md2");
    ent->solid = SOLID_NOT;
    ent->s.effects |= EF_GIB;
    ent->takedamage = DAMAGE_YES;
    ent->die = gib_die;
    ent->movetype = MOVETYPE_TOSS;
    ent->svflags |= SVF_MONSTER;
    ent->deadflag = DEAD_DEAD;
    ent->avelocity[0] = random() * 200;
    ent->avelocity[1] = random() * 200;
    ent->avelocity[2] = random() * 200;
    ent->think = G_FreeEdict;
    ent->nextthink = level.time + 30;
    gi.linkentity(ent);
}

SP_misc_gib_leg()

void SP_misc_gib_leg

(

edict_t *

self

)

Definition at line 1455 of file g_misc.c.

{
    gi.setmodel(ent, "models/objects/gibs/leg/tris.md2");
    ent->solid = SOLID_NOT;
    ent->s.effects |= EF_GIB;
    ent->takedamage = DAMAGE_YES;
    ent->die = gib_die;
    ent->movetype = MOVETYPE_TOSS;
    ent->svflags |= SVF_MONSTER;
    ent->deadflag = DEAD_DEAD;
    ent->avelocity[0] = random() * 200;
    ent->avelocity[1] = random() * 200;
    ent->avelocity[2] = random() * 200;
    ent->think = G_FreeEdict;
    ent->nextthink = level.time + 30;
    gi.linkentity(ent);
}

SP_misc_insane()

void SP_misc_insane

(

edict_t *

self

)

Definition at line 589 of file m_insane.c.

{
//  static int skin = 0;    //@@
 
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_fist = gi.soundindex("insane/insane11.wav");
    sound_shake = gi.soundindex("insane/insane5.wav");
    sound_moan = gi.soundindex("insane/insane7.wav");
    sound_scream[0] = gi.soundindex("insane/insane1.wav");
    sound_scream[1] = gi.soundindex("insane/insane2.wav");
    sound_scream[2] = gi.soundindex("insane/insane3.wav");
    sound_scream[3] = gi.soundindex("insane/insane4.wav");
    sound_scream[4] = gi.soundindex("insane/insane6.wav");
    sound_scream[5] = gi.soundindex("insane/insane8.wav");
    sound_scream[6] = gi.soundindex("insane/insane9.wav");
    sound_scream[7] = gi.soundindex("insane/insane10.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/insane/tris.md2");
 
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 100;
    self->gib_health = -50;
    self->mass = 300;
 
    self->pain = insane_pain;
    self->die = insane_die;
 
    self->monsterinfo.stand = insane_stand;
    self->monsterinfo.walk = insane_walk;
    self->monsterinfo.run = insane_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = NULL;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = NULL;
    self->monsterinfo.aiflags |= AI_GOOD_GUY;
 
//@@
//  self->s.skinnum = skin;
//  skin++;
//  if (skin > 12)
//      skin = 0;
 
    gi.linkentity(self);
 
    if (self->spawnflags & 16)              // Stand Ground
        self->monsterinfo.aiflags |= AI_STAND_GROUND;
 
    self->monsterinfo.currentmove = &insane_move_stand_normal;
 
    self->monsterinfo.scale = MODEL_SCALE;
 
    if (self->spawnflags & 8) {                 // Crucified ?
        VectorSet(self->mins, -16, 0, 0);
        VectorSet(self->maxs, 16, 8, 32);
        self->flags |= FL_NO_KNOCKBACK;
        flymonster_start(self);
    } else {
        walkmonster_start(self);
        self->s.skinnum = rand() % 3;
    }
}

SP_misc_satellite_dish()

void SP_misc_satellite_dish

(

edict_t *

self

)

Definition at line 1397 of file g_misc.c.

{
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    VectorSet(ent->mins, -64, -64, 0);
    VectorSet(ent->maxs, 64, 64, 128);
    ent->s.modelindex = gi.modelindex("models/objects/satellite/tris.md2");
    ent->use = misc_satellite_dish_use;
    gi.linkentity(ent);
}

SP_misc_strogg_ship()

void SP_misc_strogg_ship

(

edict_t *

self

)

Definition at line 1354 of file g_misc.c.

{
    if (!ent->target) {
        gi.dprintf("%s without a target at %s\n", ent->classname, vtos(ent->absmin));
        G_FreeEdict(ent);
        return;
    }
 
    if (!ent->speed)
        ent->speed = 300;
 
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_NOT;
    ent->s.modelindex = gi.modelindex("models/ships/strogg1/tris.md2");
    VectorSet(ent->mins, -16, -16, 0);
    VectorSet(ent->maxs, 16, 16, 32);
 
    ent->think = func_train_find;
    ent->nextthink = level.time + FRAMETIME;
    ent->use = misc_strogg_ship_use;
    ent->svflags |= SVF_NOCLIENT;
    ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;
 
    gi.linkentity(ent);
}

SP_misc_teleporter()

void SP_misc_teleporter

(

edict_t *

self

)

Definition at line 1748 of file g_misc.c.

{
    edict_t     *trig;
 
    if (!ent->target) {
        gi.dprintf("teleporter without a target.\n");
        G_FreeEdict(ent);
        return;
    }
 
    gi.setmodel(ent, "models/objects/dmspot/tris.md2");
    ent->s.skinnum = 1;
    ent->s.effects = EF_TELEPORTER;
    ent->s.sound = gi.soundindex("world/amb10.wav");
    ent->solid = SOLID_BBOX;
 
    VectorSet(ent->mins, -32, -32, -24);
    VectorSet(ent->maxs, 32, 32, -16);
    gi.linkentity(ent);
 
    trig = G_Spawn();
    trig->touch = teleporter_touch;
    trig->solid = SOLID_TRIGGER;
    trig->target = ent->target;
    trig->owner = ent;
    VectorCopy(ent->s.origin, trig->s.origin);
    VectorSet(trig->mins, -8, -8, 8);
    VectorSet(trig->maxs, 8, 8, 24);
    gi.linkentity(trig);
 
}

SP_misc_teleporter_dest()

void SP_misc_teleporter_dest

(

edict_t *

self

)

Definition at line 1783 of file g_misc.c.

{
    gi.setmodel(ent, "models/objects/dmspot/tris.md2");
    ent->s.skinnum = 0;
    ent->solid = SOLID_BBOX;
//  ent->s.effects |= EF_FLIES;
    VectorSet(ent->mins, -32, -32, -24);
    VectorSet(ent->maxs, 32, 32, -16);
    gi.linkentity(ent);
}

SP_misc_viper()

void SP_misc_viper

(

edict_t *

self

)

Definition at line 1225 of file g_misc.c.

{
    if (!ent->target) {
        gi.dprintf("misc_viper without a target at %s\n", vtos(ent->absmin));
        G_FreeEdict(ent);
        return;
    }
 
    if (!ent->speed)
        ent->speed = 300;
 
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_NOT;
    ent->s.modelindex = gi.modelindex("models/ships/viper/tris.md2");
    VectorSet(ent->mins, -16, -16, 0);
    VectorSet(ent->maxs, 16, 16, 32);
 
    ent->think = func_train_find;
    ent->nextthink = level.time + FRAMETIME;
    ent->use = misc_viper_use;
    ent->svflags |= SVF_NOCLIENT;
    ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;
 
    gi.linkentity(ent);
}

SP_misc_viper_bomb()

void SP_misc_viper_bomb

(

edict_t *

self

)

Definition at line 1317 of file g_misc.c.

{
    self->movetype = MOVETYPE_NONE;
    self->solid = SOLID_NOT;
    VectorSet(self->mins, -8, -8, -8);
    VectorSet(self->maxs, 8, 8, 8);
 
    self->s.modelindex = gi.modelindex("models/objects/bomb/tris.md2");
 
    if (!self->dmg)
        self->dmg = 1000;
 
    self->use = misc_viper_bomb_use;
    self->svflags |= SVF_NOCLIENT;
 
    gi.linkentity(self);
}

SP_monster_berserk()

void SP_monster_berserk

(

edict_t *

self

)

Definition at line 399 of file m_berserk.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    // pre-caches
    sound_pain  = gi.soundindex("berserk/berpain2.wav");
    sound_die   = gi.soundindex("berserk/berdeth2.wav");
    sound_idle  = gi.soundindex("berserk/beridle1.wav");
    sound_punch = gi.soundindex("berserk/attack.wav");
    sound_search = gi.soundindex("berserk/bersrch1.wav");
    sound_sight = gi.soundindex("berserk/sight.wav");
 
    self->s.modelindex = gi.modelindex("models/monsters/berserk/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
 
    self->health = 240;
    self->gib_health = -60;
    self->mass = 250;
 
    self->pain = berserk_pain;
    self->die = berserk_die;
 
    self->monsterinfo.stand = berserk_stand;
    self->monsterinfo.walk = berserk_walk;
    self->monsterinfo.run = berserk_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = NULL;
    self->monsterinfo.melee = berserk_melee;
    self->monsterinfo.sight = berserk_sight;
    self->monsterinfo.search = berserk_search;
 
    self->monsterinfo.currentmove = &berserk_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    gi.linkentity(self);
 
    walkmonster_start(self);
}

SP_monster_boss2()

void SP_monster_boss2

(

edict_t *

self

)

Definition at line 599 of file m_boss2.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("bosshovr/bhvpain1.wav");
    sound_pain2 = gi.soundindex("bosshovr/bhvpain2.wav");
    sound_pain3 = gi.soundindex("bosshovr/bhvpain3.wav");
    sound_death = gi.soundindex("bosshovr/bhvdeth1.wav");
    sound_search1 = gi.soundindex("bosshovr/bhvunqv1.wav");
 
    self->s.sound = gi.soundindex("bosshovr/bhvengn1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/boss2/tris.md2");
    VectorSet(self->mins, -56, -56, 0);
    VectorSet(self->maxs, 56, 56, 80);
 
    self->health = 2000;
    self->gib_health = -200;
    self->mass = 1000;
 
    self->flags |= FL_IMMUNE_LASER;
 
    self->pain = boss2_pain;
    self->die = boss2_die;
 
    self->monsterinfo.stand = boss2_stand;
    self->monsterinfo.walk = boss2_walk;
    self->monsterinfo.run = boss2_run;
    self->monsterinfo.attack = boss2_attack;
    self->monsterinfo.search = boss2_search;
    self->monsterinfo.checkattack = Boss2_CheckAttack;
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &boss2_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    flymonster_start(self);
}

SP_monster_boss3_stand()

void SP_monster_boss3_stand

(

edict_t *

self

)

Definition at line 51 of file m_boss3.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->model = "models/monsters/boss3/rider/tris.md2";
    self->s.modelindex = gi.modelindex(self->model);
    self->s.frame = FRAME_stand201;
 
    gi.soundindex("misc/bigtele.wav");
 
    VectorSet(self->mins, -32, -32, 0);
    VectorSet(self->maxs, 32, 32, 90);
 
    self->use = Use_Boss3;
    self->think = Think_Boss3Stand;
    self->nextthink = level.time + FRAMETIME;
    gi.linkentity(self);
}

SP_monster_brain()

void SP_monster_brain

(

edict_t *

self

)

Definition at line 594 of file m_brain.c.

                                     {
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_chest_open = gi.soundindex("brain/brnatck1.wav");
    sound_tentacles_extend = gi.soundindex("brain/brnatck2.wav");
    sound_tentacles_retract = gi.soundindex("brain/brnatck3.wav");
    sound_death = gi.soundindex("brain/brndeth1.wav");
    sound_idle1 = gi.soundindex("brain/brnidle1.wav");
    sound_idle2 = gi.soundindex("brain/brnidle2.wav");
    sound_idle3 = gi.soundindex("brain/brnlens1.wav");
    sound_pain1 = gi.soundindex("brain/brnpain1.wav");
    sound_pain2 = gi.soundindex("brain/brnpain2.wav");
    sound_sight = gi.soundindex("brain/brnsght1.wav");
    sound_search = gi.soundindex("brain/brnsrch1.wav");
    sound_melee1 = gi.soundindex("brain/melee1.wav");
    sound_melee2 = gi.soundindex("brain/melee2.wav");
    sound_melee3 = gi.soundindex("brain/melee3.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/brain/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 300;
    self->gib_health = -150;
    self->mass = 400;
 
    self->pain = brain_pain;
    self->die = brain_die;
 
    self->monsterinfo.stand = brain_stand;
    self->monsterinfo.walk = brain_walk;
    self->monsterinfo.run = brain_run;
    self->monsterinfo.dodge = brain_dodge;
//  self->monsterinfo.attack = brain_attack;
    self->monsterinfo.melee = brain_melee;
    self->monsterinfo.sight = brain_sight;
    self->monsterinfo.search = brain_search;
    self->monsterinfo.idle = brain_idle;
 
    self->monsterinfo.power_armor_type = POWER_ARMOR_SCREEN;
    self->monsterinfo.power_armor_power = 100;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &brain_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_chick()

void SP_monster_chick

(

edict_t *

self

)

Definition at line 594 of file m_chick.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_missile_prelaunch = gi.soundindex("chick/chkatck1.wav");
    sound_missile_launch    = gi.soundindex("chick/chkatck2.wav");
    sound_melee_swing       = gi.soundindex("chick/chkatck3.wav");
    sound_melee_hit         = gi.soundindex("chick/chkatck4.wav");
    sound_missile_reload    = gi.soundindex("chick/chkatck5.wav");
    sound_death1            = gi.soundindex("chick/chkdeth1.wav");
    sound_death2            = gi.soundindex("chick/chkdeth2.wav");
    sound_fall_down         = gi.soundindex("chick/chkfall1.wav");
    sound_idle1             = gi.soundindex("chick/chkidle1.wav");
    sound_idle2             = gi.soundindex("chick/chkidle2.wav");
    sound_pain1             = gi.soundindex("chick/chkpain1.wav");
    sound_pain2             = gi.soundindex("chick/chkpain2.wav");
    sound_pain3             = gi.soundindex("chick/chkpain3.wav");
    sound_sight             = gi.soundindex("chick/chksght1.wav");
    sound_search            = gi.soundindex("chick/chksrch1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/bitch/tris.md2");
    VectorSet(self->mins, -16, -16, 0);
    VectorSet(self->maxs, 16, 16, 56);
 
    self->health = 175;
    self->gib_health = -70;
    self->mass = 200;
 
    self->pain = chick_pain;
    self->die = chick_die;
 
    self->monsterinfo.stand = chick_stand;
    self->monsterinfo.walk = chick_walk;
    self->monsterinfo.run = chick_run;
    self->monsterinfo.dodge = chick_dodge;
    self->monsterinfo.attack = chick_attack;
    self->monsterinfo.melee = chick_melee;
    self->monsterinfo.sight = chick_sight;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &chick_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_commander_body()

void SP_monster_commander_body

(

edict_t *

self

)

Definition at line 1110 of file g_misc.c.

{
    self->movetype = MOVETYPE_NONE;
    self->solid = SOLID_BBOX;
    self->model = "models/monsters/commandr/tris.md2";
    self->s.modelindex = gi.modelindex(self->model);
    VectorSet(self->mins, -32, -32, 0);
    VectorSet(self->maxs, 32, 32, 48);
    self->use = commander_body_use;
    self->takedamage = DAMAGE_YES;
    self->flags = FL_GODMODE;
    self->s.renderfx |= RF_FRAMELERP;
    gi.linkentity(self);
 
    gi.soundindex("tank/thud.wav");
    gi.soundindex("tank/pain.wav");
 
    self->think = commander_body_drop;
    self->nextthink = level.time + 5 * FRAMETIME;
}

SP_monster_flipper()

void SP_monster_flipper

(

edict_t *

self

)

Definition at line 346 of file m_flipper.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1     = gi.soundindex("flipper/flppain1.wav");
    sound_pain2     = gi.soundindex("flipper/flppain2.wav");
    sound_death     = gi.soundindex("flipper/flpdeth1.wav");
    sound_chomp     = gi.soundindex("flipper/flpatck1.wav");
    sound_attack    = gi.soundindex("flipper/flpatck2.wav");
    sound_idle      = gi.soundindex("flipper/flpidle1.wav");
    sound_search    = gi.soundindex("flipper/flpsrch1.wav");
    sound_sight     = gi.soundindex("flipper/flpsght1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/flipper/tris.md2");
    VectorSet(self->mins, -16, -16, 0);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 50;
    self->gib_health = -30;
    self->mass = 100;
 
    self->pain = flipper_pain;
    self->die = flipper_die;
 
    self->monsterinfo.stand = flipper_stand;
    self->monsterinfo.walk = flipper_walk;
    self->monsterinfo.run = flipper_start_run;
    self->monsterinfo.melee = flipper_melee;
    self->monsterinfo.sight = flipper_sight;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &flipper_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    swimmonster_start(self);
}

SP_monster_floater()

void SP_monster_floater

(

edict_t *

self

)

Definition at line 594 of file m_float.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_attack2 = gi.soundindex("floater/fltatck2.wav");
    sound_attack3 = gi.soundindex("floater/fltatck3.wav");
    sound_death1 = gi.soundindex("floater/fltdeth1.wav");
    sound_idle = gi.soundindex("floater/fltidle1.wav");
    sound_pain1 = gi.soundindex("floater/fltpain1.wav");
    sound_pain2 = gi.soundindex("floater/fltpain2.wav");
    sound_sight = gi.soundindex("floater/fltsght1.wav");
 
    gi.soundindex("floater/fltatck1.wav");
 
    self->s.sound = gi.soundindex("floater/fltsrch1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/float/tris.md2");
    VectorSet(self->mins, -24, -24, -24);
    VectorSet(self->maxs, 24, 24, 32);
 
    self->health = 200;
    self->gib_health = -80;
    self->mass = 300;
 
    self->pain = floater_pain;
    self->die = floater_die;
 
    self->monsterinfo.stand = floater_stand;
    self->monsterinfo.walk = floater_walk;
    self->monsterinfo.run = floater_run;
//  self->monsterinfo.dodge = floater_dodge;
    self->monsterinfo.attack = floater_attack;
    self->monsterinfo.melee = floater_melee;
    self->monsterinfo.sight = floater_sight;
    self->monsterinfo.idle = floater_idle;
 
    gi.linkentity(self);
 
    if (random() <= 0.5)
        self->monsterinfo.currentmove = &floater_move_stand1;
    else
        self->monsterinfo.currentmove = &floater_move_stand2;
 
    self->monsterinfo.scale = MODEL_SCALE;
 
    flymonster_start(self);
}

SP_monster_flyer()

void SP_monster_flyer

(

edict_t *

self

)

Definition at line 549 of file m_flyer.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    // fix a map bug in jail5.bsp
    if (!Q_stricmp(level.mapname, "jail5") && (self->s.origin[2] == -104)) {
        self->targetname = self->target;
        self->target = NULL;
    }
 
    sound_sight = gi.soundindex("flyer/flysght1.wav");
    sound_idle = gi.soundindex("flyer/flysrch1.wav");
    sound_pain1 = gi.soundindex("flyer/flypain1.wav");
    sound_pain2 = gi.soundindex("flyer/flypain2.wav");
    sound_slash = gi.soundindex("flyer/flyatck2.wav");
    sound_sproing = gi.soundindex("flyer/flyatck1.wav");
    sound_die = gi.soundindex("flyer/flydeth1.wav");
 
    gi.soundindex("flyer/flyatck3.wav");
 
    self->s.modelindex = gi.modelindex("models/monsters/flyer/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
 
    self->s.sound = gi.soundindex("flyer/flyidle1.wav");
 
    self->health = 50;
    self->mass = 50;
 
    self->pain = flyer_pain;
    self->die = flyer_die;
 
    self->monsterinfo.stand = flyer_stand;
    self->monsterinfo.walk = flyer_walk;
    self->monsterinfo.run = flyer_run;
    self->monsterinfo.attack = flyer_attack;
    self->monsterinfo.melee = flyer_melee;
    self->monsterinfo.sight = flyer_sight;
    self->monsterinfo.idle = flyer_idle;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &flyer_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    flymonster_start(self);
}

SP_monster_gladiator()

void SP_monster_gladiator

(

edict_t *

self

)

Definition at line 327 of file m_gladiator.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
 
    sound_pain1 = gi.soundindex("gladiator/pain.wav");
    sound_pain2 = gi.soundindex("gladiator/gldpain2.wav");
    sound_die = gi.soundindex("gladiator/glddeth2.wav");
    sound_gun = gi.soundindex("gladiator/railgun.wav");
    sound_cleaver_swing = gi.soundindex("gladiator/melee1.wav");
    sound_cleaver_hit = gi.soundindex("gladiator/melee2.wav");
    sound_cleaver_miss = gi.soundindex("gladiator/melee3.wav");
    sound_idle = gi.soundindex("gladiator/gldidle1.wav");
    sound_search = gi.soundindex("gladiator/gldsrch1.wav");
    sound_sight = gi.soundindex("gladiator/sight.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/gladiatr/tris.md2");
    VectorSet(self->mins, -32, -32, -24);
    VectorSet(self->maxs, 32, 32, 64);
 
    self->health = 400;
    self->gib_health = -175;
    self->mass = 400;
 
    self->pain = gladiator_pain;
    self->die = gladiator_die;
 
    self->monsterinfo.stand = gladiator_stand;
    self->monsterinfo.walk = gladiator_walk;
    self->monsterinfo.run = gladiator_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = gladiator_attack;
    self->monsterinfo.melee = gladiator_melee;
    self->monsterinfo.sight = gladiator_sight;
    self->monsterinfo.idle = gladiator_idle;
    self->monsterinfo.search = gladiator_search;
 
    gi.linkentity(self);
    self->monsterinfo.currentmove = &gladiator_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_gunner()

void SP_monster_gunner

(

edict_t *

self

)

Definition at line 559 of file m_gunner.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_death = gi.soundindex("gunner/death1.wav");
    sound_pain = gi.soundindex("gunner/gunpain2.wav");
    sound_pain2 = gi.soundindex("gunner/gunpain1.wav");
    sound_idle = gi.soundindex("gunner/gunidle1.wav");
    sound_open = gi.soundindex("gunner/gunatck1.wav");
    sound_search = gi.soundindex("gunner/gunsrch1.wav");
    sound_sight = gi.soundindex("gunner/sight1.wav");
 
    gi.soundindex("gunner/gunatck2.wav");
    gi.soundindex("gunner/gunatck3.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/gunner/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 175;
    self->gib_health = -70;
    self->mass = 200;
 
    self->pain = gunner_pain;
    self->die = gunner_die;
 
    self->monsterinfo.stand = gunner_stand;
    self->monsterinfo.walk = gunner_walk;
    self->monsterinfo.run = gunner_run;
    self->monsterinfo.dodge = gunner_dodge;
    self->monsterinfo.attack = gunner_attack;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = gunner_sight;
    self->monsterinfo.search = gunner_search;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &gunner_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_hover()

void SP_monster_hover

(

edict_t *

self

)

Definition at line 546 of file m_hover.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("hover/hovpain1.wav");
    sound_pain2 = gi.soundindex("hover/hovpain2.wav");
    sound_death1 = gi.soundindex("hover/hovdeth1.wav");
    sound_death2 = gi.soundindex("hover/hovdeth2.wav");
    sound_sight = gi.soundindex("hover/hovsght1.wav");
    sound_search1 = gi.soundindex("hover/hovsrch1.wav");
    sound_search2 = gi.soundindex("hover/hovsrch2.wav");
 
    gi.soundindex("hover/hovatck1.wav");
 
    self->s.sound = gi.soundindex("hover/hovidle1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/hover/tris.md2");
    VectorSet(self->mins, -24, -24, -24);
    VectorSet(self->maxs, 24, 24, 32);
 
    self->health = 240;
    self->gib_health = -100;
    self->mass = 150;
 
    self->pain = hover_pain;
    self->die = hover_die;
 
    self->monsterinfo.stand = hover_stand;
    self->monsterinfo.walk = hover_walk;
    self->monsterinfo.run = hover_run;
//  self->monsterinfo.dodge = hover_dodge;
    self->monsterinfo.attack = hover_start_attack;
    self->monsterinfo.sight = hover_sight;
    self->monsterinfo.search = hover_search;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &hover_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    flymonster_start(self);
}

SP_monster_infantry()

void SP_monster_infantry

(

edict_t *

self

)

Definition at line 526 of file m_infantry.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("infantry/infpain1.wav");
    sound_pain2 = gi.soundindex("infantry/infpain2.wav");
    sound_die1 = gi.soundindex("infantry/infdeth1.wav");
    sound_die2 = gi.soundindex("infantry/infdeth2.wav");
 
    sound_gunshot = gi.soundindex("infantry/infatck1.wav");
    sound_weapon_cock = gi.soundindex("infantry/infatck3.wav");
    sound_punch_swing = gi.soundindex("infantry/infatck2.wav");
    sound_punch_hit = gi.soundindex("infantry/melee2.wav");
 
    sound_sight = gi.soundindex("infantry/infsght1.wav");
    sound_search = gi.soundindex("infantry/infsrch1.wav");
    sound_idle = gi.soundindex("infantry/infidle1.wav");
 
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 100;
    self->gib_health = -40;
    self->mass = 200;
 
    self->pain = infantry_pain;
    self->die = infantry_die;
 
    self->monsterinfo.stand = infantry_stand;
    self->monsterinfo.walk = infantry_walk;
    self->monsterinfo.run = infantry_run;
    self->monsterinfo.dodge = infantry_dodge;
    self->monsterinfo.attack = infantry_attack;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = infantry_sight;
    self->monsterinfo.idle = infantry_fidget;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &infantry_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_jorg()

void SP_monster_jorg

(

edict_t *

self

)

Definition at line 649 of file m_boss31.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("boss3/bs3pain1.wav");
    sound_pain2 = gi.soundindex("boss3/bs3pain2.wav");
    sound_pain3 = gi.soundindex("boss3/bs3pain3.wav");
    sound_death = gi.soundindex("boss3/bs3deth1.wav");
    sound_attack1 = gi.soundindex("boss3/bs3atck1.wav");
    sound_attack2 = gi.soundindex("boss3/bs3atck2.wav");
    sound_search1 = gi.soundindex("boss3/bs3srch1.wav");
    sound_search2 = gi.soundindex("boss3/bs3srch2.wav");
    sound_search3 = gi.soundindex("boss3/bs3srch3.wav");
    sound_idle = gi.soundindex("boss3/bs3idle1.wav");
    sound_step_left = gi.soundindex("boss3/step1.wav");
    sound_step_right = gi.soundindex("boss3/step2.wav");
    sound_firegun = gi.soundindex("boss3/xfire.wav");
    sound_death_hit = gi.soundindex("boss3/d_hit.wav");
 
    MakronPrecache();
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/boss3/rider/tris.md2");
    self->s.modelindex2 = gi.modelindex("models/monsters/boss3/jorg/tris.md2");
    VectorSet(self->mins, -80, -80, 0);
    VectorSet(self->maxs, 80, 80, 140);
 
    self->health = 3000;
    self->gib_health = -2000;
    self->mass = 1000;
 
    self->pain = jorg_pain;
    self->die = jorg_die;
    self->monsterinfo.stand = jorg_stand;
    self->monsterinfo.walk = jorg_walk;
    self->monsterinfo.run = jorg_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = jorg_attack;
    self->monsterinfo.search = jorg_search;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = NULL;
    self->monsterinfo.checkattack = Jorg_CheckAttack;
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &jorg_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_medic()

void SP_monster_medic

(

edict_t *

self

)

Definition at line 686 of file m_medic.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_idle1 = gi.soundindex("medic/idle.wav");
    sound_pain1 = gi.soundindex("medic/medpain1.wav");
    sound_pain2 = gi.soundindex("medic/medpain2.wav");
    sound_die = gi.soundindex("medic/meddeth1.wav");
    sound_sight = gi.soundindex("medic/medsght1.wav");
    sound_search = gi.soundindex("medic/medsrch1.wav");
    sound_hook_launch = gi.soundindex("medic/medatck2.wav");
    sound_hook_hit = gi.soundindex("medic/medatck3.wav");
    sound_hook_heal = gi.soundindex("medic/medatck4.wav");
    sound_hook_retract = gi.soundindex("medic/medatck5.wav");
 
    gi.soundindex("medic/medatck1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/medic/tris.md2");
    VectorSet(self->mins, -24, -24, -24);
    VectorSet(self->maxs, 24, 24, 32);
 
    self->health = 300;
    self->gib_health = -130;
    self->mass = 400;
 
    self->pain = medic_pain;
    self->die = medic_die;
 
    self->monsterinfo.stand = medic_stand;
    self->monsterinfo.walk = medic_walk;
    self->monsterinfo.run = medic_run;
    self->monsterinfo.dodge = medic_dodge;
    self->monsterinfo.attack = medic_attack;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = medic_sight;
    self->monsterinfo.idle = medic_idle;
    self->monsterinfo.search = medic_search;
    self->monsterinfo.checkattack = medic_checkattack;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &medic_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_mutant()

void SP_monster_mutant

(

edict_t *

self

)

Definition at line 582 of file m_mutant.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_swing = gi.soundindex("mutant/mutatck1.wav");
    sound_hit = gi.soundindex("mutant/mutatck2.wav");
    sound_hit2 = gi.soundindex("mutant/mutatck3.wav");
    sound_death = gi.soundindex("mutant/mutdeth1.wav");
    sound_idle = gi.soundindex("mutant/mutidle1.wav");
    sound_pain1 = gi.soundindex("mutant/mutpain1.wav");
    sound_pain2 = gi.soundindex("mutant/mutpain2.wav");
    sound_sight = gi.soundindex("mutant/mutsght1.wav");
    sound_search = gi.soundindex("mutant/mutsrch1.wav");
    sound_step1 = gi.soundindex("mutant/step1.wav");
    sound_step2 = gi.soundindex("mutant/step2.wav");
    sound_step3 = gi.soundindex("mutant/step3.wav");
    sound_thud = gi.soundindex("mutant/thud1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/mutant/tris.md2");
    VectorSet(self->mins, -32, -32, -24);
    VectorSet(self->maxs, 32, 32, 48);
 
    self->health = 300;
    self->gib_health = -120;
    self->mass = 300;
 
    self->pain = mutant_pain;
    self->die = mutant_die;
 
    self->monsterinfo.stand = mutant_stand;
    self->monsterinfo.walk = mutant_walk;
    self->monsterinfo.run = mutant_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = mutant_jump;
    self->monsterinfo.melee = mutant_melee;
    self->monsterinfo.sight = mutant_sight;
    self->monsterinfo.search = mutant_search;
    self->monsterinfo.idle = mutant_idle;
    self->monsterinfo.checkattack = mutant_checkattack;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &mutant_move_stand;
 
    self->monsterinfo.scale = MODEL_SCALE;
    walkmonster_start(self);
}

SP_monster_parasite()

void SP_monster_parasite

(

edict_t *

self

)

Definition at line 484 of file m_parasite.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("parasite/parpain1.wav");
    sound_pain2 = gi.soundindex("parasite/parpain2.wav");
    sound_die = gi.soundindex("parasite/pardeth1.wav");
    sound_launch = gi.soundindex("parasite/paratck1.wav");
    sound_impact = gi.soundindex("parasite/paratck2.wav");
    sound_suck = gi.soundindex("parasite/paratck3.wav");
    sound_reelin = gi.soundindex("parasite/paratck4.wav");
    sound_sight = gi.soundindex("parasite/parsght1.wav");
    sound_tap = gi.soundindex("parasite/paridle1.wav");
    sound_scratch = gi.soundindex("parasite/paridle2.wav");
    sound_search = gi.soundindex("parasite/parsrch1.wav");
 
    self->s.modelindex = gi.modelindex("models/monsters/parasite/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 24);
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
 
    self->health = 175;
    self->gib_health = -50;
    self->mass = 250;
 
    self->pain = parasite_pain;
    self->die = parasite_die;
 
    self->monsterinfo.stand = parasite_stand;
    self->monsterinfo.walk = parasite_start_walk;
    self->monsterinfo.run = parasite_start_run;
    self->monsterinfo.attack = parasite_attack;
    self->monsterinfo.sight = parasite_sight;
    self->monsterinfo.idle = parasite_idle;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &parasite_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_soldier()

void SP_monster_soldier

(

edict_t *

self

)

Definition at line 1211 of file m_soldier.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    SP_monster_soldier_x(self);
 
    sound_pain = gi.soundindex("soldier/solpain1.wav");
    sound_death = gi.soundindex("soldier/soldeth1.wav");
    gi.soundindex("soldier/solatck1.wav");
 
    self->s.skinnum = 2;
    self->health = 30;
    self->gib_health = -30;
}

SP_monster_soldier_light()

void SP_monster_soldier_light

(

edict_t *

self

)

Definition at line 1189 of file m_soldier.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    SP_monster_soldier_x(self);
 
    sound_pain_light = gi.soundindex("soldier/solpain2.wav");
    sound_death_light = gi.soundindex("soldier/soldeth2.wav");
    gi.modelindex("models/objects/laser/tris.md2");
    gi.soundindex("misc/lasfly.wav");
    gi.soundindex("soldier/solatck2.wav");
 
    self->s.skinnum = 0;
    self->health = 20;
    self->gib_health = -30;
}

SP_monster_soldier_ss()

void SP_monster_soldier_ss

(

edict_t *

self

)

Definition at line 1231 of file m_soldier.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    SP_monster_soldier_x(self);
 
    sound_pain_ss = gi.soundindex("soldier/solpain3.wav");
    sound_death_ss = gi.soundindex("soldier/soldeth3.wav");
    gi.soundindex("soldier/solatck3.wav");
 
    self->s.skinnum = 4;
    self->health = 40;
    self->gib_health = -30;
}

SP_monster_supertank()

void SP_monster_supertank

(

edict_t *

self

)

Definition at line 646 of file m_supertank.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    sound_pain1 = gi.soundindex("bosstank/btkpain1.wav");
    sound_pain2 = gi.soundindex("bosstank/btkpain2.wav");
    sound_pain3 = gi.soundindex("bosstank/btkpain3.wav");
    sound_death = gi.soundindex("bosstank/btkdeth1.wav");
    sound_search1 = gi.soundindex("bosstank/btkunqv1.wav");
    sound_search2 = gi.soundindex("bosstank/btkunqv2.wav");
 
//  self->s.sound = gi.soundindex ("bosstank/btkengn1.wav");
    tread_sound = gi.soundindex("bosstank/btkengn1.wav");
 
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/boss1/tris.md2");
    VectorSet(self->mins, -64, -64, 0);
    VectorSet(self->maxs, 64, 64, 112);
 
    self->health = 1500;
    self->gib_health = -500;
    self->mass = 800;
 
    self->pain = supertank_pain;
    self->die = supertank_die;
    self->monsterinfo.stand = supertank_stand;
    self->monsterinfo.walk = supertank_walk;
    self->monsterinfo.run = supertank_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = supertank_attack;
    self->monsterinfo.search = supertank_search;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = NULL;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &supertank_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
}

SP_monster_tank()

void SP_monster_tank

(

edict_t *

self

)

Definition at line 752 of file m_tank.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    self->s.modelindex = gi.modelindex("models/monsters/tank/tris.md2");
    VectorSet(self->mins, -32, -32, -16);
    VectorSet(self->maxs, 32, 32, 72);
    self->movetype = MOVETYPE_STEP;
    self->solid = SOLID_BBOX;
 
    sound_pain = gi.soundindex("tank/tnkpain2.wav");
    sound_thud = gi.soundindex("tank/tnkdeth2.wav");
    sound_idle = gi.soundindex("tank/tnkidle1.wav");
    sound_die = gi.soundindex("tank/death.wav");
    sound_step = gi.soundindex("tank/step.wav");
    sound_windup = gi.soundindex("tank/tnkatck4.wav");
    sound_strike = gi.soundindex("tank/tnkatck5.wav");
    sound_sight = gi.soundindex("tank/sight1.wav");
 
    gi.soundindex("tank/tnkatck1.wav");
    gi.soundindex("tank/tnkatk2a.wav");
    gi.soundindex("tank/tnkatk2b.wav");
    gi.soundindex("tank/tnkatk2c.wav");
    gi.soundindex("tank/tnkatk2d.wav");
    gi.soundindex("tank/tnkatk2e.wav");
    gi.soundindex("tank/tnkatck3.wav");
 
    if (strcmp(self->classname, "monster_tank_commander") == 0) {
        self->health = 1000;
        self->gib_health = -225;
    } else {
        self->health = 750;
        self->gib_health = -200;
    }
 
    self->mass = 500;
 
    self->pain = tank_pain;
    self->die = tank_die;
    self->monsterinfo.stand = tank_stand;
    self->monsterinfo.walk = tank_walk;
    self->monsterinfo.run = tank_run;
    self->monsterinfo.dodge = NULL;
    self->monsterinfo.attack = tank_attack;
    self->monsterinfo.melee = NULL;
    self->monsterinfo.sight = tank_sight;
    self->monsterinfo.idle = tank_idle;
 
    gi.linkentity(self);
 
    self->monsterinfo.currentmove = &tank_move_stand;
    self->monsterinfo.scale = MODEL_SCALE;
 
    walkmonster_start(self);
 
    if (strcmp(self->classname, "monster_tank_commander") == 0)
        self->s.skinnum = 2;
}

SP_path_corner()

void SP_path_corner

(

edict_t *

self

)

Definition at line 376 of file g_misc.c.

{
    if (!self->targetname) {
        gi.dprintf("path_corner with no targetname at %s\n", vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    self->solid = SOLID_TRIGGER;
    self->touch = path_corner_touch;
    VectorSet(self->mins, -8, -8, -8);
    VectorSet(self->maxs, 8, 8, 8);
    self->svflags |= SVF_NOCLIENT;
    gi.linkentity(self);
}

SP_point_combat()

void SP_point_combat

(

edict_t *

self

)

Definition at line 444 of file g_misc.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
    self->solid = SOLID_TRIGGER;
    self->touch = point_combat_touch;
    VectorSet(self->mins, -8, -8, -16);
    VectorSet(self->maxs, 8, 8, 16);
    self->svflags = SVF_NOCLIENT;
    gi.linkentity(self);
}

SP_target_actor()

void SP_target_actor

(

edict_t *

ent

)

Definition at line 541 of file m_actor.c.

{
    if (!self->targetname)
        gi.dprintf("%s with no targetname at %s\n", self->classname, vtos(self->s.origin));
 
    self->solid = SOLID_TRIGGER;
    self->touch = target_actor_touch;
    VectorSet(self->mins, -8, -8, -8);
    VectorSet(self->maxs, 8, 8, 8);
    self->svflags = SVF_NOCLIENT;
 
    if (self->spawnflags & 1) {
        if (!self->speed)
            self->speed = 200;
        if (!st.height)
            st.height = 200;
        if (self->s.angles[YAW] == 0)
            self->s.angles[YAW] = 360;
        G_SetMovedir(self->s.angles, self->movedir);
        self->movedir[2] = st.height;
    }
 
    gi.linkentity(self);
}

SP_target_blaster()

void SP_target_blaster

(

edict_t *

ent

)

Definition at line 422 of file g_target.c.

{
    self->use = use_target_blaster;
    G_SetMovedir(self->s.angles, self->movedir);
    self->noise_index = gi.soundindex("weapons/laser2.wav");
 
    if (!self->dmg)
        self->dmg = 15;
    if (!self->speed)
        self->speed = 1000;
 
    self->svflags = SVF_NOCLIENT;
}

SP_target_changelevel()

void SP_target_changelevel

(

edict_t *

ent

)

Definition at line 293 of file g_target.c.

{
    if (!ent->map) {
        gi.dprintf("target_changelevel with no map at %s\n", vtos(ent->s.origin));
        G_FreeEdict(ent);
        return;
    }
 
    // ugly hack because *SOMEBODY* screwed up their map
    if ((Q_stricmp(level.mapname, "fact1") == 0) && (Q_stricmp(ent->map, "fact3") == 0))
        ent->map = "fact3$secret1";
 
    ent->use = use_target_changelevel;
    ent->svflags = SVF_NOCLIENT;
}

SP_target_character()

void SP_target_character

(

edict_t *

ent

)

Definition at line 1501 of file g_misc.c.

{
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel(self, self->model);
    self->solid = SOLID_BSP;
    self->s.frame = 12;
    gi.linkentity(self);
    return;
}

SP_target_crosslevel_target()

void SP_target_crosslevel_target

(

edict_t *

ent

)

Definition at line 468 of file g_target.c.

{
    if (! self->delay)
        self->delay = 1;
    self->svflags = SVF_NOCLIENT;
 
    self->think = target_crosslevel_target_think;
    self->nextthink = level.time + self->delay;
}

SP_target_crosslevel_trigger()

void SP_target_crosslevel_trigger

(

edict_t *

ent

)

Definition at line 448 of file g_target.c.

{
    self->svflags = SVF_NOCLIENT;
    self->use = trigger_crosslevel_trigger_use;
}

SP_target_earthquake()

void SP_target_earthquake

(

edict_t *

ent

)

Definition at line 761 of file g_target.c.

{
    if (!self->targetname)
        gi.dprintf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));
 
    if (!self->count)
        self->count = 5;
 
    if (!self->speed)
        self->speed = 200;
 
    self->svflags |= SVF_NOCLIENT;
    self->think = target_earthquake_think;
    self->use = target_earthquake_use;
 
    self->noise_index = gi.soundindex("world/quake.wav");
}

SP_target_explosion()

void SP_target_explosion

(

edict_t *

ent

)

Definition at line 252 of file g_target.c.

{
    ent->use = use_target_explosion;
    ent->svflags = SVF_NOCLIENT;
}

SP_target_goal()

void SP_target_goal

(

edict_t *

ent

)

Definition at line 197 of file g_target.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(ent);
        return;
    }
 
    ent->use = use_target_goal;
    if (!st.noise)
        st.noise = "misc/secret.wav";
    ent->noise_index = gi.soundindex(st.noise);
    ent->svflags = SVF_NOCLIENT;
    level.total_goals++;
}

SP_target_help()

void SP_target_help

(

edict_t *

ent

)

Definition at line 127 of file g_target.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(ent);
        return;
    }
 
    if (!ent->message) {
        gi.dprintf("%s with no message at %s\n", ent->classname, vtos(ent->s.origin));
        G_FreeEdict(ent);
        return;
    }
    ent->use = Use_Target_Help;
}

SP_target_laser()

void SP_target_laser

(

edict_t *

self

)

Definition at line 624 of file g_target.c.

{
    // let everything else get spawned before we start firing
    self->think = target_laser_start;
    self->nextthink = level.time + 1;
}

SP_target_lightramp()

void SP_target_lightramp

(

edict_t *

self

)

Definition at line 688 of file g_target.c.

{
    if (!self->message || strlen(self->message) != 2 || self->message[0] < 'a' || self->message[0] > 'z' || self->message[1] < 'a' || self->message[1] > 'z' || self->message[0] == self->message[1]) {
        gi.dprintf("target_lightramp has bad ramp (%s) at %s\n", self->message, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    if (!self->target) {
        gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    self->svflags |= SVF_NOCLIENT;
    self->use = target_lightramp_use;
    self->think = target_lightramp_think;
 
    self->movedir[0] = self->message[0] - 'a';
    self->movedir[1] = self->message[1] - 'a';
    self->movedir[2] = (self->movedir[1] - self->movedir[0]) / (self->speed / FRAMETIME);
}

SP_target_secret()

void SP_target_secret

(

edict_t *

ent

)

Definition at line 159 of file g_target.c.

{
    if (deathmatch->value) {
        // auto-remove for deathmatch
        G_FreeEdict(ent);
        return;
    }
 
    ent->use = use_target_secret;
    if (!st.noise)
        st.noise = "misc/secret.wav";
    ent->noise_index = gi.soundindex(st.noise);
    ent->svflags = SVF_NOCLIENT;
    level.total_secrets++;
    // map bug hack
    if (!Q_stricmp(level.mapname, "mine3") && ent->s.origin[0] == 280 && ent->s.origin[1] == -2048 && ent->s.origin[2] == -624)
        ent->message = "You have found a secret area.";
}

SP_target_spawner()

void SP_target_spawner

(

edict_t *

ent

)

Definition at line 386 of file g_target.c.

{
    self->use = use_target_spawner;
    self->svflags = SVF_NOCLIENT;
    if (self->speed) {
        G_SetMovedir(self->s.angles, self->movedir);
        VectorScale(self->movedir, self->speed, self->movedir);
    }
}

SP_target_speaker()

void SP_target_speaker

(

edict_t *

ent

)

Definition at line 78 of file g_target.c.

{
    char    buffer[MAX_QPATH];
 
    if (!st.noise) {
        gi.dprintf("target_speaker with no noise set at %s\n", vtos(ent->s.origin));
        return;
    }
    if (!strstr(st.noise, ".wav"))
        Q_snprintf(buffer, sizeof(buffer), "%s.wav", st.noise);
    else
        strncpy(buffer, st.noise, sizeof(buffer));
    ent->noise_index = gi.soundindex(buffer);
 
    if (!ent->volume)
        ent->volume = 1.0;
 
    if (!ent->attenuation)
        ent->attenuation = 1.0;
    else if (ent->attenuation == -1)    // use -1 so 0 defaults to 1
        ent->attenuation = 0;
 
    // check for prestarted looping sound
    if (ent->spawnflags & 1)
        ent->s.sound = ent->noise_index;
 
    ent->use = Use_Target_Speaker;
 
    // must link the entity so we get areas and clusters so
    // the server can determine who to send updates to
    gi.linkentity(ent);
}

SP_target_splash()

void SP_target_splash

(

edict_t *

ent

)

Definition at line 342 of file g_target.c.

{
    self->use = use_target_splash;
    G_SetMovedir(self->s.angles, self->movedir);
 
    if (!self->count)
        self->count = 32;
 
    self->svflags = SVF_NOCLIENT;
}

SP_target_string()

void SP_target_string

(

edict_t *

ent

)

Definition at line 1543 of file g_misc.c.

{
    if (!self->message)
        self->message = "";
    self->use = target_string_use;
}

SP_target_temp_entity()

void SP_target_temp_entity

(

edict_t *

ent

)

Definition at line 32 of file g_target.c.

{
    ent->use = Use_Target_Tent;
}

SP_trigger_always()

void SP_trigger_always

(

edict_t *

ent

)

Definition at line 344 of file g_trigger.c.

{
    // we must have some delay to make sure our use targets are present
    if (ent->delay < 0.2)
        ent->delay = 0.2;
    G_UseTargets(ent, ent);
}

SP_trigger_counter()

void SP_trigger_counter

(

edict_t *

ent

)

Definition at line 323 of file g_trigger.c.

{
    self->wait = -1;
    if (!self->count)
        self->count = 2;
 
    self->use = trigger_counter_use;
}

SP_trigger_elevator()

void SP_trigger_elevator

(

edict_t *

ent

)

Definition at line 1648 of file g_func.c.

{
    self->think = trigger_elevator_init;
    self->nextthink = level.time + FRAMETIME;
}

SP_trigger_gravity()

void SP_trigger_gravity

(

edict_t *

ent

)

Definition at line 502 of file g_trigger.c.

{
    if (st.gravity == 0) {
        gi.dprintf("trigger_gravity without gravity set at %s\n", vtos(self->s.origin));
        G_FreeEdict(self);
        return;
    }
 
    InitTrigger(self);
    self->gravity = atoi(st.gravity);
    self->touch = trigger_gravity_touch;
}

SP_trigger_hurt()

void SP_trigger_hurt

(

edict_t *

ent

)

Definition at line 461 of file g_trigger.c.

{
    InitTrigger(self);
 
    self->noise_index = gi.soundindex("world/electro.wav");
    self->touch = hurt_touch;
 
    if (!self->dmg)
        self->dmg = 5;
 
    if (self->spawnflags & 1)
        self->solid = SOLID_NOT;
    else
        self->solid = SOLID_TRIGGER;
 
    if (self->spawnflags & 2)
        self->use = hurt_use;
 
    gi.linkentity(self);
}

SP_trigger_key()

void SP_trigger_key

(

edict_t *

ent

)

Definition at line 259 of file g_trigger.c.

{
    if (!st.item) {
        gi.dprintf("no key item for trigger_key at %s\n", vtos(self->s.origin));
        return;
    }
    self->item = FindItemByClassname(st.item);
 
    if (!self->item) {
        gi.dprintf("item %s not found for trigger_key at %s\n", st.item, vtos(self->s.origin));
        return;
    }
 
    if (!self->target) {
        gi.dprintf("%s at %s has no target\n", self->classname, vtos(self->s.origin));
        return;
    }
 
    gi.soundindex("misc/keytry.wav");
    gi.soundindex("misc/keyuse.wav");
 
    self->use = trigger_key_use;
}

SP_trigger_monsterjump()

void SP_trigger_monsterjump

(

edict_t *

ent

)

Definition at line 550 of file g_trigger.c.

{
    if (!self->speed)
        self->speed = 200;
    if (!st.height)
        st.height = 200;
    if (self->s.angles[YAW] == 0)
        self->s.angles[YAW] = 360;
    InitTrigger(self);
    self->touch = trigger_monsterjump_touch;
    self->movedir[2] = st.height;
}

SP_trigger_multiple()

void SP_trigger_multiple

(

edict_t *

ent

)

Definition at line 109 of file g_trigger.c.

{
    if (ent->sounds == 1)
        ent->noise_index = gi.soundindex("misc/secret.wav");
    else if (ent->sounds == 2)
        ent->noise_index = gi.soundindex("misc/talk.wav");
    else if (ent->sounds == 3)
        ent->noise_index = gi.soundindex("misc/trigger1.wav");
 
    if (!ent->wait)
        ent->wait = 0.2;
    ent->touch = Touch_Multi;
    ent->movetype = MOVETYPE_NONE;
    ent->svflags |= SVF_NOCLIENT;
 
 
    if (ent->spawnflags & 4) {
        ent->solid = SOLID_NOT;
        ent->use = trigger_enable;
    } else {
        ent->solid = SOLID_TRIGGER;
        ent->use = Use_Multi;
    }
 
    if (!VectorCompare(ent->s.angles, vec3_origin))
        G_SetMovedir(ent->s.angles, ent->movedir);
 
    gi.setmodel(ent, ent->model);
    gi.linkentity(ent);
}

Referenced by SP_trigger_once().

SP_trigger_once()

void SP_trigger_once

(

edict_t *

ent

)

Definition at line 156 of file g_trigger.c.

{
    // make old maps work because I messed up on flag assignments here
    // triggered was on bit 1 when it should have been on bit 4
    if (ent->spawnflags & 1) {
        vec3_t  v;
 
        VectorMA(ent->mins, 0.5, ent->size, v);
        ent->spawnflags &= ~1;
        ent->spawnflags |= 4;
        gi.dprintf("fixed TRIGGERED flag on %s at %s\n", ent->classname, vtos(v));
    }
 
    ent->wait = -1;
    SP_trigger_multiple(ent);
}

SP_trigger_push()

void SP_trigger_push

(

edict_t *

ent

)

Definition at line 390 of file g_trigger.c.

{
    InitTrigger(self);
    windsound = gi.soundindex("misc/windfly.wav");
    self->touch = trigger_push_touch;
    if (!self->speed)
        self->speed = 1000;
    gi.linkentity(self);
}

SP_trigger_relay()

void SP_trigger_relay

(

edict_t *

ent

)

Definition at line 181 of file g_trigger.c.

{
    self->use = trigger_relay_use;
}

SP_turret_base()

void SP_turret_base

(

edict_t *

self

)

Definition at line 250 of file g_turret.c.

{
    self->solid = SOLID_BSP;
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel(self, self->model);
    self->blocked = turret_blocked;
    gi.linkentity(self);
}

SP_turret_breach()

void SP_turret_breach

(

edict_t *

self

)

Definition at line 211 of file g_turret.c.

{
    self->solid = SOLID_BSP;
    self->movetype = MOVETYPE_PUSH;
    gi.setmodel(self, self->model);
 
    if (!self->speed)
        self->speed = 50;
    if (!self->dmg)
        self->dmg = 10;
 
    if (!st.minpitch)
        st.minpitch = -30;
    if (!st.maxpitch)
        st.maxpitch = 30;
    if (!st.maxyaw)
        st.maxyaw = 360;
 
    self->pos1[PITCH] = -1 * st.minpitch;
    self->pos1[YAW]   = st.minyaw;
    self->pos2[PITCH] = -1 * st.maxpitch;
    self->pos2[YAW]   = st.maxyaw;
 
    self->ideal_yaw = self->s.angles[YAW];
    self->move_angles[YAW] = self->ideal_yaw;
 
    self->blocked = turret_blocked;
 
    self->think = turret_breach_finish_init;
    self->nextthink = level.time + FRAMETIME;
    gi.linkentity(self);
}

SP_turret_driver()

void SP_turret_driver

(

edict_t *

self

)

Definition at line 371 of file g_turret.c.

{
    if (deathmatch->value) {
        G_FreeEdict(self);
        return;
    }
 
    self->movetype = MOVETYPE_PUSH;
    self->solid = SOLID_BBOX;
    self->s.modelindex = gi.modelindex("models/monsters/infantry/tris.md2");
    VectorSet(self->mins, -16, -16, -24);
    VectorSet(self->maxs, 16, 16, 32);
 
    self->health = 100;
    self->gib_health = 0;
    self->mass = 200;
    self->viewheight = 24;
 
    self->die = turret_driver_die;
    self->monsterinfo.stand = infantry_stand;
 
    self->flags |= FL_NO_KNOCKBACK;
 
    level.total_monsters++;
 
    self->svflags |= SVF_MONSTER;
    self->s.renderfx |= RF_FRAMELERP;
    self->takedamage = DAMAGE_AIM;
    self->use = monster_use;
    self->clipmask = MASK_MONSTERSOLID;
    VectorCopy(self->s.origin, self->s.old_origin);
    self->monsterinfo.aiflags |= AI_STAND_GROUND | AI_DUCKED;
 
    if (st.item) {
        self->item = FindItemByClassname(st.item);
        if (!self->item)
            gi.dprintf("%s at %s has bad item: %s\n", self->classname, vtos(self->s.origin), st.item);
    }
 
    self->think = turret_driver_link;
    self->nextthink = level.time + FRAMETIME;
 
    gi.linkentity(self);
}

SP_viewthing()

void SP_viewthing

(

edict_t *

ent

)

Definition at line 468 of file g_misc.c.

{
    gi.dprintf("viewthing spawned\n");
 
    ent->movetype = MOVETYPE_NONE;
    ent->solid = SOLID_BBOX;
    ent->s.renderfx = RF_FRAMELERP;
    VectorSet(ent->mins, -16, -16, -24);
    VectorSet(ent->maxs, 16, 16, 32);
    ent->s.modelindex = gi.modelindex("models/objects/banner/tris.md2");
    gi.linkentity(ent);
    ent->nextthink = level.time + 0.5;
    ent->think = TH_viewthing;
    return;
}

SP_worldspawn()

void SP_worldspawn

(

edict_t *

ent

)

Definition at line 842 of file g_spawn.c.

{
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_BSP;
    ent->inuse = qtrue;          // 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");
}

SpawnEntities()

void SpawnEntities	(	const char *	mapname,
		const char *	entities,
		const char *	spawnpoint
	)

Definition at line 568 of file g_spawn.c.

{
    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();
        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 (nomonsters->value && (strstr(ent->classname, "monster") || strstr(ent->classname, "misc_deadsoldier") || strstr(ent->classname, "misc_insane"))) {
                G_FreeEdict(ent);
                inhibit++;
                continue;
            }
            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();
}

Referenced by GetGameAPI().

Variable Documentation

dm_statusbar

const char dm_statusbar[]

static

Definition at line 752 of file g_spawn.c.

Referenced by SP_worldspawn().

single_statusbar

const char single_statusbar[]

static

Definition at line 694 of file g_spawn.c.

Referenced by SP_worldspawn().

spawn_fields

const spawn_field_t spawn_fields[]

static

Definition at line 273 of file g_spawn.c.

Referenced by ED_ParseEdict().

spawn_funcs

const spawn_func_t spawn_funcs[]

static

Definition at line 150 of file g_spawn.c.

Referenced by ED_CallSpawn().

temp_fields

const spawn_field_t temp_fields[]

static

Initial value:

= {
    {"lip", STOFS(lip), F_INT},
    {"distance", STOFS(distance), F_INT},
    {"height", STOFS(height), F_INT},
    {"noise", STOFS(noise), F_LSTRING},
    {"pausetime", STOFS(pausetime), F_FLOAT},
    {"item", STOFS(item), F_LSTRING},
 
    {"gravity", STOFS(gravity), F_LSTRING},
    {"sky", STOFS(sky), F_LSTRING},
    {"skyrotate", STOFS(skyrotate), F_FLOAT},
    {"skyaxis", STOFS(skyaxis), F_VECTOR},
    {"minyaw", STOFS(minyaw), F_FLOAT},
    {"maxyaw", STOFS(maxyaw), F_FLOAT},
    {"minpitch", STOFS(minpitch), F_FLOAT},
    {"maxpitch", STOFS(maxpitch), F_FLOAT},
    {"nextmap", STOFS(nextmap), F_LSTRING},
 
    {NULL}
}

Definition at line 311 of file g_spawn.c.

Referenced by ED_ParseEdict().