Git Repos / fte_dogmode / qc / base_monster.qc
Last update to this file was on 2025-03-30 at 19:29.
Show base_monster.qc
//==============================================================================
// base_monster.qc -- base monster class, monster logic
//==============================================================================
//======================================================================
// constants
//======================================================================
#ifdef SSQC
//----------------------------------------------------------------------
// base monster spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
SPAWNFLAG_MONSTER_TELEWAIT = 8, // teleport-wait enemy
SPAWNFLAG_MONSTER_BERSERK = 16, // was .berserk -- CEV
SPAWNFLAG_MONSTER_NO_SIGHT_SOUND = 32, // no alert sound
SPAWNFLAG_MONSTER_PASSIVE_UNTIL_ATTACKED = 64,
SPAWNFLAG_MONSTER_PASSIVE_ALWAYS = 128,
// SPAWNFLAG_NOT_ON_EASY = 256, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_NORMAL = 512, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_HARD_OR_NIGHTMARE = 1024, // base_entities.qc -- CEV
// SPAWNFLAG_NOT_IN_DEATHMATCH = 2048, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_IN_COOP = 4096, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_IN_SP = 8192, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_IN_TEAMPLAY = 16384, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_SKILL2 = 32768, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_SKILL3 = 65536, // see base_entities.qc -- CEV
// SPAWNFLAG_CENTERPRINTALL = 131072, // see base_entities.qc -- CEV
SPAWNFLAG_MONSTER_SILENT = 262144, // suppress the teleport-in sound
SPAWNFLAG_MONSTER_TURRET = 524288, // dumptruck_ds
SPAWNFLAG_MONSTER_SPAWNED = 1048576, // MG1 SPAWNED flag
SPAWNFLAG_MONSTER_ANGRY = 2097152, // monster spawns in angry -- CEV
SPAWNFLAG_MONSTER_WAITWALK = 4194304 // MG1 WAITWALK flag
} base_monster_spawnflags;
#endif
#ifdef SSQC
//----------------------------------------------------------------------
// base_corpse spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
SPAWNFLAG_CORPSE_SOLID = 1, // spawnflags: solid
SPAWNFLAG_CORPSE_DYNAMIC = 2 // non-static, moveable corpse
// SPAWNFLAG_NOT_ON_EASY = 256, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_NORMAL = 512,
// SPAWNFLAG_NOT_ON_HARD_OR_NIGHTMARE = 1024,
// SPAWNFLAG_NOT_IN_DEATHMATCH = 2048,
// SPAWNFLAG_NOT_IN_COOP = 4096,
// SPAWNFLAG_NOT_IN_SP = 8192,
// SPAWNFLAG_NOT_ON_SKILL2 = 32768, // see base_entities.qc -- CEV
// SPAWNFLAG_NOT_ON_SKILL3 = 65536, // see base_entities.qc -- CEV
// SPAWNFLAG_CENTERPRINTALL = 131072 // see base_entities.qc -- CEV
} base_corpse_spawnflags;
#endif
#ifdef SSQC
//----------------------------------------------------------------------
// values for attack_state field
//----------------------------------------------------------------------
typedef enum
{
AS_STRAIGHT = 1,
AS_SLIDING = 2,
AS_MELEE = 3,
AS_MISSILE = 4,
AS_TURRET = 5
} base_monster_attack_states;
#endif
#ifdef SSQC
//----------------------------------------------------------------------
// range values; see ai_range ()
//----------------------------------------------------------------------
typedef enum
{
RANGE_MELEE = 0,
RANGE_NEAR = 1,
RANGE_MID = 2,
RANGE_FAR = 3
} base_monster_ai_ranges;
#endif
#ifdef SSQC
const float CORPSE_HEALTH = 30; // static corpse health -- CEV
#endif
//======================================================================
// globals
//======================================================================
#ifdef SSQC
float enemy_vis; // was in fight.qc
float enemy_infront; // was in fight.qc
float enemy_range; // was in fight.qc
float enemy_yaw; // was in fight.qc
float movedist; // base_monster
float sight_entity_time; // was in ai.qc
entity sight_entity; // was in ai.qc
#endif
//======================================================================
// fields
//======================================================================
#if defined(CSQC) || defined(SSQC)
.float air_finished; // when time > air_finished, drown
#endif
#ifdef SSQC
.float attack_elevation; // Preach's Z-aware nades -- CEV
.float attack_state;
.float berserk; // dumptruck_ds
.float drop_item; // key DropStuff
.float infight_mode;
.float keep_ammo; // dumptruck_ds
.float pain_threshold; // dumptruck_ds
.float pausetime;
.float search_time;
.float sight_trigger; // dumptruck_ds
.float swim_time; // monster swimming sound flag
.float touch_time;
#endif
#ifdef SSQC
.entity infight_activator;
.entity movetarget;
#endif
#ifdef SSQC
.void() th_stand; // the typical th_ monster functions
.void() th_walk;
.void() th_run;
.void() th_missile;
.void() th_melee;
.void() th_turret;
#endif
#ifdef SSQC
.float() checkattack; // per-monster CheckAttack -- CEV
.void(float old, float new) contentstransition; // liquid -> air and reverse
.void() sightsound; // per-monster SightSound -- CEV
#endif
//======================================================================
// forward declarations
//======================================================================
#ifdef SSQC
void(float n) monster_update_total;
#endif
// base_monster
#ifdef CSQC
// BASE_MONSTER_NETRECEIVE(initfn, newmins, newmaxs)
float() base_monster_predraw;
#endif
#ifdef SSQC
void(vector org, float projspeed) base_monster_fire_flak;
void(vector org, float direct, float splash, float elevation)
base_monster_fire_grenade;
void() base_monster_fire_tribolt;
void(vector org, vector dir, float off) base_monster_fire_hknightspell;
void(vector org, vector dir) base_monster_fire_laser;
void(vector org, vector dir, float projspeed) base_monster_fire_lavaball;
void() base_monster_fire_multigrenade;
void(vector org, vector dir, float direct, float splash, float projspeed)
base_monster_fire_rocket;
void(vector org, vector dir, vector spread) base_monster_fire_shotgun;
void(vector org, vector dir, float damage, float projspeed)
base_monster_fire_spike;
void(vector org, vector dir) base_monster_fire_voreball;
void() base_monster_fire_wizardspell;
void(vector offset, float elevation) base_monster_fire_zombiechunk;
void() base_monster_liquiddamage; // monster AI
void(float old, float new) base_monster_contentstransition;
float() ai_checkattack;
float(entity targ) ai_infront;
float(entity targ) ai_range;
float(entity targ) ai_visible;
void() ai_hunttarget;
void() ai_foundtarget;
float() ai_findtarget;
void() ai_face;
float() ai_facing_ideal;
void(float dist) ai_forward;
void(float dist) ai_back;
void(float dist) ai_pain;
void(float dist) ai_painforward;
void(float dist) ai_walk;
void() ai_stand;
void() ai_turn;
void() ai_run_melee;
void() ai_run_missile;
void() ai_run_slide;
void(float dist) ai_run;
void(float dist) ai_charge;
void() ai_charge_side;
void() ai_melee;
void() ai_melee_side;
void(float normal) sub_attackfinished; // monster subs
void(void() nextfunc) sub_checkrefire;
float(.string fld) sub_fieldistargeted;
float() sub_istargeted;
void() sub_pain_use;
void() base_monster_think_teleport_start; // monster interaction
#endif
#if defined(CSQC) || defined(SSQC)
void() base_monster_touch;
#endif
#ifdef SSQC
void() base_monster_use_angry;
void() base_monster_use_beginwalk;
void() base_monster_use_death;
void() base_monster_use_teledelay;
entity(vector org, vector ang, float sflags, float yaw,
void(entity e) initfn) spawn_base_monster;
// BASE_MONSTER_PREINIT(func) // monster initialization
void(string key, string value) base_monster_init_field;
void() base_monster_init_teleport_check;
float(entity e, void() start_fn) base_monster_init_teleport;
void() base_monster_init_start;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) base_monster_init;
#endif
#ifdef SSQC
strip void() base_monster;
#endif
#ifdef SSQC
// base_corpse
void(entity e, float corpse_health) become_base_corpse;
void(entity e) base_corpse_init;
strip void() base_corpse;
#endif
//------------------------------------------------------------------------------
//======================================================================
// .enemy
// Will be world if not currently angry at anyone.
//
// .movetarget
// The next path spot to walk toward. If .enemy, ignore .movetarget.
// When an enemy is killed, the monster will try to return to it's path.
//
// .huntt_ime
// Set to time + something when the player is in sight, but movement
// straight for him is blocked. This causes the monster to use wall
// following code for movement direction instead of sighting on the
// player.
//
// .ideal_yaw
// A yaw angle of the intended direction, which will be turned towards
// at up to 45 deg / state. If the enemy is in view and hunt_time is not
// active, this will be the exact line towards the enemy.
//
// .pausetime
// A monster will leave it's stand state and head towards it's .movetarget
// when time > .pausetime.
//
// walkmove(angle, speed) primitive is all or nothing
//======================================================================
#ifdef SSQC
//----------------------------------------------------------------------
// monster_update_total
//
// Call this function to safely update total_monsters when the game is
// in progress. It adds "n" to total_monsters, then notifies all clients
// of the change. -- iw
//----------------------------------------------------------------------
void(float n) monster_update_total =
{
total_monsters = total_monsters + n;
WriteByte (MSG_ALL, SVC_UPDATESTAT);
WriteByte (MSG_ALL, STAT_TOTALMONSTERS);
WriteLong (MSG_ALL, total_monsters);
};
#endif
//----------------------------------------------------------------------
// class base_monster: base_mapentity
// {
//==============================================================
// Generic monster networking -- CEV
//==============================================================
#ifdef CSQC
//--------------------------------------------------------------
#define BASE_MONSTER_NETRECEIVE(initfn, newmins, newmaxs) \
/* { */ \
local float netflags = base_entity_netreceive (isnew); \
if (isnew && !(self.predraw)) \
{ \
initfn (self); \
} \
else \
{ \
if (netflags & NETFLAG_BASE_ENTITY_MODEL) { \
if (self.modelindex) \
{ \
setmodelindex (self, self.modelindex); \
if (self.solid) \
setsize (self, newmins, newmaxs); \
/*
else \
setsize (self, '0 0 0', '0 0 0'); */ \
} } \
if (netflags & NETFLAG_BASE_ENTITY_SOLID) \
{ \
if (self.solid) \
setsize (self, newmins, newmaxs); \
else \
setsize (self, '0 0 0', '0 0 0'); \
} \
} \
if (self.frame_net != self.frame || isnew) \
{ \
self.frame2 = self.frame; \
self.lerptime = time; \
self.frame = self.frame_net; \
} \
/* } */
//--------------------------------------------------------------
float() base_monster_predraw =
{
// a hack - don't interpolate frame for nonsolid (dead)
// monsters when in intermission - monsters are set
// nonsolid based on their frame in their individual
// netreceive functions -- CEV
if (intermission == FALSE || self.solid)
{
// interpolate frame
if (self.lerptime)
self.lerpfrac = 1 - (time - self.lerptime) * 10;
}
// interpolate angles -- see base_entities.qc -- CEV
BASE_ENTITY_LERP_ANGLES (self,
self.angles_net, self.angles_prev, time,
self.angles_net_time, self.angles_prev_time)
// interpolate origin -- see base_entities.qc -- CEV
BASE_ENTITY_LERP_ORIGIN (self,
self.origin_net, self.origin_prev, time,
self.origin_net_time, self.origin_prev_time)
// draw muzzleflash if needed -- CEV
if (self.effects & EF_MUZZLEFLASH)
{
self.effects &= ~EF_MUZZLEFLASH;
makevectors ([0, self.angles_y, 0]);
pointparticles (particleeffectnum("te_muzzleflash"),
self.origin, v_forward, 1);
}
// draw this entity -- CEV
addentity (self);
// go to next without auto-drawing this entity -- CEV
return PREDRAW_NEXT;
};
#endif
//==============================================================
// Generic Monster Weapon Firing
//==============================================================
#ifdef SSQC
//--------------------------------------------------------------
// BDW_OgreFireFlak
//--------------------------------------------------------------
void(vector org, float projspeed) base_monster_fire_flak =
{
local float flakcount = 8;
local vector dir, ang;
self.effects = self.effects | EF_MUZZLEFLASH;
sound (self, CHAN_WEAPON, "weapons/spike2.wav",
VOL_HIGH, ATTN_NORM);
// make angles out of the current displacement vector...
ang = vectoangles (self.enemy.origin - self.origin);
// then get the required components...
makevectors (ang);
while (flakcount > 0)
{
// tighter spread...
dir = v_forward * 10 +
crandom() * v_right +
crandom() * v_up;
dir = normalize (dir);
// f*cking hack...is this a v_forward problem?
dir_z *= -1;
// SetSpeed -- CEV
dir *= min (projspeed * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
spawn_projectile_flak (self, org, dir);
flakcount -= 1;
}
};
//--------------------------------------------------------------
// Monster grenade function, incorporates PreachFireGrenade -- CEV
//--------------------------------------------------------------
void(vector org, float direct, float splash, float elevation)
base_monster_fire_grenade =
{
local vector missile_velocity = '0 0 0';
self.effects = self.effects | EF_MUZZLEFLASH;
sound (self, CHAN_WEAPON, "weapons/grenade.wav",
VOL_HIGH, ATTN_NORM);
// set missile speed
if (elevation)
{
local vector ang = self.angles;
ang_x = -elevation;
makevectors (ang);
missile_velocity = v_forward * GRENADE_SPEED;
}
else
{
missile_velocity =
normalize (self.enemy.origin - self.origin);
missile_velocity *= 600;
missile_velocity_z = 200;
}
// TODO CEV pass direct and splash damage?
spawn_projectile_grenade (self, org, missile_velocity);
};
//--------------------------------------------------------------
void() base_monster_fire_tribolt =
{
sound (self, CHAN_WEAPON, "weapons/grenade.wav",
VOL_HIGH, ATTN_NORM);
spawn_projectile_bolt (self, 0);
spawn_projectile_bolt (self, BOLT_FIRING_DELAY);
spawn_projectile_bolt (self, BOLT_FIRING_DELAY * 2.0f);
};
//--------------------------------------------------------------
// hknight_shot
//--------------------------------------------------------------
void(vector org, vector dir, float off) base_monster_fire_hknightspell =
{
// set missile speed
dir = normalize (v_forward);
dir_z = 0 - dir_z + (random() - 0.5) * 0.1;
dir *= min (HKNSPELL_SPEED * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
spawn_projectile_hknightspell (self, org, dir, off);
sound (self, CHAN_WEAPON, "hknight/attack1.wav",
VOL_HIGH, ATTN_NORM);
};
//--------------------------------------------------------------
// Enforcer lasers, was LaunchLaser
//--------------------------------------------------------------
void(vector org, vector dir) base_monster_fire_laser =
{
self.effects = self.effects | EF_MUZZLEFLASH;
sound (self, CHAN_WEAPON, "enforcer/enfire.wav",
VOL_HIGH, ATTN_NORM);
dir = normalize (dir);
// SetSpeed (newmis, vec, projspeed);
dir *= min (LASER_SPEED * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
spawn_projectile_laser (self, org, dir);
};
//--------------------------------------------------------------
void(vector org, vector dir, float projspeed)
base_monster_fire_lavaball =
{
dir = normalize (dir);
// SetSpeed
dir *= min (projspeed * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
spawn_projectile_lavaball (self, org, dir);
};
//--------------------------------------------------------------
// DOE multigrenades
//--------------------------------------------------------------
void() base_monster_fire_multigrenade =
{
local vector missile_velocity;
sound (self, CHAN_WEAPON, "weapons/grenade.wav",
VOL_HIGH, ATTN_NORM);
// set missile speed
missile_velocity = normalize (self.enemy.origin - self.origin);
missile_velocity *= 600;
missile_velocity_z = 200;
spawn_projectile_multigrenade (self, self.origin + '0 0 16',
missile_velocity);
};
//--------------------------------------------------------------
void(vector org, vector dir, float direct, float splash,
float projspeed) base_monster_fire_rocket =
{
self.effects = self.effects | EF_MUZZLEFLASH;
sound (self, CHAN_WEAPON, "weapons/sgun1.wav",
VOL_HIGH, ATTN_NORM);
dir = normalize (dir);
// SetSpeed
dir *= min (projspeed * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
// TODO CEV pass direct & splash damage?
spawn_projectile_rocket (self, org, dir, projspeed);
};
//--------------------------------------------------------------
void(vector org, vector dir, vector spread) base_monster_fire_shotgun =
{
local vector vdir;
local float vspeed;
// 4 bullets instead of 6 -- CEV
for (float i = 0; i < 4; i++)
{
vspeed = crandom () * 10 + BULLET_SPEED;
vdir = dir + crandom() * spread_x * v_right +
crandom() * spread_y * v_up;
vdir *= min (vspeed, world_maxvelocity);
spawn_projectile_bullet (self, org, vdir);
}
};
//--------------------------------------------------------------
void(vector org, vector dir, float damage, float projspeed)
base_monster_fire_spike =
{
dir = normalize (dir);
// SetSpeed
dir *= min (projspeed * (self.proj_speed_mod ?
self.proj_speed_mod : 1), world_maxvelocity);
spawn_projectile_spike (self, org, dir, damage, projspeed);
};
//--------------------------------------------------------------
// ShalMissile
//--------------------------------------------------------------
void(vector org, vector dir) base_monster_fire_voreball =
{
local float basespeed;
self.effects = self.effects | EF_MUZZLEFLASH;
sound (self, CHAN_WEAPON, "shalrath/attack2.wav",
VOL_HIGH, ATTN_NORM);
dir = normalize (dir);
// SetSpeed
dir *= min (VOREBALL_SPEED * self.proj_speed_mod,
world_maxvelocity);
if (skill == 3)
basespeed = 350 * self.proj_speed_mod;
else
basespeed = 250 * self.proj_speed_mod;
spawn_projectile_voreball (self, org, dir, basespeed);
};
//--------------------------------------------------------------
// Wiz_StartFast
//--------------------------------------------------------------
void() base_monster_fire_wizardspell =
{
self.v_angle = self.angles;
makevectors (self.angles);
// two nextthinks were present in Wiz_StartFast, I'm leaving
// the last of them -- CEV
// nextthink: time + 0.6,
spawn_projectile_wizardspell (self,
self.origin + '0 0 30' + v_forward * 14 + v_right * 14,
v_right, time + 0.8);
// two nextthinks were present in Wiz_StartFast, I'm leaving
// the last of them -- CEV
// nextthink: time + 1,
spawn_projectile_wizardspell (self,
self.origin + '0 0 30' + v_forward * 14 + v_right * -14,
'0 0 0' - v_right, time + 0.3);
};
//--------------------------------------------------------------
// Throw a zombie gib; incorporates PreachFireGrenade -- CEV
//--------------------------------------------------------------
void(vector offset, float elevation) base_monster_fire_zombiechunk =
{
local vector vel = '0 0 0';
sound (self, CHAN_WEAPON, "zombie/z_shot1.wav",
VOL_HIGH, ATTN_NORM);
// set missile speed
if (elevation)
{
// PreachFireZombie -- for Z-Aware Zombies
local vector ang = self.angles;
ang_x = -elevation;
makevectors (ang);
vel = v_forward * ZCHUNK_SPEED;
}
else
{
// calc org
offset = offset_x * v_forward +
offset_y * v_right + (offset_z - 24) * v_up;
local vector org = self.origin + offset;
makevectors (self.angles);
vel = normalize (self.enemy.origin - org);
vel = vel * ZCHUNK_SPEED;
vel_z = 200;
}
spawn_projectile_zombiechunk (self, self.origin + offset, vel);
};
//==============================================================
// Monster AI
//==============================================================
//--------------------------------------------------------------
// Damage the monster according to the liquid type it's in.
// Based on AD code & id1 player/client watermove -- CEV
//--------------------------------------------------------------
void() base_monster_liquiddamage =
{
if (self.conlevel == WATERLEVEL_NONE)
return;
if (self.contype == CONTENT_WATER &&
self.conlevel > WATERLEVEL_WAIST &&
self.air_finished < time)
{
if (self.classtype == CT_MONSTER_ZOMBIE)
// zombies can't drown
return;
// other monsters can drown
if (self.pain_finished < time)
{
self.deathtype = "drowning";
t_damage2 (self, world, world, 10);
self.deathtype = "";
self.pain_finished = time + 1;
}
}
else if (self.contype == CONTENT_LAVA)
{
// monsters damaged by lava
if (self.damage_time < time)
{
self.damage_time = time + 0.2;
self.deathtype = "lava";
if (self.classtype == CT_MONSTER_ZOMBIE)
// lava kills zombies -- CEV
t_damage2 (self, world, world, 150);
else
// fixed damage multiplier for monsters
t_damage2 (self, world, world, 10 * 5);
self.deathtype = "";
}
}
else if (self.contype == CONTENT_SLIME)
{
if (self.classtype == CT_MONSTER_ZOMBIE)
// zombies aren't damaged by slime
return;
// monsters damaged by slime
if (self.damage_time < time)
{
self.damage_time = time + 1;
self.deathtype = "slime";
// fixed damage multiplier for monsters
t_damage2 (self, world, world, 4 * 5);
self.deathtype = "";
}
}
};
//--------------------------------------------------------------
// a no-op to prevent the engine from playing h2ohit1.wav when
// an entity enters water -- CEV
//--------------------------------------------------------------
void(float old, float new) base_monster_contentstransition =
{
dprint (sprintf("base_monster_contentstransition: "
"entering; self %s, old %g, new %g\n",
self.classname, old, new));
};
//--------------------------------------------------------------
// ai_checkattack - MonsterCheckAttack & CheckAttack
// override in monster code if other behavior is desired
//
// The player is in view, so decide to move or launch an attack
// Returns FALSE if movement should continue
//--------------------------------------------------------------
float() ai_checkattack =
{
// Drake devkit -- dumptruck_ds
if (cutscene)
if (self.enemy.classtype == CT_INFO_MOVIE_CAMERA)
// Don't attack the camera (player)!
return FALSE;
if (!enemy_vis)
return FALSE;
if (self.checkattack)
return self.checkattack ();
local vector spot1 = '0 0 0';
local vector spot2 = '0 0 0';
local entity targ;
local float chance;
// TODO CEV: fix these class checks, generalize
// call to knight_attack
// dumptruck_ds
if (self.spawnflags & SPAWNFLAG_MONSTER_TURRET)
{
// dprint ("CheckAttack...\n");
if (self.classtype == CT_MONSTER_ENFORCER)
{
if (self.style == 4)
{
// lightning can only go so far
if (vlen(spot1 - spot2) > 900)
return FALSE;
}
self.attack_state = AS_MISSILE;
}
else if (self.classtype == CT_MONSTER_DEATHKNIGHT)
{
if (self.style == 1)
{
// lightning can only go so far
if (vlen(spot1 - spot2) > 900)
return FALSE;
}
// self.attack_state = AS_MISSILE;
self.th_turret ();
}
else if (self.classtype == CT_MONSTER_VORE)
{
self.th_turret ();
}
else if (self.classtype == CT_MONSTER_ZOMBIE)
{
// dprint ("CheckAttack...\n");
// zombie_turret_missile ();
self.th_turret ();
}
sub_attackfinished (2 * random());
return TRUE;
}
targ = self.enemy;
// see if any entities are in the way of the shot
spot1 = self.origin + self.view_ofs;
spot2 = targ.origin + targ.view_ofs;
traceline (spot1, spot2, FALSE, self);
if ((self.spawnflags & SPAWNFLAG_MONSTER_TURRET) &&
(trace_ent != targ))
{
// dprint ("trace_ent...\n");
self.attack_state = AS_TURRET;
return FALSE;
}
if (trace_inopen && trace_inwater)
// sight line crossed contents
return FALSE;
if (trace_ent != targ)
// don't have a clear shot
return FALSE;
if (enemy_range == RANGE_MELEE)
{
// melee attack
if (self.th_melee)
{
// TODO CEV
if (self.classtype == CT_MONSTER_KNIGHT)
monster_knight_attack ();
else
self.th_melee ();
return TRUE;
}
}
// missile attack
if (!self.th_missile)
return FALSE;
if (time < self.attack_finished)
return FALSE;
if (enemy_range == RANGE_FAR)
return FALSE;
if (enemy_range == RANGE_MELEE)
{
chance = 0.9;
self.attack_finished = 0;
}
else if (enemy_range == RANGE_NEAR)
{
if (self.th_melee)
chance = 0.2;
else
chance = 0.4;
}
else if (enemy_range == RANGE_MID)
{
if (self.th_melee)
chance = 0.05;
else
chance = 0.1;
}
else
{
chance = 0;
}
if (random() < chance)
{
self.th_missile ();
sub_attackfinished (2 * random());
return TRUE;
}
return FALSE;
};
//--------------------------------------------------------------
// infront -- return TRUE if targ is in front (in sight) of self
//--------------------------------------------------------------
float(entity targ) ai_infront =
{
local vector vec;
makevectors (self.angles);
vec = normalize (targ.origin - self.origin);
if ((vec * v_forward) > 0.3)
return TRUE;
return FALSE;
};
//--------------------------------------------------------------
// range
//
// returns the range catagorization of an entity reletive to self
// 0 melee range, will become hostile even if back is turned
// 1 visibility and infront, or visibility and show hostile
// 2 infront and show hostile
// 3 only triggered by damage
//--------------------------------------------------------------
float(entity targ) ai_range =
{
local vector spot1 = self.origin + self.view_ofs;
local vector spot2 = targ.origin + targ.view_ofs;
local float r = vlen (spot1 - spot2);
if (r < 120)
return RANGE_MELEE;
if (r < 500)
return RANGE_NEAR;
if (r < 1000)
return RANGE_MID;
return RANGE_FAR;
};
//--------------------------------------------------------------
// visible - returns TRUE if targ is visible to self, even
// if not infront ()
//--------------------------------------------------------------
float(entity targ) ai_visible =
{
local vector spot1, spot2;
spot1 = self.origin + self.view_ofs;
spot2 = targ.origin + targ.view_ofs;
// see through other monsters
traceline (spot1, spot2, TRUE, self);
if (trace_inopen && trace_inwater)
// sight line crossed contents
return FALSE;
if (trace_fraction == 1)
return TRUE;
return FALSE;
};
//--------------------------------------------------------------
// HuntTarget -- was in ai.qc -- CEV
//--------------------------------------------------------------
void() ai_hunttarget =
{
self.goalentity = self.enemy;
self.ideal_yaw = vectoyaw (self.enemy.origin - self.origin);
self.think = self.th_run;
self.nextthink = time + 0.1;
// wait a while before first attack
sub_attackfinished (1);
};
//--------------------------------------------------------------
// FoundTarget -- was in ai.qc -- CEV
//--------------------------------------------------------------
void() ai_foundtarget =
{
if (self.enemy.classtype == CT_PLAYER)
{
// let other monsters see this monster for a while
sight_entity = self;
sight_entity_time = time;
}
// wake up other monsters
self.show_hostile = time + 1;
if !(self.spawnflags & SPAWNFLAG_MONSTER_NO_SIGHT_SOUND ||
self.spawnflags & SPAWNFLAG_MONSTER_PASSIVE_ALWAYS ||
self.spawnflags &
SPAWNFLAG_MONSTER_PASSIVE_UNTIL_ATTACKED)
{
if (self.sightsound)
self.sightsound ();
}
ai_hunttarget ();
// thanks RennyC -- dumptruck_ds
if (self.sight_trigger == 1)
{
activator = self.enemy;
sub_useandforgettargets ();
}
};
//--------------------------------------------------------------
// FindTarget
//
// Self is currently not attacking anything, so try to find a target
//
// Returns TRUE if an enemy was sighted
//
// When a player fires a missile, the point of impact becomes a
// fakeplayer so that monsters that see the impact will respond as
// if they had seen the player.
//
// To avoid spending too much time, only a single client (or
// fakeclient) is checked each frame. This means multi player games
// will have slightly slower noticing monsters.
//--------------------------------------------------------------
float() ai_findtarget =
{
// don't attempt to find a target during intermission -- CEV
if (intermission)
return FALSE;
local entity client;
local float r;
// if the first spawnflag bit is set, the monster will only
// wake up on really seeing the player, not another monster
// getting angry
// spawnflags & 3 is a big hack, because zombie crucified
// used the first spawn flag prior to the ambush flag, and
// I forgot about it, so the second spawn flag works as well
if (sight_entity_time >= time - 0.1 && !(self.spawnflags & 3))
{
client = sight_entity;
if (client.enemy == self.enemy)
return TRUE;
}
else
{
client = checkclient ();
if (!client)
// current check entity isn't in PVS
return FALSE;
}
if ((self.spawnflags &
SPAWNFLAG_MONSTER_PASSIVE_UNTIL_ATTACKED) ||
(self.spawnflags & SPAWNFLAG_MONSTER_PASSIVE_ALWAYS))
{
return FALSE;
}
// from Copper -- dumptruck_ds
if (client.flags & FL_NOTARGET ||
client.movetype == MOVETYPE_NOCLIP)
{
return FALSE;
}
if (client.health <= 0)
return FALSE;
if (client.classtype != CT_PLAYER)
if (client.enemy.health <= 0)
return FALSE;
if (client == self.enemy)
return FALSE;
if (client.flags & FL_NOTARGET)
return FALSE;
if (client.items & IT_INVISIBILITY)
return FALSE;
r = ai_range (client);
if (r == RANGE_FAR)
return FALSE;
if (!ai_visible(client))
return FALSE;
if (r == RANGE_NEAR)
{
if (client.show_hostile < time && !(ai_infront(client)))
return FALSE;
}
else if (r == RANGE_MID)
{
/*
if (client.show_hostile < time || !ai_infront (client))
*/
if (!(ai_infront(client)))
return FALSE;
}
// got one
self.enemy = client;
if (self.enemy.classtype != CT_PLAYER)
{
self.enemy = self.enemy.enemy;
if (self.enemy.classtype != CT_PLAYER)
{
self.enemy = world;
return FALSE;
}
}
ai_foundtarget ();
return TRUE;
};
//--------------------------------------------------------------
// ai_face Stay facing the enemy
//--------------------------------------------------------------
void() ai_face =
{
self.ideal_yaw = vectoyaw (self.enemy.origin - self.origin);
changeyaw ();
self.SendFlags |= NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// FacingIdeal
//--------------------------------------------------------------
float() ai_facing_ideal =
{
local float delta;
delta = anglemod (self.angles_y - self.ideal_yaw);
if (delta > 45 && delta < 315)
return FALSE;
return TRUE;
};
//--------------------------------------------------------------
void(float dist) ai_forward =
{
// dprint ("ai_forward\n");
walkmove (self.angles_y, dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
void(float dist) ai_back =
{
// dprint ("ai_back\n");
walkmove ((self.angles_y + 180), dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_pain -- stagger back a bit
//--------------------------------------------------------------
void(float dist) ai_pain =
{
ai_back (dist);
/*
local float away;
away = anglemod (vectoyaw (self.origin - self.enemy.origin)
+ 180 * (random() - 0.5));
walkmove (away, dist);
*/
};
//--------------------------------------------------------------
// ai_painforward -- stagger back a bit
//--------------------------------------------------------------
void(float dist) ai_painforward =
{
// dprint ("ai_painforward\n");
walkmove (self.ideal_yaw, dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_walk -- The monster is walking its beat
//--------------------------------------------------------------
void(float dist) ai_walk =
{
self.SendFlags |= NETFLAG_BASE_ENTITY_FRAME;
if (self.health < 1)
return;
// find waterlevel and watertype for walking monsters -- CEV
if (!(self.classgroup & CG_MONSTER_SWIM) &&
!(self.classgroup & CG_MONSTER_FLY))
{
base_entity_positioncontents (self);
base_monster_liquiddamage ();
if (self.health < 1)
return;
}
movedist = dist;
// check for noticing a player
if (ai_findtarget())
return;
movetogoal (dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_stand -- The monster is staying in one place for a while,
// with slight angle turns
//--------------------------------------------------------------
void() ai_stand =
{
// instead of setting the FRAME netflag here let individual
// monster think functions take care of it -- CEV
// TODO CEV
if (!(self.SendFlags & NETFLAG_BASE_ENTITY_FRAME))
self.SendFlags |= NETFLAG_BASE_ENTITY_FRAME;
if (self.health < 1)
return;
// find waterlevel and watertype for walking monsters -- CEV
if (!(self.classgroup & CG_MONSTER_SWIM) &&
!(self.classgroup & CG_MONSTER_FLY))
{
base_entity_positioncontents (self);
base_monster_liquiddamage ();
if (self.health < 1)
return;
}
if (ai_findtarget())
return;
if (time > self.pausetime)
{
self.th_walk ();
return;
}
// change angle slightly -- TODO CEV this comment was
// in PD3 source but had no associated code
};
//--------------------------------------------------------------
// ai_turn -- don't move, but turn towards ideal_yaw
//--------------------------------------------------------------
void() ai_turn =
{
if (ai_findtarget())
return;
changeyaw ();
self.SendFlags |= NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_run_melee
// Turn and close until within an angle to launch a melee attack
//--------------------------------------------------------------
void() ai_run_melee =
{
self.ideal_yaw = enemy_yaw;
changeyaw ();
if (ai_facing_ideal())
{
self.th_melee ();
self.attack_state = AS_STRAIGHT;
}
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_run_missile
// Turn in place until within an angle to launch a missile attack
//--------------------------------------------------------------
void() ai_run_missile =
{
self.ideal_yaw = enemy_yaw;
changeyaw ();
if (ai_facing_ideal())
{
if (self.spawnflags & SPAWNFLAG_MONSTER_TURRET)
self.th_turret ();
else
self.th_missile ();
self.attack_state = AS_STRAIGHT;
}
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_run_slide
// Strafe sideways, but stay at approximately the same range
//--------------------------------------------------------------
void() ai_run_slide =
{
local float ofs;
self.ideal_yaw = enemy_yaw;
changeyaw ();
if (self.lefty)
ofs = 90;
else
ofs = -90;
if (walkmove(self.ideal_yaw + ofs, movedist))
{
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
return;
}
self.lefty = 1 - self.lefty;
walkmove (self.ideal_yaw - ofs, movedist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_run -- The monster has an enemy it is trying to kill
//--------------------------------------------------------------
void(float dist) ai_run =
{
// dprint ("ai_run\n");
if (self.health < 1)
return;
// find waterlevel and watertype for walking monsters -- CEV
if (!(self.classgroup & CG_MONSTER_SWIM) &&
!(self.classgroup & CG_MONSTER_FLY))
{
base_entity_positioncontents (self);
base_monster_liquiddamage ();
if (self.health < 1)
return;
}
movedist = dist;
// see if the enemy is a corpse, dead, or if we're passive
if ((self.enemy.health <= 0) ||
(self.enemy.solid == SOLID_NOT) ||
(self.enemy.solid == SOLID_CORPSE) ||
(self.spawnflags & SPAWNFLAG_MONSTER_PASSIVE_ALWAYS))
{
self.enemy = world;
// FIXME: look all around for other targets
if (self.oldenemy.health > 0)
{
self.enemy = self.oldenemy;
ai_hunttarget ();
}
else
{
if (self.spawnflags & SPAWNFLAG_MONSTER_TURRET)
{
self.th_stand ();
}
else if (self.movetarget)
{
self.th_walk ();
}
else
{
self.th_stand ();
}
return;
}
}
// wake up other monsters
self.show_hostile = time + 1;
// check knowledge of enemy
enemy_vis = ai_visible (self.enemy);
if (enemy_vis)
self.search_time = time + 5;
// look for other coop players
if (coop && self.search_time < time)
{
if (ai_findtarget())
return;
}
enemy_infront = ai_infront (self.enemy);
enemy_range = ai_range (self.enemy);
enemy_yaw = vectoyaw (self.enemy.origin - self.origin);
if (self.spawnflags & SPAWNFLAG_MONSTER_TURRET)
ai_face ();
if (self.attack_state == AS_MISSILE)
{
ai_run_missile ();
return;
}
if (self.attack_state == AS_MELEE)
{
ai_run_melee ();
return;
}
if (ai_checkattack())
// beginning an attack
return;
if (self.attack_state == AS_SLIDING)
{
ai_run_slide ();
return;
}
// part of monster face from TheSolipsist
// urged to change positions
if (time < self.t_length)
{
// if orientation is forced
changeyaw ();
if (walkmove(self.ideal_yaw, dist))
{
self.SendFlags |=
NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
return;
}
// dodge left
self.ideal_yaw += 30;
changeyaw ();
if (walkmove(self.ideal_yaw, dist))
{
self.SendFlags |=
NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
return;
}
// dodge right
self.ideal_yaw -= 60;
changeyaw ();
changeyaw ();
if (walkmove(self.ideal_yaw, dist))
{
self.SendFlags |=
NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
return;
}
// give up
self.ideal_yaw += 30;
changeyaw();
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
// lose patience
self.touch_time = self.touch_time - 0.1;
return;
}
if (!(self.spawnflags & SPAWNFLAG_MONSTER_TURRET))
{
// keeps monster from moving to player - dumptruck_ds
// head straight in -- done in C code...
movetogoal (dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
}
};
//--------------------------------------------------------------
// ai_charge -- The monster is in a melee attack, so get as close
// as possible to .enemy
//--------------------------------------------------------------
void(float dist) ai_charge =
{
ai_face ();
// done in C code...
movetogoal (dist);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
void() ai_charge_side =
{
local vector dtemp;
local float heading;
// aim to the left of the enemy for a flyby
self.ideal_yaw = vectoyaw (self.enemy.origin - self.origin);
changeyaw ();
makevectors (self.angles);
dtemp = self.enemy.origin - 30 * v_right;
heading = vectoyaw (dtemp - self.origin);
walkmove (heading, 20);
self.SendFlags |= NETFLAG_BASE_ENTITY_ORIGIN_X |
NETFLAG_BASE_ENTITY_ORIGIN_Y |
NETFLAG_BASE_ENTITY_ORIGIN_Z |
NETFLAG_BASE_ENTITY_ANGLES;
};
//--------------------------------------------------------------
// ai_melee
//--------------------------------------------------------------
void() ai_melee =
{
local vector delta;
local float ldmg;
if (!self.enemy)
// removed before stroke
return;
delta = self.enemy.origin - self.origin;
if (vlen(delta) > 60)
return;
ldmg = (random() + random() + random()) * 3;
t_damage2 (self.enemy, self, self, ldmg);
};
//--------------------------------------------------------------
void() ai_melee_side =
{
local vector delta;
local float ldmg;
if (!self.enemy)
// removed before stroke
return;
ai_charge_side ();
delta = self.enemy.origin - self.origin;
if (vlen(delta) > 60)
return;
if (!can_damage(self, self.enemy))
return;
ldmg = (random() + random() + random()) * 3;
t_damage2 (self.enemy, self, self, ldmg);
};
//==============================================================
// SUBS
//==============================================================
//--------------------------------------------------------------
// SUB_AttackFinished
// in nightmare mode, all attack_finished times become 0
// some monsters refire twice automatically
//--------------------------------------------------------------
void(float normal) sub_attackfinished =
{
// refire count for nightmare
self.cnt = 0;
if (skill != 3)
self.attack_finished = time + normal;
};
//--------------------------------------------------------------
void(void() nextfunc) sub_checkrefire =
{
if (skill != 3)
return;
if (self.cnt == 1)
return;
if (!ai_visible(self.enemy))
return;
self.cnt = 1;
self.think = nextfunc;
};
//--------------------------------------------------------------
// SUB_FieldIsTargeted
//
// Return TRUE if the "fld" field of this entity is non-empty and
// matches the target (or target2/3/4 or pain_target) field of
// any other entity, otherwise return FALSE. -- iw
//--------------------------------------------------------------
float(.string fld) sub_fieldistargeted =
{
if (self.fld == "")
return FALSE;
// the following function calls are staggered to avoid
// the silly "return value conflict" problem with
// traditional compilers -- iw
if (find(world, target, self.fld) != world)
return TRUE;
if (find(world, target2, self.fld) != world)
return TRUE;
if (find(world, target3, self.fld) != world)
return TRUE;
if (find(world, target4, self.fld) != world)
return TRUE;
if (find(world, pain_target, self.fld) != world)
return TRUE;
return FALSE;
};
//--------------------------------------------------------------
// SUB_IsTargeted
//
// Return TRUE if the targetname (or targetname2/3/4) field of
// this entity is non-empty and matches the target (or target2/3/4
// or pain_target) field of any other entity, otherwise return
// FALSE. -- iw
//--------------------------------------------------------------
float() sub_istargeted =
{
// the following function calls are staggered to avoid
// the silly "return value conflict" problem with
// traditional compilers -- iw
if (sub_fieldistargeted(targetname))
return TRUE;
if (sub_fieldistargeted(targetname2))
return TRUE;
if (sub_fieldistargeted(targetname3))
return TRUE;
if (sub_fieldistargeted(targetname4))
return TRUE;
return FALSE;
};
//--------------------------------------------------------------
// monster_pain_use -- dumptruck_ds
//
// When a monster reaches pain_threshold, it fires all of its
// pain_targets with the current enemy as activator.
//--------------------------------------------------------------
void() sub_pain_use =
{
if (!self.pain_target)
return;
activator = self.enemy;
// SUB_UsePain ();
if (self.pain_target != "")
{
sub_usetarget (self.pain_target, targetname);
sub_usetarget (self.pain_target, targetname2);
sub_usetarget (self.pain_target, targetname3);
sub_usetarget (self.pain_target, targetname4);
}
// dumptruck_ds via Discord - thanks Spike, Snaut and QueenJazz
self.pain_target = "";
};
//==============================================================
// Interaction
//==============================================================
//--------------------------------------------------------------
void() base_monster_think_teleport_start =
{
// fix for cumulative delays for counters etc. -- dumptruck_ds
self.delay = 0;
// run the stored think -- must set model, size, etc -- CEV
if (self.think1)
self.think1 ();
// override the random delay the start function applies
self.nextthink = time + 0.1;
if (!(self.spawnflags & SPAWNFLAG_MONSTER_SPAWNED)) {
if (!(self.spawnflags & SPAWNFLAG_MONSTER_SILENT))
{
// dumptruck_ds: if wait value is > 0 spawn silently
if (self.wait == 0)
spawn_tfog (self.origin);
spawn_tdeath (self.origin, self);
} }
if (!(self.SendEntity))
{
// make sure monster is sent to CSQC -- CEV
self.SendEntity = base_entity_netsend;
self.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
}
};
#endif
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
// monster_touch -- was in monsters.qc -- CEV
//--------------------------------------------------------------
void() base_monster_touch =
{
// 1998-09-16 Sliding/not-jumping on monsters/boxes/players
// fix by Maddes/Kryten start
// by: Philip Martin aka: Kryten
// When on top of monsters or players you slide. This is a
// QuakeC problem. The function below fixes that problem.
// based on code given to Kryten by: Michael Turitzin (MaNiAc)
// can cause problems for monsters on top of a player,
// so only players
if (other.classtype != CT_PLAYER)
return;
if (other.health <= 0)
return;
if ((!(other.flags & FL_ONGROUND)) &&
((other.absmin_z >= self.absmax_z - 2)))
{
other.flags |= FL_ONGROUND;
return;
}
// you can add other stuff like pushable players/monsters here
// will do Kryten, thanks for the tip -- CEV
// base_entity_push (self, other, PM_MAXSPEED);
// 1998-09-16 Sliding/not-jumping on monsters/boxes/players
// fix by Maddes/Kryten end
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
// monster_use -- Using a monster makes it angry at the activator
//--------------------------------------------------------------
void() base_monster_use_angry =
{
if (self.enemy)
return;
if (self.health <= 0)
return;
if (activator.items & IT_INVISIBILITY)
return;
if (activator.flags & FL_NOTARGET)
return;
if (activator.movetype == MOVETYPE_NOCLIP)
// Copper -- dumptruck_ds
return;
if (activator.classtype != CT_PLAYER)
return;
// delay reaction so if the monster is teleported,
// its sound is still heard
self.enemy = activator;
self.think = ai_foundtarget;
self.nextthink = time + 0.1;
};
//--------------------------------------------------------------
// WAITWALK functionality from MG1 -- CEV
//--------------------------------------------------------------
void() base_monster_use_beginwalk =
{
self.use = base_monster_use_angry;
self.pausetime = 0;
self.th_walk ();
};
//--------------------------------------------------------------
// monster_teleport_delay
//--------------------------------------------------------------
void() base_monster_use_teledelay =
{
// new from Qmaster func coding help thread
self.think = base_monster_think_teleport_start;
if (self.delay == -1)
{
// if delay is set to -1 random delay
// from 0.1 to 1 second - dumptruck_ds
self.nextthink = time + 0.1 + random();
return;
}
self.nextthink = time + 0.1 + self.delay;
};
//--------------------------------------------------------------
// monster_death_use
//
// When a monster dies, it fires all of its targets with the
// current enemy as activator.
//--------------------------------------------------------------
void() base_monster_use_death =
{
// fall to ground
if (self.flags & FL_FLY)
self.flags &= ~FL_FLY;
if (self.flags & FL_SWIM)
self.flags &= ~FL_SWIM;
if (!self.target)
return;
if (self.infight_activator)
activator = self.infight_activator;
else
activator = self.enemy;
sub_usetargets ();
};
//==============================================================
// Initialization
//==============================================================
//--------------------------------------------------------------
entity(vector org, vector ang, float sflags, float yaw,
void(entity e) initfn) spawn_base_monster =
{
local entity e = spawn ();
e.spawnflags = sflags;
e.origin = org;
e.angles = ang;
e.yaw_speed = yaw;
setorigin (e, e.origin);
if (initfn)
initfn (e);
return e;
};
//--------------------------------------------------------------
#define BASE_MONSTER_PREINIT(func) \
/* { */ \
/* remap flags for Dimension Of The Machine -- CEV */ \
if (known_release == KNOWN_RELEASE_MG1) \
{ \
compat_mg1_monster_spawnflags (); \
} \
/* call func (if it's valid) to remap fields -- CEV */ \
/* run before inhibit in case it alters spawnflags -- CEV */ \
base_mapentity_init_spawndata (func); \
/* new spawnflags for all entities -- iw */ \
if (SUB_Inhibit()) \
return; \
/* } */
//--------------------------------------------------------------
void(string key, string value) base_monster_init_field =
{
switch (key)
{
case "berserk":
local float zerk = stof (value);
if (zerk)
self.spawnflags |=
SPAWNFLAG_MONSTER_BERSERK;
break;
case "spawn_angry":
local float angry = stof (value);
if (angry)
self.spawnflags |=
SPAWNFLAG_MONSTER_ANGRY;
break;
}
};
//--------------------------------------------------------------
// monster_teleport_check
//
// This detects and eliminates a common map bug: a trigger-spawned
// monster which can't be activated either because it has no
// targetname or because its targetname isn't targeted by any
// other entity. (This map bug would otherwise make it impossible
// for the player to get 100% kills.) -- iw
//--------------------------------------------------------------
void() base_monster_init_teleport_check =
{
if (!sub_istargeted())
{
dprint (sprintf("base_monster_init_teleport_check: "
"WARNING: removed untargeted trigger-spawned "
"%s at %v\n", self.classname, self.origin));
base_entity_remove (self);
return;
}
// the targetname appears to be OK, so let's finish
// setting up the trigger-spawned monster -- iw
// qmaster
self.touch = sub_null;
self.use = base_monster_use_teledelay;
monster_update_total (1);
};
//--------------------------------------------------------------
float(entity e, void() start_fn) base_monster_init_teleport =
{
if(!(e.spawnflags & SPAWNFLAG_MONSTER_TELEWAIT))
return FALSE;
e.model = "";
e.modelindex = 0;
e.solid = SOLID_NOT;
e.movetype = MOVETYPE_NONE;
e.think1 = start_fn;
// wait for other entities to finish spawning, then check that
// something targets self -- iw
e.think = base_monster_init_teleport_check;
e.nextthink = time + 0.1;
return TRUE;
};
//--------------------------------------------------------------
void() base_monster_init_start =
{
#if 0
dprint (sprintf("base_monster_init_start: "
"initializing %s at %v\n",
self.classname, self.origin));
#endif
self.solid = SOLID_SLIDEBOX;
self.movetype = MOVETYPE_STEP;
self.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
if (self.mdl != __NULL__ && self.mdl != "")
setmodel (self, self.mdl);
else
setmodel (self, self.model);
if (self.pos1 || self.pos2)
setsize (self, self.pos1, self.pos2);
else
setsize (self, self.mins, self.maxs);
self.flags |= FL_MONSTER;
if (!(self.classgroup & CG_MONSTER_FLY) &&
!(self.classgroup & CG_MONSTER_SWIM))
{
// Preach's "check" here
if (!(self.spawnflags & SPAWNFLAG_MONSTER_TELEWAIT))
{
// raise off floor a bit
self.origin_z += 1;
droptofloor ();
}
}
else
{
if (self.classgroup & CG_MONSTER_FLY)
self.flags |= FL_FLY;
if (self.classgroup & CG_MONSTER_SWIM)
self.flags |= FL_SWIM;
}
if (!walkmove(0,0))
{
dprint (sprintf("base_monster_init_start: %s in wall "
"at %v, target = '%s', targetname = '%s'\n",
self.classname, self.origin,
self.target, self.targetname));
}
if (self.spawnflags & SPAWNFLAG_MONSTER_SPAWNED)
{
// dumptruck_ds: if wait value is > 0 spawn silently
if (self.wait == 0)
spawn_tfog (self.origin);
spawn_tdeath (self.origin, self);
}
self.contentstransition = base_monster_contentstransition;
self.takedamage = DAMAGE_AIM;
self.touch = base_monster_touch;
self.use = base_monster_use_angry;
self.view_ofs = '0 0 25';
self.ideal_yaw = self.angles * '0 1 0';
if (!self.yaw_speed)
self.yaw_speed = 20;
if (self.target != __NULL__ && self.target != "")
{
self.goalentity = find (world, targetname, self.target);
self.movetarget = self.goalentity;
if (self.goalentity)
self.ideal_yaw = vectoyaw (
self.goalentity.origin - self.origin);
// this used to be an objerror
if (!self.movetarget)
{
dprint (sprintf("base_monster_init_start: "
"%s at %v can't find target\n",
self.classname, self.origin));
}
if (self.movetarget.classtype == CT_PATH_CORNER)
{
if (self.spawnflags&SPAWNFLAG_MONSTER_WAITWALK)
{
self.pausetime = 99999999;
self.th_stand ();
self.use = base_monster_use_beginwalk;
}
else
{
self.th_walk ();
}
}
else
{
self.pausetime = 99999999;
self.th_stand ();
}
}
else
{
self.pausetime = 99999999;
self.th_stand ();
}
if (known_release == KNOWN_RELEASE_MG1)
{
if (self.spawnflags & SPAWNFLAG_MONSTER_SPAWNED &&
self.spawnflags & SPAWNFLAG_MONSTER_ANGRY)
{
// this is Shamblernaut's method -- dumptruck_ds
local entity pl;
pl = findfloat (world, classtype, CT_PLAYER);
activator = pl;
base_monster_use_angry ();
}
else
{
self.nextthink = time + 0.1 + random() * 0.5;
}
}
else
{
// spread think times so they don't all happen at once
// 1998-08-14 Monsters sometimes do not move fix
// by Lord Sméagol start
self.nextthink = time + 0.1 + random() * 0.5;
// 1998-08-14 Monsters sometimes do not move fixx
// by Lord Sméagol end
// anger the monster if requested -- CEV
if (self.spawnflags & SPAWNFLAG_MONSTER_ANGRY)
{
// this is Shamblernaut's method -- dumptruck_ds
local entity pl2;
pl2 = findfloat (world, classtype, CT_PLAYER);
activator = pl2;
base_monster_use_angry ();
}
}
// all monsters get transmitted to CSQC -- CEV
self.SendEntity = base_entity_netsend;
self.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
};
#endif
#if defined(CSQC) || defined(SSQC)
//--------------------------------------------------------------
void(entity e) base_monster_init =
{
#ifdef SSQC
// Preach's tutorial
if (autocvar(nomonsters, 0))
{
remove (e);
return;
}
#endif
e.classgroup |= CG_MONSTER;
base_mapentity_init (e);
#ifdef CSQC
// set touch immediately -- CEV
e.touch = base_monster_touch;
// set fly/swim flags on the client -- CEV
if (e.classgroup & CG_MONSTER_FLY)
e.flags |= FL_FLY;
if (e.classgroup & CG_MONSTER_SWIM)
e.flags |= FL_SWIM;
// if we have an origin set it -- CEV
if (e.origin)
setorigin (e, e.origin);
// generic flags & masks for the client side -- CEV
e.drawmask = DRAWMASK_NORMAL;
e.flags |= FL_MONSTER;
e.movetype = MOVETYPE_NONE;
e.solid = SOLID_SLIDEBOX;
// generic monster predraw (interpolates angles, origin, and
// frames). See above. -- CEV
e.predraw = base_monster_predraw;
#endif
#ifdef SSQC
// Preach's tutorial
if (base_monster_init_teleport(e, base_monster_init_start))
// this monster is setup to teleport in; exit early
return;
total_monsters += 1;
if (self.spawnflags & SPAWNFLAG_MONSTER_SPAWNED)
{
// this monster will initialize when used -- CEV
e.use = base_monster_init_start;
}
else
{
// normal start -- CEV
e.think = base_monster_init_start;
e.nextthink = time + 0.1 + random() * 0.5;
}
#endif
};
#endif
#ifdef SSQC
//--------------------------------------------------------------
strip void() base_monster =
{
base_monster_init (self);
};
#endif
// };
#ifdef SSQC
//----------------------------------------------------------------------
// Corpse base class, used for both converting dead monsters into corpses
// and for DeadStuff mod mapper-placeable corpses -- CEV
//----------------------------------------------------------------------
// class base_corpse: base_mapentity
// {
//--------------------------------------------------------------
// Convert an entity into a shootable corpse. Call at the end of
// a monster's death think. Uses FTE's SOLID_CORPSE. Inspired by
// / based on Kryten's gibbable corpse tutorial found at
// https://www.insideqc.com/qctut/qctut-33.shtml -- CEV
//--------------------------------------------------------------
void(entity e, float corpse_health) become_base_corpse =
{
e.classgroup |= CG_CORPSE;
// set up trigger interaction
if (e.flags & FL_MONSTER)
e.flags &= ~FL_MONSTER;
// re-set the monster/corpse's health -- CEV
if (corpse_health)
e.health = corpse_health;
else
e.health = CORPSE_HEALTH;
// e.movetype = MOVETYPE_STEP;
e.movetype = MOVETYPE_TOSS;
e.solid = SOLID_CORPSE;
e.takedamage = DAMAGE_YES;
// clear targets
e.killtarget = e.killtarget2 = __NULL__;
e.pain_target = __NULL__;
e.target = e.target2 = e.target3 = e.target4 = __NULL__;
// clear everything but destroy and think
// leave e.destroy alone, the existing destroy will handle it
e.th_pain = sub_nullpain;
// leave e.think alone so e's animation can finish
e.touch = sub_null;
e.use = sub_null;
// clear monster think functions
e.th_melee = sub_null;
e.th_missile = sub_null;
e.th_run = sub_null;
e.th_stand = sub_null;
e.th_turret = sub_null;
e.th_walk = sub_null;
};
//--------------------------------------------------------------
void(entity e) base_corpse_init =
{
base_mapentity_init (e);
e.classgroup |= CG_CORPSE;
if (e.spawnflags & SPAWNFLAG_CORPSE_SOLID)
e.solid = SOLID_BBOX;
else
e.solid = SOLID_NOT;
};
//--------------------------------------------------------------
strip void() base_corpse =
{
base_corpse_init (self);
};
// };
#endif
Return to the top of this page or return to the overview of this repo.
Log base_monster.qc
| Date | Commit Message | Author | + | - |
|---|---|---|---|---|
| 2025-03-30 | Big commit. Entity networking, etc. | cev | +642 | -480 |
| 2024-09-17 | Ice, improved stairs, other movement changes | cev | +2 | -3 |
| 2024-06-26 | pmove fixes, GL now a faux tribolt, wall climbing | cev | +13 | -1 |
| 2024-06-15 | Major update, committing as-is, will have bugs | cev | +221 | -46 |
| 2024-04-08 | Registered monsters, projectile bugfixes | cev | +1 | |
| 2024-04-05 | Player footsteps, shareware monsters, misc? | cev | +651 | -703 |
| 2024-03-24 | Fix projectile and func_ blocked interaction | cev | +5 | |
| 2024-03-24 | 2nd pass refactor, rework QC class structure | cev | +33 | -2 |
| 2024-02-27 | Bullet projectile, pmove changes, misc | cev | +22 | |
| 2024-02-18 | Client/player, projectiles, entrypoints refactor | cev | +411 | -27 |
| 2024-01-31 | Class based monster refactor & start projectiles | cev | +1503 | -1 |
| 2024-01-09 | Continue OO / Class-based refactor | cev | +12 |
Return to the top of this page or return to the overview of this repo.