You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
740 lines
17 KiB
740 lines
17 KiB
/* |
|
Copyright (C) 1997-2001 Id Software, Inc. |
|
|
|
This program is free software; you can redistribute it and/or |
|
modify it under the terms of the GNU General Public License |
|
as published by the Free Software Foundation; either version 2 |
|
of the License, or (at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
|
|
|
See the GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
|
|
|
*/ |
|
#include "g_local.h" |
|
|
|
|
|
// |
|
// monster weapons |
|
// |
|
|
|
//FIXME mosnters should call these with a totally accurate direction |
|
// and we can mess it up based on skill. Spread should be for normal |
|
// and we can tighten or loosen based on skill. We could muck with |
|
// the damages too, but I'm not sure that's such a good idea. |
|
void monster_fire_bullet (edict_t *self, vec3_t start, vec3_t dir, int damage, int kick, int hspread, int vspread, int flashtype) |
|
{ |
|
fire_bullet (self, start, dir, damage, kick, hspread, vspread, MOD_UNKNOWN); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_shotgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int hspread, int vspread, int count, int flashtype) |
|
{ |
|
fire_shotgun (self, start, aimdir, damage, kick, hspread, vspread, count, MOD_UNKNOWN); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_blaster (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype, int effect) |
|
{ |
|
fire_blaster (self, start, dir, damage, speed, effect, false); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_grenade (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int flashtype) |
|
{ |
|
fire_grenade (self, start, aimdir, damage, speed, 2.5, damage+40); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, int flashtype) |
|
{ |
|
fire_rocket (self, start, dir, damage, speed, damage+20, damage); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_railgun (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int kick, int flashtype) |
|
{ |
|
fire_rail (self, start, aimdir, damage, kick); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
void monster_fire_bfg (edict_t *self, vec3_t start, vec3_t aimdir, int damage, int speed, int kick, float damage_radius, int flashtype) |
|
{ |
|
fire_bfg (self, start, aimdir, damage, speed, damage_radius); |
|
|
|
gi.WriteByte (svc_muzzleflash2); |
|
gi.WriteShort (self - g_edicts); |
|
gi.WriteByte (flashtype); |
|
gi.multicast (start, MULTICAST_PVS); |
|
} |
|
|
|
|
|
|
|
// |
|
// Monster utility functions |
|
// |
|
|
|
static void M_FliesOff (edict_t *self) |
|
{ |
|
self->s.effects &= ~EF_FLIES; |
|
self->s.sound = 0; |
|
} |
|
|
|
static void M_FliesOn (edict_t *self) |
|
{ |
|
if (self->waterlevel) |
|
return; |
|
self->s.effects |= EF_FLIES; |
|
self->s.sound = gi.soundindex ("infantry/inflies1.wav"); |
|
self->think = M_FliesOff; |
|
self->nextthink = level.time + 60; |
|
} |
|
|
|
void M_FlyCheck (edict_t *self) |
|
{ |
|
if (self->waterlevel) |
|
return; |
|
|
|
if (random() > 0.5) |
|
return; |
|
|
|
self->think = M_FliesOn; |
|
self->nextthink = level.time + 5 + 10 * random(); |
|
} |
|
|
|
void AttackFinished (edict_t *self, float time) |
|
{ |
|
self->monsterinfo.attack_finished = level.time + time; |
|
} |
|
|
|
|
|
void M_CheckGround (edict_t *ent) |
|
{ |
|
vec3_t point; |
|
trace_t trace; |
|
|
|
if (ent->flags & (FL_SWIM|FL_FLY)) |
|
return; |
|
|
|
if (ent->velocity[2] > 100) |
|
{ |
|
ent->groundentity = NULL; |
|
return; |
|
} |
|
|
|
// if the hull point one-quarter unit down is solid the entity is on ground |
|
point[0] = ent->s.origin[0]; |
|
point[1] = ent->s.origin[1]; |
|
point[2] = ent->s.origin[2] - 0.25; |
|
|
|
trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_MONSTERSOLID); |
|
|
|
// check steepness |
|
if ( trace.plane.normal[2] < 0.7 && !trace.startsolid) |
|
{ |
|
ent->groundentity = NULL; |
|
return; |
|
} |
|
|
|
// ent->groundentity = trace.ent; |
|
// ent->groundentity_linkcount = trace.ent->linkcount; |
|
// if (!trace.startsolid && !trace.allsolid) |
|
// VectorCopy (trace.endpos, ent->s.origin); |
|
if (!trace.startsolid && !trace.allsolid) |
|
{ |
|
VectorCopy (trace.endpos, ent->s.origin); |
|
ent->groundentity = trace.ent; |
|
ent->groundentity_linkcount = trace.ent->linkcount; |
|
ent->velocity[2] = 0; |
|
} |
|
} |
|
|
|
|
|
void M_CatagorizePosition (edict_t *ent) |
|
{ |
|
vec3_t point; |
|
int cont; |
|
|
|
// |
|
// get waterlevel |
|
// |
|
point[0] = ent->s.origin[0]; |
|
point[1] = ent->s.origin[1]; |
|
point[2] = ent->s.origin[2] + ent->mins[2] + 1; |
|
cont = gi.pointcontents (point); |
|
|
|
if (!(cont & MASK_WATER)) |
|
{ |
|
ent->waterlevel = 0; |
|
ent->watertype = 0; |
|
return; |
|
} |
|
|
|
ent->watertype = cont; |
|
ent->waterlevel = 1; |
|
point[2] += 26; |
|
cont = gi.pointcontents (point); |
|
if (!(cont & MASK_WATER)) |
|
return; |
|
|
|
ent->waterlevel = 2; |
|
point[2] += 22; |
|
cont = gi.pointcontents (point); |
|
if (cont & MASK_WATER) |
|
ent->waterlevel = 3; |
|
} |
|
|
|
|
|
void M_WorldEffects (edict_t *ent) |
|
{ |
|
int dmg; |
|
|
|
if (ent->health > 0) |
|
{ |
|
if (!(ent->flags & FL_SWIM)) |
|
{ |
|
if (ent->waterlevel < 3) |
|
{ |
|
ent->air_finished = level.time + 12; |
|
} |
|
else if (ent->air_finished < level.time) |
|
{ // drown! |
|
if (ent->pain_debounce_time < level.time) |
|
{ |
|
dmg = 2 + 2 * floor(level.time - ent->air_finished); |
|
if (dmg > 15) |
|
dmg = 15; |
|
T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER); |
|
ent->pain_debounce_time = level.time + 1; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (ent->waterlevel > 0) |
|
{ |
|
ent->air_finished = level.time + 9; |
|
} |
|
else if (ent->air_finished < level.time) |
|
{ // suffocate! |
|
if (ent->pain_debounce_time < level.time) |
|
{ |
|
dmg = 2 + 2 * floor(level.time - ent->air_finished); |
|
if (dmg > 15) |
|
dmg = 15; |
|
T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, dmg, 0, DAMAGE_NO_ARMOR, MOD_WATER); |
|
ent->pain_debounce_time = level.time + 1; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if (ent->waterlevel == 0) |
|
{ |
|
if (ent->flags & FL_INWATER) |
|
{ |
|
gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_out.wav"), 1, ATTN_NORM, 0); |
|
ent->flags &= ~FL_INWATER; |
|
} |
|
return; |
|
} |
|
|
|
if ((ent->watertype & CONTENTS_LAVA) && !(ent->flags & FL_IMMUNE_LAVA)) |
|
{ |
|
if (ent->damage_debounce_time < level.time) |
|
{ |
|
ent->damage_debounce_time = level.time + 0.2; |
|
T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 10*ent->waterlevel, 0, 0, MOD_LAVA); |
|
} |
|
} |
|
if ((ent->watertype & CONTENTS_SLIME) && !(ent->flags & FL_IMMUNE_SLIME)) |
|
{ |
|
if (ent->damage_debounce_time < level.time) |
|
{ |
|
ent->damage_debounce_time = level.time + 1; |
|
T_Damage (ent, world, world, vec3_origin, ent->s.origin, vec3_origin, 4*ent->waterlevel, 0, 0, MOD_SLIME); |
|
} |
|
} |
|
|
|
if ( !(ent->flags & FL_INWATER) ) |
|
{ |
|
if (!(ent->svflags & SVF_DEADMONSTER)) |
|
{ |
|
if (ent->watertype & CONTENTS_LAVA) |
|
if (random() <= 0.5) |
|
gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava1.wav"), 1, ATTN_NORM, 0); |
|
else |
|
gi.sound (ent, CHAN_BODY, gi.soundindex("player/lava2.wav"), 1, ATTN_NORM, 0); |
|
else if (ent->watertype & CONTENTS_SLIME) |
|
gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0); |
|
else if (ent->watertype & CONTENTS_WATER) |
|
gi.sound (ent, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0); |
|
} |
|
|
|
ent->flags |= FL_INWATER; |
|
ent->damage_debounce_time = 0; |
|
} |
|
} |
|
|
|
|
|
void M_droptofloor (edict_t *ent) |
|
{ |
|
vec3_t end; |
|
trace_t trace; |
|
|
|
ent->s.origin[2] += 1; |
|
VectorCopy (ent->s.origin, end); |
|
end[2] -= 256; |
|
|
|
trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID); |
|
|
|
if (trace.fraction == 1 || trace.allsolid) |
|
return; |
|
|
|
VectorCopy (trace.endpos, ent->s.origin); |
|
|
|
gi.linkentity (ent); |
|
M_CheckGround (ent); |
|
M_CatagorizePosition (ent); |
|
} |
|
|
|
|
|
void M_SetEffects (edict_t *ent) |
|
{ |
|
ent->s.effects &= ~(EF_COLOR_SHELL|EF_POWERSCREEN); |
|
ent->s.renderfx &= ~(RF_SHELL_RED|RF_SHELL_GREEN|RF_SHELL_BLUE); |
|
|
|
if (ent->monsterinfo.aiflags & AI_RESURRECTING) |
|
{ |
|
ent->s.effects |= EF_COLOR_SHELL; |
|
ent->s.renderfx |= RF_SHELL_RED; |
|
} |
|
|
|
if (ent->health <= 0) |
|
return; |
|
|
|
if (ent->powerarmor_time > level.time) |
|
{ |
|
if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SCREEN) |
|
{ |
|
ent->s.effects |= EF_POWERSCREEN; |
|
} |
|
else if (ent->monsterinfo.power_armor_type == POWER_ARMOR_SHIELD) |
|
{ |
|
ent->s.effects |= EF_COLOR_SHELL; |
|
ent->s.renderfx |= RF_SHELL_GREEN; |
|
} |
|
} |
|
} |
|
|
|
|
|
void M_MoveFrame (edict_t *self) |
|
{ |
|
mmove_t *move; |
|
int index; |
|
|
|
move = self->monsterinfo.currentmove; |
|
self->nextthink = level.time + FRAMETIME; |
|
|
|
if ((self->monsterinfo.nextframe) && (self->monsterinfo.nextframe >= move->firstframe) && (self->monsterinfo.nextframe <= move->lastframe)) |
|
{ |
|
self->s.frame = self->monsterinfo.nextframe; |
|
self->monsterinfo.nextframe = 0; |
|
} |
|
else |
|
{ |
|
if (self->s.frame == move->lastframe) |
|
{ |
|
if (move->endfunc) |
|
{ |
|
move->endfunc (self); |
|
|
|
// regrab move, endfunc is very likely to change it |
|
move = self->monsterinfo.currentmove; |
|
|
|
// check for death |
|
if (self->svflags & SVF_DEADMONSTER) |
|
return; |
|
} |
|
} |
|
|
|
if (self->s.frame < move->firstframe || self->s.frame > move->lastframe) |
|
{ |
|
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME; |
|
self->s.frame = move->firstframe; |
|
} |
|
else |
|
{ |
|
if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME)) |
|
{ |
|
self->s.frame++; |
|
if (self->s.frame > move->lastframe) |
|
self->s.frame = move->firstframe; |
|
} |
|
} |
|
} |
|
|
|
index = self->s.frame - move->firstframe; |
|
if (move->frame[index].aifunc) |
|
if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME)) |
|
move->frame[index].aifunc (self, move->frame[index].dist * self->monsterinfo.scale); |
|
else |
|
move->frame[index].aifunc (self, 0); |
|
|
|
if (move->frame[index].thinkfunc) |
|
move->frame[index].thinkfunc (self); |
|
} |
|
|
|
|
|
void monster_think (edict_t *self) |
|
{ |
|
M_MoveFrame (self); |
|
if (self->linkcount != self->monsterinfo.linkcount) |
|
{ |
|
self->monsterinfo.linkcount = self->linkcount; |
|
M_CheckGround (self); |
|
} |
|
M_CatagorizePosition (self); |
|
M_WorldEffects (self); |
|
M_SetEffects (self); |
|
} |
|
|
|
|
|
/* |
|
================ |
|
monster_use |
|
|
|
Using a monster makes it angry at the current activator |
|
================ |
|
*/ |
|
void monster_use (edict_t *self, edict_t *other, edict_t *activator) |
|
{ |
|
if (self->enemy) |
|
return; |
|
if (self->health <= 0) |
|
return; |
|
if (activator->flags & FL_NOTARGET) |
|
return; |
|
if (!(activator->client) && !(activator->monsterinfo.aiflags & AI_GOOD_GUY)) |
|
return; |
|
|
|
// delay reaction so if the monster is teleported, its sound is still heard |
|
self->enemy = activator; |
|
FoundTarget (self); |
|
} |
|
|
|
|
|
void monster_start_go (edict_t *self); |
|
|
|
|
|
void monster_triggered_spawn (edict_t *self) |
|
{ |
|
self->s.origin[2] += 1; |
|
KillBox (self); |
|
|
|
self->solid = SOLID_BBOX; |
|
self->movetype = MOVETYPE_STEP; |
|
self->svflags &= ~SVF_NOCLIENT; |
|
self->air_finished = level.time + 12; |
|
gi.linkentity (self); |
|
|
|
monster_start_go (self); |
|
|
|
if (self->enemy && !(self->spawnflags & 1) && !(self->enemy->flags & FL_NOTARGET)) |
|
{ |
|
FoundTarget (self); |
|
} |
|
else |
|
{ |
|
self->enemy = NULL; |
|
} |
|
} |
|
|
|
void monster_triggered_spawn_use (edict_t *self, edict_t *other, edict_t *activator) |
|
{ |
|
// we have a one frame delay here so we don't telefrag the guy who activated us |
|
self->think = monster_triggered_spawn; |
|
self->nextthink = level.time + FRAMETIME; |
|
if (activator->client) |
|
self->enemy = activator; |
|
self->use = monster_use; |
|
} |
|
|
|
void monster_triggered_start (edict_t *self) |
|
{ |
|
self->solid = SOLID_NOT; |
|
self->movetype = MOVETYPE_NONE; |
|
self->svflags |= SVF_NOCLIENT; |
|
self->nextthink = 0; |
|
self->use = monster_triggered_spawn_use; |
|
} |
|
|
|
|
|
/* |
|
================ |
|
monster_death_use |
|
|
|
When a monster dies, it fires all of its targets with the current |
|
enemy as activator. |
|
================ |
|
*/ |
|
void monster_death_use (edict_t *self) |
|
{ |
|
self->flags &= ~(FL_FLY|FL_SWIM); |
|
self->monsterinfo.aiflags &= AI_GOOD_GUY; |
|
|
|
if (self->item) |
|
{ |
|
Drop_Item (self, self->item); |
|
self->item = NULL; |
|
} |
|
|
|
if (self->deathtarget) |
|
self->target = self->deathtarget; |
|
|
|
if (!self->target) |
|
return; |
|
|
|
G_UseTargets (self, self->enemy); |
|
} |
|
|
|
|
|
//============================================================================ |
|
|
|
qboolean monster_start (edict_t *self) |
|
{ |
|
if (deathmatch->value) |
|
{ |
|
G_FreeEdict (self); |
|
return false; |
|
} |
|
|
|
if ((self->spawnflags & 4) && !(self->monsterinfo.aiflags & AI_GOOD_GUY)) |
|
{ |
|
self->spawnflags &= ~4; |
|
self->spawnflags |= 1; |
|
// gi.dprintf("fixed spawnflags on %s at %s\n", self->classname, vtos(self->s.origin)); |
|
} |
|
|
|
if (!(self->monsterinfo.aiflags & AI_GOOD_GUY)) |
|
level.total_monsters++; |
|
|
|
self->nextthink = level.time + FRAMETIME; |
|
self->svflags |= SVF_MONSTER; |
|
self->s.renderfx |= RF_FRAMELERP; |
|
self->takedamage = DAMAGE_AIM; |
|
self->air_finished = level.time + 12; |
|
self->use = monster_use; |
|
self->max_health = self->health; |
|
self->clipmask = MASK_MONSTERSOLID; |
|
|
|
self->s.skinnum = 0; |
|
self->deadflag = DEAD_NO; |
|
self->svflags &= ~SVF_DEADMONSTER; |
|
|
|
if (!self->monsterinfo.checkattack) |
|
self->monsterinfo.checkattack = M_CheckAttack; |
|
VectorCopy (self->s.origin, self->s.old_origin); |
|
|
|
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); |
|
} |
|
|
|
// randomize what frame they start on |
|
if (self->monsterinfo.currentmove) |
|
self->s.frame = self->monsterinfo.currentmove->firstframe + (rand() % (self->monsterinfo.currentmove->lastframe - self->monsterinfo.currentmove->firstframe + 1)); |
|
|
|
return true; |
|
} |
|
|
|
void monster_start_go (edict_t *self) |
|
{ |
|
vec3_t v; |
|
|
|
if (self->health <= 0) |
|
return; |
|
|
|
// check for target to combat_point and change to combattarget |
|
if (self->target) |
|
{ |
|
qboolean notcombat; |
|
qboolean fixup; |
|
edict_t *target; |
|
|
|
target = NULL; |
|
notcombat = false; |
|
fixup = false; |
|
while ((target = G_Find (target, FOFS(targetname), self->target)) != NULL) |
|
{ |
|
if (strcmp(target->classname, "point_combat") == 0) |
|
{ |
|
self->combattarget = self->target; |
|
fixup = true; |
|
} |
|
else |
|
{ |
|
notcombat = true; |
|
} |
|
} |
|
if (notcombat && self->combattarget) |
|
gi.dprintf("%s at %s has target with mixed types\n", self->classname, vtos(self->s.origin)); |
|
if (fixup) |
|
self->target = NULL; |
|
} |
|
|
|
// validate combattarget |
|
if (self->combattarget) |
|
{ |
|
edict_t *target; |
|
|
|
target = NULL; |
|
while ((target = G_Find (target, FOFS(targetname), self->combattarget)) != NULL) |
|
{ |
|
if (strcmp(target->classname, "point_combat") != 0) |
|
{ |
|
gi.dprintf("%s at (%i %i %i) has a bad combattarget %s : %s at (%i %i %i)\n", |
|
self->classname, (int)self->s.origin[0], (int)self->s.origin[1], (int)self->s.origin[2], |
|
self->combattarget, target->classname, (int)target->s.origin[0], (int)target->s.origin[1], |
|
(int)target->s.origin[2]); |
|
} |
|
} |
|
} |
|
|
|
if (self->target) |
|
{ |
|
self->goalentity = self->movetarget = G_PickTarget(self->target); |
|
if (!self->movetarget) |
|
{ |
|
gi.dprintf ("%s can't find target %s at %s\n", self->classname, self->target, vtos(self->s.origin)); |
|
self->target = NULL; |
|
self->monsterinfo.pausetime = 100000000; |
|
self->monsterinfo.stand (self); |
|
} |
|
else if (strcmp (self->movetarget->classname, "path_corner") == 0) |
|
{ |
|
VectorSubtract (self->goalentity->s.origin, self->s.origin, v); |
|
self->ideal_yaw = self->s.angles[YAW] = vectoyaw(v); |
|
self->monsterinfo.walk (self); |
|
self->target = NULL; |
|
} |
|
else |
|
{ |
|
self->goalentity = self->movetarget = NULL; |
|
self->monsterinfo.pausetime = 100000000; |
|
self->monsterinfo.stand (self); |
|
} |
|
} |
|
else |
|
{ |
|
self->monsterinfo.pausetime = 100000000; |
|
self->monsterinfo.stand (self); |
|
} |
|
|
|
self->think = monster_think; |
|
self->nextthink = level.time + FRAMETIME; |
|
} |
|
|
|
|
|
void walkmonster_start_go (edict_t *self) |
|
{ |
|
if (!(self->spawnflags & 2) && level.time < 1) |
|
{ |
|
M_droptofloor (self); |
|
|
|
if (self->groundentity) |
|
if (!M_walkmove (self, 0, 0)) |
|
gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin)); |
|
} |
|
|
|
if (!self->yaw_speed) |
|
self->yaw_speed = 20; |
|
self->viewheight = 25; |
|
|
|
monster_start_go (self); |
|
|
|
if (self->spawnflags & 2) |
|
monster_triggered_start (self); |
|
} |
|
|
|
void walkmonster_start (edict_t *self) |
|
{ |
|
self->think = walkmonster_start_go; |
|
monster_start (self); |
|
} |
|
|
|
|
|
void flymonster_start_go (edict_t *self) |
|
{ |
|
if (!M_walkmove (self, 0, 0)) |
|
gi.dprintf ("%s in solid at %s\n", self->classname, vtos(self->s.origin)); |
|
|
|
if (!self->yaw_speed) |
|
self->yaw_speed = 10; |
|
self->viewheight = 25; |
|
|
|
monster_start_go (self); |
|
|
|
if (self->spawnflags & 2) |
|
monster_triggered_start (self); |
|
} |
|
|
|
|
|
void flymonster_start (edict_t *self) |
|
{ |
|
self->flags |= FL_FLY; |
|
self->think = flymonster_start_go; |
|
monster_start (self); |
|
} |
|
|
|
|
|
void swimmonster_start_go (edict_t *self) |
|
{ |
|
if (!self->yaw_speed) |
|
self->yaw_speed = 10; |
|
self->viewheight = 10; |
|
|
|
monster_start_go (self); |
|
|
|
if (self->spawnflags & 2) |
|
monster_triggered_start (self); |
|
} |
|
|
|
void swimmonster_start (edict_t *self) |
|
{ |
|
self->flags |= FL_SWIM; |
|
self->think = swimmonster_start_go; |
|
monster_start (self); |
|
}
|
|
|