g_spawn.c File Reference

#include "g_local.h"

Go to the source code of this file.

Classes
struct	spawn_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)
char *	ED_NewString (char *string)
void	ED_ParseField (char *key, char *value, edict_t *ent)
char *	ED_ParseEdict (char *data, edict_t *ent)
void	G_FindTeams (void)
void	SpawnEntities (char *mapname, char *entities, char *spawnpoint)

Variables
spawn_t	spawns []
char *	single_statusbar
char *	dm_statusbar

Function Documentation

ED_CallSpawn()

void ED_CallSpawn

(

edict_t *

ent

)

Definition at line 278 of file g_spawn.c.

{
    spawn_t *s;
    gitem_t *item;
    int     i;
 
    if (!ent->classname)
    {
        gi.dprintf ("ED_CallSpawn: NULL classname\n");
        return;
    }
 
    // check item spawn functions
    for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
    {
        if (!item->classname)
            continue;
        if (!strcmp(item->classname, ent->classname))
        {   // found it
            SpawnItem (ent, item);
            return;
        }
    }
 
    // check normal spawn functions
    for (s=spawns ; s->name ; s++)
    {
        if (!strcmp(s->name, ent->classname))
        {   // found it
            s->spawn (ent);
            return;
        }
    }
    gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
}

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

ED_NewString()

char* ED_NewString

(

char *

string

)

Definition at line 319 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()

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

Definition at line 416 of file g_spawn.c.

{
    qboolean    init;
    char        keyname[256];
    char        *com_token;
 
    init = false;
    memset (&st, 0, sizeof(st));
 
// go through all the dictionary pairs
    while (1)
    {   
    // parse key
        com_token = COM_Parse (&data);
        if (com_token[0] == '}')
            break;
        if (!data)
            gi.error ("ED_ParseEntity: EOF without closing brace");
 
        strncpy (keyname, com_token, sizeof(keyname)-1);
        
    // parse value  
        com_token = COM_Parse (&data);
        if (!data)
            gi.error ("ED_ParseEntity: EOF without closing brace");
 
        if (com_token[0] == '}')
            gi.error ("ED_ParseEntity: closing brace without data");
 
        init = true;    
 
    // keynames with a leading underscore are used for utility comments,
    // and are immediately discarded by quake
        if (keyname[0] == '_')
            continue;
 
        ED_ParseField (keyname, com_token, ent);
    }
 
    if (!init)
        memset (ent, 0, sizeof(*ent));
 
    return data;
}

Referenced by SpawnEntities().

ED_ParseField()

void ED_ParseField	(	char *	key,
		char *	value,
		edict_t *	ent
	)

Definition at line 358 of file g_spawn.c.

{
    field_t *f;
    byte    *b;
    float   v;
    vec3_t  vec;
 
    for (f=fields ; f->name ; f++)
    {
        if (!(f->flags & FFL_NOSPAWN) && !Q_stricmp(f->name, key))
        {   // found it
            if (f->flags & FFL_SPAWNTEMP)
                b = (byte *)&st;
            else
                b = (byte *)ent;
 
            switch (f->type)
            {
            case F_LSTRING:
                *(char **)(b+f->ofs) = ED_NewString (value);
                break;
            case F_VECTOR:
                sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
                ((float *)(b+f->ofs))[0] = vec[0];
                ((float *)(b+f->ofs))[1] = vec[1];
                ((float *)(b+f->ofs))[2] = vec[2];
                break;
            case F_INT:
                *(int *)(b+f->ofs) = atoi(value);
                break;
            case F_FLOAT:
                *(float *)(b+f->ofs) = atof(value);
                break;
            case F_ANGLEHACK:
                v = atof(value);
                ((float *)(b+f->ofs))[0] = 0;
                ((float *)(b+f->ofs))[1] = v;
                ((float *)(b+f->ofs))[2] = 0;
                break;
            case F_IGNORE:
                break;
            default:
                break;
            }
            return;
        }
    }
    gi.dprintf ("%s is not a field\n", key);
}

Referenced by ED_ParseEdict().

G_FindTeams()

void G_FindTeams

(

void

)

Definition at line 472 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 44 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 763 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 1750 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 1842 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 1138 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 1261 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 1966 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 823 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 2042 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 692 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 513 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 623 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 1795 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 1654 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 612 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 1378 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 528 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 519 of file g_misc.c.

{
    G_FreeEdict (self);
}

SP_info_player_coop()

void SP_info_player_coop

(

edict_t *

ent

)

Definition at line 137 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 123 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 108 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 2121 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 2154 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 2170 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 2137 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 559 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 1473 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 1484 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 425 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 1202 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 1316 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 1043 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 1230 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 1099 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 1127 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 1071 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 974 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 1496 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 1538 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 1517 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 623 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 1459 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 1415 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 1832 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 1868 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 1285 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 1378 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 413 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 636 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 53 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 621 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 628 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 1170 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 361 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 611 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 573 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 339 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 581 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 573 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 556 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 696 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 718 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 611 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 506 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 1261 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 1238 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 1282 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 672 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 792 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 399 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 474 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 585 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 431 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 302 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 1563 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 478 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 457 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 793 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 258 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 202 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 131 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 642 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 715 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 164 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 396 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 81 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"))
        Com_sprintf (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 352 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 1607 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 34 of file g_target.c.

{
    ent->use = Use_Target_Tent;
}

SP_trigger_always()

void SP_trigger_always

(

edict_t *

ent

)

Definition at line 373 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 352 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 1750 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 537 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 496 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 282 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 586 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 118 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 168 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 424 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 194 of file g_trigger.c.

{
    self->use = trigger_relay_use;
}

SP_turret_base()

void SP_turret_base

(

edict_t *

self

)

Definition at line 259 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 220 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 387 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 499 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 798 of file g_spawn.c.

{
    ent->movetype = MOVETYPE_PUSH;
    ent->solid = SOLID_BSP;
    ent->inuse = true;          // since the world doesn't use G_Spawn()
    ent->s.modelindex = 1;      // world model is always index 1
 
    //---------------
 
    // reserve some spots for dead player bodies for coop / deathmatch
    InitBodyQue ();
 
    // set configstrings for items
    SetItemNames ();
 
    if (st.nextmap)
        strcpy (level.nextmap, st.nextmap);
 
    // make some data visible to the server
 
    if (ent->message && ent->message[0])
    {
        gi.configstring (CS_NAME, ent->message);
        strncpy (level.level_name, ent->message, sizeof(level.level_name));
    }
    else
        strncpy (level.level_name, level.mapname, sizeof(level.level_name));
 
    if (st.sky && st.sky[0])
        gi.configstring (CS_SKY, st.sky);
    else
        gi.configstring (CS_SKY, "unit1_");
 
    gi.configstring (CS_SKYROTATE, va("%f", st.skyrotate) );
 
    gi.configstring (CS_SKYAXIS, va("%f %f %f",
        st.skyaxis[0], st.skyaxis[1], st.skyaxis[2]) );
 
    gi.configstring (CS_CDTRACK, va("%i", ent->sounds) );
 
    gi.configstring (CS_MAXCLIENTS, va("%i", (int)(maxclients->value) ) );
 
    // status bar program
    if (deathmatch->value)
        gi.configstring (CS_STATUSBAR, dm_statusbar);
    else
        gi.configstring (CS_STATUSBAR, single_statusbar);
 
    //---------------
 
 
    // help icon for statusbar
    gi.imageindex ("i_help");
    level.pic_health = gi.imageindex ("i_health");
    gi.imageindex ("help");
    gi.imageindex ("field_3");
 
    if (!st.gravity)
        gi.cvar_set("sv_gravity", "800");
    else
        gi.cvar_set("sv_gravity", st.gravity);
 
    snd_fry = gi.soundindex ("player/fry.wav"); // standing in lava / slime
 
    PrecacheItem (FindItem ("Blaster"));
 
    gi.soundindex ("player/lava1.wav");
    gi.soundindex ("player/lava2.wav");
 
    gi.soundindex ("misc/pc_up.wav");
    gi.soundindex ("misc/talk1.wav");
 
    gi.soundindex ("misc/udeath.wav");
 
    // gibs
    gi.soundindex ("items/respawn1.wav");
 
    // sexed sounds
    gi.soundindex ("*death1.wav");
    gi.soundindex ("*death2.wav");
    gi.soundindex ("*death3.wav");
    gi.soundindex ("*death4.wav");
    gi.soundindex ("*fall1.wav");
    gi.soundindex ("*fall2.wav");   
    gi.soundindex ("*gurp1.wav");       // drowning damage
    gi.soundindex ("*gurp2.wav");   
    gi.soundindex ("*jump1.wav");       // player jump
    gi.soundindex ("*pain25_1.wav");
    gi.soundindex ("*pain25_2.wav");
    gi.soundindex ("*pain50_1.wav");
    gi.soundindex ("*pain50_2.wav");
    gi.soundindex ("*pain75_1.wav");
    gi.soundindex ("*pain75_2.wav");
    gi.soundindex ("*pain100_1.wav");
    gi.soundindex ("*pain100_2.wav");
 
    // sexed models
    // THIS ORDER MUST MATCH THE DEFINES IN g_local.h
    // you can add more, max 15
    gi.modelindex ("#w_blaster.md2");
    gi.modelindex ("#w_shotgun.md2");
    gi.modelindex ("#w_sshotgun.md2");
    gi.modelindex ("#w_machinegun.md2");
    gi.modelindex ("#w_chaingun.md2");
    gi.modelindex ("#a_grenades.md2");
    gi.modelindex ("#w_glauncher.md2");
    gi.modelindex ("#w_rlauncher.md2");
    gi.modelindex ("#w_hyperblaster.md2");
    gi.modelindex ("#w_railgun.md2");
    gi.modelindex ("#w_bfg.md2");
 
    //-------------------
 
    gi.soundindex ("player/gasp1.wav");     // gasping for air
    gi.soundindex ("player/gasp2.wav");     // head breaking surface, not gasping
 
    gi.soundindex ("player/watr_in.wav");   // feet hitting water
    gi.soundindex ("player/watr_out.wav");  // feet leaving water
 
    gi.soundindex ("player/watr_un.wav");   // head going underwater
    
    gi.soundindex ("player/u_breath1.wav");
    gi.soundindex ("player/u_breath2.wav");
 
    gi.soundindex ("items/pkup.wav");       // bonus item pickup
    gi.soundindex ("world/land.wav");       // landing thud
    gi.soundindex ("misc/h2ohit1.wav");     // landing splash
 
    gi.soundindex ("items/damage.wav");
    gi.soundindex ("items/protect.wav");
    gi.soundindex ("items/protect4.wav");
    gi.soundindex ("weapons/noammo.wav");
 
    gi.soundindex ("infantry/inflies1.wav");
 
    sm_meat_index = gi.modelindex ("models/objects/gibs/sm_meat/tris.md2");
    gi.modelindex ("models/objects/gibs/arm/tris.md2");
    gi.modelindex ("models/objects/gibs/bone/tris.md2");
    gi.modelindex ("models/objects/gibs/bone2/tris.md2");
    gi.modelindex ("models/objects/gibs/chest/tris.md2");
    gi.modelindex ("models/objects/gibs/skull/tris.md2");
    gi.modelindex ("models/objects/gibs/head2/tris.md2");
 
//
// Setup light animation tables. 'a' is total darkness, 'z' is doublebright.
//
 
    // 0 normal
    gi.configstring(CS_LIGHTS+0, "m");
    
    // 1 FLICKER (first variety)
    gi.configstring(CS_LIGHTS+1, "mmnmmommommnonmmonqnmmo");
    
    // 2 SLOW STRONG PULSE
    gi.configstring(CS_LIGHTS+2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
    
    // 3 CANDLE (first variety)
    gi.configstring(CS_LIGHTS+3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
    
    // 4 FAST STROBE
    gi.configstring(CS_LIGHTS+4, "mamamamamama");
    
    // 5 GENTLE PULSE 1
    gi.configstring(CS_LIGHTS+5,"jklmnopqrstuvwxyzyxwvutsrqponmlkj");
    
    // 6 FLICKER (second variety)
    gi.configstring(CS_LIGHTS+6, "nmonqnmomnmomomno");
    
    // 7 CANDLE (second variety)
    gi.configstring(CS_LIGHTS+7, "mmmaaaabcdefgmmmmaaaammmaamm");
    
    // 8 CANDLE (third variety)
    gi.configstring(CS_LIGHTS+8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
    
    // 9 SLOW STROBE (fourth variety)
    gi.configstring(CS_LIGHTS+9, "aaaaaaaazzzzzzzz");
    
    // 10 FLUORESCENT FLICKER
    gi.configstring(CS_LIGHTS+10, "mmamammmmammamamaaamammma");
 
    // 11 SLOW PULSE NOT FADE TO BLACK
    gi.configstring(CS_LIGHTS+11, "abcdefghijklmnopqrrqponmlkjihgfedcba");
    
    // styles 32-62 are assigned by the light program for switchable lights
 
    // 63 testing
    gi.configstring(CS_LIGHTS+63, "a");
}

SpawnEntities()

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

Definition at line 522 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 ();
        entities = ED_ParseEdict (entities, ent);
 
        // yet another map hack
        if (!Q_stricmp(level.mapname, "command") && !Q_stricmp(ent->classname, "trigger_once") && !Q_stricmp(ent->model, "*27"))
            ent->spawnflags &= ~SPAWNFLAG_NOT_HARD;
 
        // remove things (except the world) from different skill levels or deathmatch
        if (ent != g_edicts)
        {
            if (deathmatch->value)
            {
                if ( ent->spawnflags & SPAWNFLAG_NOT_DEATHMATCH )
                {
                    G_FreeEdict (ent);  
                    inhibit++;
                    continue;
                }
            }
            else
            {
                if ( /* ((coop->value) && (ent->spawnflags & SPAWNFLAG_NOT_COOP)) || */
                    ((skill->value == 0) && (ent->spawnflags & SPAWNFLAG_NOT_EASY)) ||
                    ((skill->value == 1) && (ent->spawnflags & SPAWNFLAG_NOT_MEDIUM)) ||
                    (((skill->value == 2) || (skill->value == 3)) && (ent->spawnflags & SPAWNFLAG_NOT_HARD))
                    )
                    {
                        G_FreeEdict (ent);  
                        inhibit++;
                        continue;
                    }
            }
 
            ent->spawnflags &= ~(SPAWNFLAG_NOT_EASY|SPAWNFLAG_NOT_MEDIUM|SPAWNFLAG_NOT_HARD|SPAWNFLAG_NOT_COOP|SPAWNFLAG_NOT_DEATHMATCH);
        }
 
        ED_CallSpawn (ent);
    }   
 
    gi.dprintf ("%i entities inhibited\n", inhibit);
 
#ifdef DEBUG
    i = 1;
    ent = EDICT_NUM(i);
    while (i < globals.num_edicts) {
        if (ent->inuse != 0 || ent->inuse != 1)
            Com_DPrintf("Invalid entity %d\n", i);
        i++, ent++;
    }
#endif
 
    G_FindTeams ();
 
    PlayerTrail_Init ();
}

Referenced by GetGameAPI().

Variable Documentation

dm_statusbar

char* dm_statusbar

Definition at line 708 of file g_spawn.c.

Referenced by SP_worldspawn().

single_statusbar

char* single_statusbar

Definition at line 650 of file g_spawn.c.

Referenced by SP_worldspawn().

spawns

spawn_t spawns[]

Definition at line 148 of file g_spawn.c.

Referenced by ED_CallSpawn().