rogue
/
quake2-rogue
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
quake2-rogue/m_carrier.c

1306 lines
35 KiB
C
Raw Blame History

/*
==============================================================================
carrier
==============================================================================
*/
// self->timestamp used for frame calculations in grenade & spawn code
// self->wait used to prevent rapid refire of rocket launcher
#include "g_local.h"
#include "m_carrier.h"
#define CARRIER_ROCKET_TIME 2 // number of seconds between rocket shots
#define CARRIER_ROCKET_SPEED 750
#define NUM_FLYERS_SPAWNED 6 // max # of flyers he can spawn
#define RAIL_FIRE_TIME 3
void BossExplode (edict_t *self);
void Grenade_Explode (edict_t *ent);
qboolean infront (edict_t *self, edict_t *other);
qboolean inback (edict_t *self, edict_t *other);
qboolean below (edict_t *self, edict_t *other);
void drawbbox (edict_t *self);
//char *ED_NewString (char *string);
void ED_CallSpawn (edict_t *ent);
static int sound_pain1;
static int sound_pain2;
static int sound_pain3;
static int sound_death;
//static int sound_search1;
static int sound_sight;
static int sound_rail;
static int sound_spawn;
float orig_yaw_speed;
vec3_t flyer_mins = {-16, -16, -24};
vec3_t flyer_maxs = {16, 16, 16};
extern mmove_t flyer_move_attack2, flyer_move_attack3, flyer_move_kamikaze;
void carrier_run (edict_t *self);
void carrier_stand (edict_t *self);
void carrier_dead (edict_t *self);
void carrier_attack (edict_t *self);
void carrier_attack_mg (edict_t *self);
void carrier_reattack_mg (edict_t *self);
void carrier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
void carrier_attack_gren (edict_t *self);
void carrier_reattack_gren (edict_t *self);
void carrier_start_spawn (edict_t *self);
void carrier_spawn_check (edict_t *self);
void carrier_prep_spawn (edict_t *self);
void CarrierMachineGunHold (edict_t *self);
void CarrierRocket (edict_t *self);
void carrier_sight (edict_t *self, edict_t *other)
{
gi.sound (self, CHAN_VOICE, sound_sight, 1, ATTN_NORM, 0);
}
// code starts here
//void carrier_search (edict_t *self)
//{
// if (random() < 0.5)
// gi.sound (self, CHAN_VOICE, sound_search1, 1, ATTN_NONE, 0);
//}
//
// this is the smarts for the rocket launcher in coop
//
// if there is a player behind/below the carrier, and we can shoot, and we can trace a LOS to them ..
// pick one of the group, and let it rip
void CarrierCoopCheck (edict_t *self)
{
// no more than 4 players in coop, so..
edict_t *targets[4];
int num_targets = 0, target, player;
edict_t *ent;
trace_t tr;
// if we're not in coop, this is a noop
if (!coop || !coop->value)
return;
// if we are, and we have recently fired, bail
if (self->wait > level.time)
return;
memset (targets, 0, 4*sizeof(edict_t *));
// cycle through players
for (player = 1; player <= game.maxclients; player++)
{
ent = &g_edicts[player];
if (!ent->inuse)
continue;
if (!ent->client)
continue;
if (inback(self, ent) || below(self, ent))
{
tr = gi.trace (self->s.origin, NULL, NULL, ent->s.origin, self, MASK_SOLID);
if (tr.fraction == 1.0)
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("Carrier: found a player who I can shoot\n");
targets[num_targets++] = ent;
}
}
}
if (!num_targets)
return;
// get a number from 0 to (num_targets-1)
target = random() * num_targets;
// just in case we got a 1.0 from random
if (target == num_targets)
target--;
// make sure to prevent rapid fire rockets
self->wait = level.time + CARRIER_ROCKET_TIME;
// save off the real enemy
ent = self->enemy;
// set the new guy as temporary enemy
self->enemy = targets[target];
CarrierRocket (self);
// put the real enemy back
self->enemy = ent;
// we're done
return;
}
void CarrierGrenade (edict_t *self)
{
vec3_t start;
vec3_t forward, right, up;
vec3_t aim;
int flash_number;
float direction; // from lower left to upper right, or lower right to upper left
float spreadR, spreadU;
int mytime;
CarrierCoopCheck(self);
if (!self->enemy)
return;
if (random() < 0.5)
direction = -1.0;
else
direction = 1.0;
mytime = (int)((level.time - self->timestamp)/0.4);
if (mytime == 0)
{
spreadR = 0.15 * direction;
// spreadU = 0.1 * direction;
spreadU = 0.1 - 0.1 * direction;
}
else if (mytime == 1)
{
spreadR = 0;
// spreadU = 0;
spreadU = 0.1;
}
else if (mytime == 2)
{
spreadR = -0.15 * direction;
// spreadU = -0.1 * direction;
spreadU = 0.1 - -0.1 * direction;
}
else if (mytime == 3)
{
spreadR = 0;
// spreadU = 0;
spreadU = 0.1;
}
else
{
// error, shoot straight
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("CarrierGrenade: bad time %2.2f %2.2f\n", level.time, self->timestamp);
spreadR = 0;
spreadU = 0;
}
AngleVectors (self->s.angles, forward, right, up);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_GRENADE], forward, right, start);
VectorSubtract (self->enemy->s.origin, start, aim);
VectorNormalize (aim);
VectorMA (aim, spreadR, right, aim);
VectorMA (aim, spreadU, up, aim);
if(aim[2] > 0.15)
aim[2] = 0.15;
else if(aim[2] < -0.5)
aim[2] = -0.5;
flash_number = MZ2_GUNNER_GRENADE_1;
monster_fire_grenade (self, start, aim, 50, 600, flash_number);
}
void CarrierPredictiveRocket (edict_t *self)
{
vec3_t forward, right;
vec3_t start;
vec3_t dir;
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf("predictive fire\n");
AngleVectors (self->s.angles, forward, right, NULL);
//1
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_1], forward, right, start);
PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, -0.3, dir, NULL);
monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_1);
//2
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_2], forward, right, start);
PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, -0.15, dir, NULL);
monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_2);
//3
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_3], forward, right, start);
PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, 0, dir, NULL);
monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_3);
//4
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_4], forward, right, start);
PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, 0.15, dir, NULL);
monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_4);
}
void CarrierRocket (edict_t *self)
{
vec3_t forward, right;
vec3_t start;
vec3_t dir;
vec3_t vec;
if(self->enemy)
{
if(self->enemy->client && random() < 0.5)
{
CarrierPredictiveRocket(self);
return;
}
}
else
return;
AngleVectors (self->s.angles, forward, right, NULL);
//1
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_1], forward, right, start);
VectorCopy (self->enemy->s.origin, vec);
// vec[2] += self->enemy->viewheight;
vec[2] -= 15;
VectorSubtract (vec, start, dir);
VectorNormalize (dir);
VectorMA (dir, 0.4, right, dir);
VectorNormalize (dir);
monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_1);
//2
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_2], forward, right, start);
VectorCopy (self->enemy->s.origin, vec);
// vec[2] += self->enemy->viewheight;
VectorSubtract (vec, start, dir);
VectorNormalize (dir);
VectorMA (dir, 0.025, right, dir);
VectorNormalize (dir);
monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_2);
//3
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_3], forward, right, start);
VectorCopy (self->enemy->s.origin, vec);
// vec[2] += self->enemy->viewheight;
VectorSubtract (vec, start, dir);
VectorNormalize (dir);
VectorMA (dir, -0.025, right, dir);
VectorNormalize (dir);
monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_3);
//4
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_4], forward, right, start);
VectorCopy (self->enemy->s.origin, vec);
// vec[2] += self->enemy->viewheight;
vec[2] -= 15;
VectorSubtract (vec, start, dir);
VectorNormalize (dir);
VectorMA (dir, -0.4, right, dir);
VectorNormalize (dir);
monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_4);
//5
// G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_BOSS2_ROCKET_4], forward, right, start);
// VectorCopy (self->enemy->s.origin, vec);
// vec[2] += self->enemy->viewheight;
// VectorSubtract (vec, start, dir);
// VectorNormalize (dir);
// monster_fire_rocket (self, start, dir, 50, 500, MZ2_BOSS2_ROCKET_2);
}
void carrier_firebullet_right (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
int flashnum;
// if we're in manual steering mode, it means we're leaning down .. use the lower shot
if (self->monsterinfo.aiflags & AI_MANUAL_STEERING)
flashnum = MZ2_CARRIER_MACHINEGUN_R2;
else
flashnum = MZ2_CARRIER_MACHINEGUN_R1;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
// VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
VectorMA (self->enemy->s.origin, 0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
/*
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_DEBUGTRAIL);
gi.WritePosition (start);
gi.WritePosition (target);
gi.multicast (start, MULTICAST_ALL);
*/
VectorSubtract (target, start, forward);
VectorNormalize (forward);
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD*3, DEFAULT_BULLET_VSPREAD, flashnum);
}
void carrier_firebullet_left (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
int flashnum;
// if we're in manual steering mode, it means we're leaning down .. use the lower shot
if (self->monsterinfo.aiflags & AI_MANUAL_STEERING)
flashnum = MZ2_CARRIER_MACHINEGUN_L2;
else
flashnum = MZ2_CARRIER_MACHINEGUN_L1;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
// VectorMA (self->enemy->s.origin, 0.2, self->enemy->velocity, target);
VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract (target, start, forward);
/*
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_DEBUGTRAIL);
gi.WritePosition (start);
gi.WritePosition (target);
gi.multicast (start, MULTICAST_ALL);
*/
VectorNormalize (forward);
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD*3, DEFAULT_BULLET_VSPREAD, flashnum);
}
void CarrierMachineGun (edict_t *self)
{
CarrierCoopCheck(self);
if (self->enemy)
carrier_firebullet_left(self);
if (self->enemy)
carrier_firebullet_right(self);
}
void CarrierSpawn (edict_t *self)
{
vec3_t f, r, offset, startpoint, spawnpoint;
edict_t *ent;
int mytime;
// VectorSet (offset, 105, 0, -30); // real distance needed is (sqrt (56*56*2) + sqrt(16*16*2)) or 101.8
VectorSet (offset, 105, 0, -58); // real distance needed is (sqrt (56*56*2) + sqrt(16*16*2)) or 101.8
AngleVectors (self->s.angles, f, r, NULL);
G_ProjectSource (self->s.origin, offset, f, r, startpoint);
// the +0.1 is because level.time is sometimes a little low
mytime = (int)((level.time + 0.1 - self->timestamp)/0.5);
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("mytime = %d, (%2.2f)\n", mytime, level.time - self->timestamp);
if (FindSpawnPoint (startpoint, flyer_mins, flyer_maxs, spawnpoint, 32))
{
// the second flier should be a kamikaze flyer
if (mytime != 2)
ent = CreateMonster (spawnpoint, self->s.angles, "monster_flyer");
else
ent = CreateMonster (spawnpoint, self->s.angles, "monster_kamikaze");
if (!ent)
return;
gi.sound (self, CHAN_BODY, sound_spawn, 1, ATTN_NONE, 0);
self->monsterinfo.monster_slots--;
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("carrier: post-spawn : %d slots left\n", self->monsterinfo.monster_slots);
ent->nextthink = level.time;
ent->think (ent);
ent->monsterinfo.aiflags |= AI_SPAWNED_CARRIER|AI_DO_NOT_COUNT|AI_IGNORE_SHOTS;
ent->monsterinfo.commander = self;
if ((self->enemy->inuse) && (self->enemy->health > 0))
{
ent->enemy = self->enemy;
FoundTarget (ent);
if (mytime == 1)
{
ent->monsterinfo.lefty = 0;
ent->monsterinfo.attack_state = AS_SLIDING;
ent->monsterinfo.currentmove = &flyer_move_attack3;
}
else if (mytime == 2)
{
ent->monsterinfo.lefty = 0;
ent->monsterinfo.attack_state = AS_STRAIGHT;
ent->monsterinfo.currentmove = &flyer_move_kamikaze;
ent->mass = 100;
ent->monsterinfo.aiflags |= AI_CHARGING;
}
else if (mytime == 3)
{
ent->monsterinfo.lefty = 1;
ent->monsterinfo.attack_state = AS_SLIDING;
ent->monsterinfo.currentmove = &flyer_move_attack3;
}
// else if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("carrier: unexpected time %d!\n", mytime);
}
}
}
void carrier_prep_spawn (edict_t *self)
{
CarrierCoopCheck(self);
self->monsterinfo.aiflags |= AI_MANUAL_STEERING;
self->timestamp = level.time;
self->yaw_speed = 10;
CarrierMachineGun(self);
}
void carrier_spawn_check (edict_t *self)
{
// gi.dprintf ("times - %2.2f %2.2f\n", level.time, self->timestamp);
CarrierCoopCheck(self);
CarrierMachineGun(self);
CarrierSpawn (self);
if (level.time > (self->timestamp + 1.1)) // 0.5 seconds per flyer. this gets three
{
self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
self->yaw_speed = orig_yaw_speed;
return;
}
else
self->monsterinfo.nextframe = FRAME_spawn08;
}
void carrier_ready_spawn (edict_t *self)
{
float current_yaw;
vec3_t offset, f, r, startpoint, spawnpoint;
CarrierCoopCheck(self);
CarrierMachineGun(self);
current_yaw = anglemod(self->s.angles[YAW]);
// gi.dprintf ("yaws = %2.2f %2.2f\n", current_yaw, self->ideal_yaw);
if (fabs(current_yaw - self->ideal_yaw) > 0.1)
{
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
self->timestamp += FRAMETIME;
return;
}
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
VectorSet (offset, 105,0,-58);
AngleVectors (self->s.angles, f, r, NULL);
G_ProjectSource (self->s.origin, offset, f, r, startpoint);
if (FindSpawnPoint (startpoint, flyer_mins, flyer_maxs, spawnpoint, 32))
{
SpawnGrow_Spawn (spawnpoint, 0);
}
}
void carrier_start_spawn (edict_t *self)
{
int mytime;
float enemy_yaw;
vec3_t temp;
// vec3_t offset, f, r, startpoint;
CarrierCoopCheck(self);
if (!orig_yaw_speed)
orig_yaw_speed = self->yaw_speed;
if (!self->enemy)
return;
mytime = (int)((level.time - self->timestamp)/0.5);
VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
enemy_yaw = vectoyaw2(temp);
// note that the offsets are based on a forward of 105 from the end angle
if (mytime == 0)
{
self->ideal_yaw = anglemod(enemy_yaw - 30);
// VectorSet (offset, 90.9, 52.5, 0);
}
else if (mytime == 1)
{
self->ideal_yaw = anglemod(enemy_yaw);
// VectorSet (offset, 90.9, -52.5, 0);
}
else if (mytime == 2)
{
self->ideal_yaw = anglemod(enemy_yaw + 30);
// VectorSet (offset, 90.9, -52.5, 0);
}
// else if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("carrier: bad spawntime\n");
CarrierMachineGun (self);
}
mframe_t carrier_frames_stand [] =
{
// ai_stand, 0, drawbbox,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL,
ai_stand, 0, NULL
};
mmove_t carrier_move_stand = {FRAME_search01, FRAME_search13, carrier_frames_stand, NULL};
mframe_t carrier_frames_walk [] =
{
// ai_walk, 12, drawbbox,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL,
ai_walk, 4, NULL
};
mmove_t carrier_move_walk = {FRAME_search01, FRAME_search13, carrier_frames_walk, NULL};
mframe_t carrier_frames_run [] =
{
// ai_run, 12, drawbbox,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck,
ai_run, 6, CarrierCoopCheck
};
mmove_t carrier_move_run = {FRAME_search01, FRAME_search13, carrier_frames_run, NULL};
mframe_t carrier_frames_attack_pre_mg [] =
{
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, carrier_attack_mg
};
mmove_t carrier_move_attack_pre_mg = {FRAME_firea01, FRAME_firea08, carrier_frames_attack_pre_mg, NULL};
// Loop this
mframe_t carrier_frames_attack_mg [] =
{
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, carrier_reattack_mg
/*
ai_charge, 0, CarrierMachineGunHold,
// ai_charge, 0, CarrierMachineGun,
ai_charge, 0, CarrierMachineGun,
ai_charge, 0, carrier_reattack_mg
*/
};
mmove_t carrier_move_attack_mg = {FRAME_firea09, FRAME_firea11, carrier_frames_attack_mg, NULL};
mframe_t carrier_frames_attack_post_mg [] =
{
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck
};
mmove_t carrier_move_attack_post_mg = {FRAME_firea12, FRAME_firea15, carrier_frames_attack_post_mg, carrier_run};
mframe_t carrier_frames_attack_pre_gren [] =
{
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, carrier_attack_gren
};
mmove_t carrier_move_attack_pre_gren = {FRAME_fireb01, FRAME_fireb06, carrier_frames_attack_pre_gren, NULL};
mframe_t carrier_frames_attack_gren [] =
{
ai_charge, -15, CarrierGrenade,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, carrier_reattack_gren
};
mmove_t carrier_move_attack_gren = {FRAME_fireb07, FRAME_fireb10, carrier_frames_attack_gren, NULL};
mframe_t carrier_frames_attack_post_gren [] =
{
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck,
ai_charge, 4, CarrierCoopCheck
};
mmove_t carrier_move_attack_post_gren = {FRAME_fireb11, FRAME_fireb16, carrier_frames_attack_post_gren, carrier_run};
mframe_t carrier_frames_attack_rocket [] =
{
ai_charge, 15, CarrierRocket
};
mmove_t carrier_move_attack_rocket = {FRAME_fireb01, FRAME_fireb01, carrier_frames_attack_rocket, carrier_run};
void CarrierRail (edict_t *self)
{
vec3_t start;
vec3_t dir;
vec3_t forward, right;
CarrierCoopCheck(self);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_RAILGUN], forward, right, start);
// calc direction to where we targeted
VectorSubtract (self->pos1, start, dir);
VectorNormalize (dir);
monster_fire_railgun (self, start, dir, 50, 100, MZ2_CARRIER_RAILGUN);
self->monsterinfo.attack_finished = level.time + RAIL_FIRE_TIME;
}
void CarrierSaveLoc (edict_t *self)
{
CarrierCoopCheck(self);
VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
self->pos1[2] += self->enemy->viewheight;
};
mframe_t carrier_frames_attack_rail [] =
{
ai_charge, 2, CarrierCoopCheck,
ai_charge, 2, CarrierSaveLoc,
ai_charge, 2, CarrierCoopCheck,
ai_charge, -20, CarrierRail,
ai_charge, 2, CarrierCoopCheck,
ai_charge, 2, CarrierCoopCheck,
ai_charge, 2, CarrierCoopCheck,
ai_charge, 2, CarrierCoopCheck,
ai_charge, 2, CarrierCoopCheck
};
mmove_t carrier_move_attack_rail = {FRAME_search01, FRAME_search09, carrier_frames_attack_rail, carrier_run};
mframe_t carrier_frames_spawn [] =
{
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, carrier_prep_spawn, // 7 - end of wind down
ai_charge, -2, carrier_start_spawn, // 8 - start of spawn
ai_charge, -2, carrier_ready_spawn,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -10, carrier_spawn_check, //12 - actual spawn
ai_charge, -2, CarrierMachineGun, //13 - begin of wind down
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, CarrierMachineGun,
ai_charge, -2, carrier_reattack_mg //18 - end of wind down
};
mmove_t carrier_move_spawn = {FRAME_spawn01, FRAME_spawn18, carrier_frames_spawn, NULL};
mframe_t carrier_frames_pain_heavy [] =
{
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL
};
mmove_t carrier_move_pain_heavy = {FRAME_death01, FRAME_death10, carrier_frames_pain_heavy, carrier_run};
mframe_t carrier_frames_pain_light [] =
{
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL
};
mmove_t carrier_move_pain_light = {FRAME_spawn01, FRAME_spawn04, carrier_frames_pain_light, carrier_run};
mframe_t carrier_frames_death [] =
{
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, BossExplode
};
mmove_t carrier_move_death = {FRAME_death01, FRAME_death16, carrier_frames_death, carrier_dead};
void carrier_stand (edict_t *self)
{
// gi.dprintf ("carrier stand\n");
self->monsterinfo.currentmove = &carrier_move_stand;
}
void carrier_run (edict_t *self)
{
// gi.dprintf ("carrier run - %2.2f - %s \n", level.time, self->enemy->classname);
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
if (self->monsterinfo.aiflags & AI_STAND_GROUND)
self->monsterinfo.currentmove = &carrier_move_stand;
else
self->monsterinfo.currentmove = &carrier_move_run;
}
void carrier_walk (edict_t *self)
{
self->monsterinfo.currentmove = &carrier_move_walk;
}
void CarrierMachineGunHold (edict_t *self)
{
// self->monsterinfo.aiflags |= AI_HOLD_FRAME;
// self->yaw_speed = 0;
// self->monsterinfo.currentmove = &carrier_move_attack_mg;
CarrierMachineGun (self);
}
void carrier_attack (edict_t *self)
{
vec3_t vec;
float range, luck;
qboolean enemy_inback, enemy_infront, enemy_below;
// gi.dprintf ("carrier attack\n");
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
if ((!self->enemy) || (!self->enemy->inuse))
return;
enemy_inback = inback(self, self->enemy);
enemy_infront = infront (self, self->enemy);
enemy_below = below (self, self->enemy);
if (self->bad_area)
{
if ((enemy_inback) || (enemy_below))
self->monsterinfo.currentmove = &carrier_move_attack_rocket;
else if ((random() < 0.1) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
return;
}
if (self->monsterinfo.attack_state == AS_BLIND)
{
self->monsterinfo.currentmove = &carrier_move_spawn;
return;
}
if (!enemy_inback && !enemy_infront && !enemy_below) // to side and not under
{
if ((random() < 0.1) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
return;
}
/* if ((g_showlogic) && (g_showlogic->value))
{
gi.dprintf ("checking enemy ..");
if (enemy_inback)
gi.dprintf (" in back\n");
else if (enemy_infront)
gi.dprintf (" in front\n");
else
gi.dprintf (" inaccessible\n");
}
*/
if (enemy_infront)
{
VectorSubtract (self->enemy->s.origin, self->s.origin, vec);
range = VectorLength (vec);
if (range <= 125)
{
if ((random() < 0.8) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
}
else if (range < 600)
{
luck = random();
if (self->monsterinfo.monster_slots > 2)
{
if (luck <= 0.20)
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else if (luck <= 0.40)
self->monsterinfo.currentmove = &carrier_move_attack_pre_gren;
else if ((luck <= 0.7) && !(level.time < self->monsterinfo.attack_finished))
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
else
self->monsterinfo.currentmove = &carrier_move_spawn;
}
else
{
if (luck <= 0.30)
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else if (luck <= 0.65)
self->monsterinfo.currentmove = &carrier_move_attack_pre_gren;
else if (level.time >= self->monsterinfo.attack_finished)
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
else
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
}
}
else // won't use grenades at this range
{
luck = random();
if (self->monsterinfo.monster_slots > 2)
{
if (luck < 0.3)
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else if ((luck < 0.65) && !(level.time < self->monsterinfo.attack_finished))
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
self->pos1[2] += self->enemy->viewheight;
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
else
self->monsterinfo.currentmove = &carrier_move_spawn;
}
else
{
if ((luck < 0.45) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
else
{
gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &carrier_move_attack_rail;
}
}
}
}
else if ((enemy_below) || (enemy_inback))
{
self->monsterinfo.currentmove = &carrier_move_attack_rocket;
}
}
void carrier_attack_mg (edict_t *self)
{
CarrierCoopCheck(self);
self->monsterinfo.currentmove = &carrier_move_attack_mg;
}
void carrier_reattack_mg (edict_t *self)
{
CarrierCoopCheck(self);
if ( infront(self, self->enemy) )
if (random() <= 0.5)
if ((random() < 0.7) || (self->monsterinfo.monster_slots <= 2))
self->monsterinfo.currentmove = &carrier_move_attack_mg;
else
self->monsterinfo.currentmove = &carrier_move_spawn;
else
self->monsterinfo.currentmove = &carrier_move_attack_post_mg;
else
self->monsterinfo.currentmove = &carrier_move_attack_post_mg;
}
void carrier_attack_gren (edict_t *self)
{
// gi.dprintf ("carrier_attack_gren - %2.2f\n",level.time);
CarrierCoopCheck(self);
self->timestamp = level.time;
self->monsterinfo.currentmove = &carrier_move_attack_gren;
}
void carrier_reattack_gren (edict_t *self)
{
CarrierCoopCheck(self);
// gi.dprintf ("carrier_reattack - %2.2f", level.time);
if ( infront(self, self->enemy) )
if (self->timestamp + 1.3 > level.time ) // four grenades
{
// gi.dprintf (" attacking\n");
self->monsterinfo.currentmove = &carrier_move_attack_gren;
return;
}
// gi.dprintf ("not attacking\n");
self->monsterinfo.currentmove = &carrier_move_attack_post_gren;
}
void carrier_pain (edict_t *self, edict_t *other, float kick, int damage)
{
qboolean changed = false;
if (self->health < (self->max_health / 2))
self->s.skinnum = 1;
if (skill->value == 3)
return; // no pain anims in nightmare
// gi.dprintf ("carrier pain\n");
if (level.time < self->pain_debounce_time)
return;
self->pain_debounce_time = level.time + 5;
if (damage < 10)
{
gi.sound (self, CHAN_VOICE, sound_pain3, 1, ATTN_NONE, 0);
}
else if (damage < 30)
{
gi.sound (self, CHAN_VOICE, sound_pain1, 1, ATTN_NONE, 0);
if (random() < 0.5)
{
changed = true;
self->monsterinfo.currentmove = &carrier_move_pain_light;
}
}
else
{
gi.sound (self, CHAN_VOICE, sound_pain2, 1, ATTN_NONE, 0);
self->monsterinfo.currentmove = &carrier_move_pain_heavy;
changed = true;
}
// if we changed frames, clean up our little messes
if (changed)
{
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
self->yaw_speed = orig_yaw_speed;
}
}
void carrier_dead (edict_t *self)
{
VectorSet (self->mins, -56, -56, 0);
VectorSet (self->maxs, 56, 56, 80);
self->movetype = MOVETYPE_TOSS;
self->svflags |= SVF_DEADMONSTER;
self->nextthink = 0;
gi.linkentity (self);
}
void carrier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
gi.sound (self, CHAN_VOICE, sound_death, 1, ATTN_NONE, 0);
self->deadflag = DEAD_DEAD;
self->takedamage = DAMAGE_NO;
self->count = 0;
self->monsterinfo.currentmove = &carrier_move_death;
}
qboolean Carrier_CheckAttack (edict_t *self)
{
vec3_t spot1, spot2;
vec3_t temp;
float chance;
trace_t tr;
qboolean enemy_infront, enemy_inback, enemy_below;
int enemy_range;
float enemy_yaw;
if (self->enemy->health > 0)
{
// see if any entities are in the way of the shot
VectorCopy (self->s.origin, spot1);
spot1[2] += self->viewheight;
VectorCopy (self->enemy->s.origin, spot2);
spot2[2] += self->enemy->viewheight;
tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA);
// do we have a clear shot?
if (tr.ent != self->enemy)
{
// go ahead and spawn stuff if we're mad a a client
if (self->enemy->client && self->monsterinfo.monster_slots > 2)
{
self->monsterinfo.attack_state = AS_BLIND;
return true;
}
// PGM - we want them to go ahead and shoot at info_notnulls if they can.
if(self->enemy->solid != SOLID_NOT || tr.fraction < 1.0) //PGM
return false;
}
}
enemy_infront = infront(self, self->enemy);
enemy_inback = inback(self, self->enemy);
enemy_below = below (self, self->enemy);
enemy_range = range(self, self->enemy);
VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
enemy_yaw = vectoyaw2(temp);
self->ideal_yaw = enemy_yaw;
// PMM - shoot out the back if appropriate
if ((enemy_inback) || (!enemy_infront && enemy_below))
{
// this is using wait because the attack is supposed to be independent
if (level.time >= self->wait)
{
self->wait = level.time + CARRIER_ROCKET_TIME;
self->monsterinfo.attack(self);
if (random() < 0.6)
self->monsterinfo.attack_state = AS_SLIDING;
else
self->monsterinfo.attack_state = AS_STRAIGHT;
return true;
}
}
// melee attack
if (enemy_range == RANGE_MELEE)
{
self->monsterinfo.attack_state = AS_MISSILE;
return true;
}
// if (level.time < self->monsterinfo.attack_finished)
// return false;
if (self->monsterinfo.aiflags & AI_STAND_GROUND)
{
chance = 0.4;
}
else if (enemy_range == RANGE_MELEE)
{
chance = 0.8;
}
else if (enemy_range == RANGE_NEAR)
{
chance = 0.8;
}
else if (enemy_range == RANGE_MID)
{
chance = 0.8;
}
else if (enemy_range == RANGE_FAR)
{
chance = 0.5;
}
// PGM - go ahead and shoot every time if it's a info_notnull
if ((random () < chance) || (self->enemy->solid == SOLID_NOT))
{
self->monsterinfo.attack_state = AS_MISSILE;
// self->monsterinfo.attack_finished = level.time + 2*random();
return true;
}
if (self->flags & FL_FLY)
{
if (random() < 0.6)
self->monsterinfo.attack_state = AS_SLIDING;
else
self->monsterinfo.attack_state = AS_STRAIGHT;
}
return false;
}
void CarrierPrecache ()
{
gi.soundindex ("flyer/flysght1.wav");
gi.soundindex ("flyer/flysrch1.wav");
gi.soundindex ("flyer/flypain1.wav");
gi.soundindex ("flyer/flypain2.wav");
gi.soundindex ("flyer/flyatck2.wav");
gi.soundindex ("flyer/flyatck1.wav");
gi.soundindex ("flyer/flydeth1.wav");
gi.soundindex ("flyer/flyatck3.wav");
gi.soundindex ("flyer/flyidle1.wav");
gi.soundindex ("weapons/rockfly.wav");
gi.soundindex ("infantry/infatck1.wav");
gi.soundindex ("gunner/gunatck3.wav");
gi.soundindex ("weapons/grenlb1b.wav");
gi.soundindex ("tank/rocket.wav");
gi.modelindex ("models/monsters/flyer/tris.md2");
gi.modelindex ("models/objects/rocket/tris.md2");
gi.modelindex ("models/objects/debris2/tris.md2");
gi.modelindex ("models/objects/grenade/tris.md2");
gi.modelindex("models/items/spawngro/tris.md2");
gi.modelindex("models/items/spawngro2/tris.md2");
gi.modelindex ("models/objects/gibs/sm_metal/tris.md2");
gi.modelindex ("models/objects/gibs/gear/tris.md2");
}
/*QUAKED monster_carrier (1 .5 0) (-56 -56 -44) (56 56 44) Ambush Trigger_Spawn Sight
*/
void SP_monster_carrier (edict_t *self)
{
if (deathmatch->value)
{
G_FreeEdict (self);
return;
}
sound_pain1 = gi.soundindex ("carrier/pain_md.wav");
sound_pain2 = gi.soundindex ("carrier/pain_lg.wav");
sound_pain3 = gi.soundindex ("carrier/pain_sm.wav");
sound_death = gi.soundindex ("carrier/death.wav");
// sound_search1 = gi.soundindex ("bosshovr/bhvunqv1.wav");
sound_rail = gi.soundindex ("gladiator/railgun.wav");
sound_sight = gi.soundindex ("carrier/sight.wav");
sound_spawn = gi.soundindex ("medic_commander/monsterspawn1.wav");
self->s.sound = gi.soundindex ("bosshovr/bhvengn1.wav");
self->movetype = MOVETYPE_STEP;
self->solid = SOLID_BBOX;
self->s.modelindex = gi.modelindex ("models/monsters/carrier/tris.md2");
VectorSet (self->mins, -56, -56, -44);
VectorSet (self->maxs, 56, 56, 44);
// 2000 - 4000 health
self->health = max (2000, 2000 + 1000*((skill->value)-1));
// add health in coop (500 * skill)
if (coop->value)
self->health += 500*(skill->value);
self->gib_health = -200;
self->mass = 1000;
self->yaw_speed = 15;
orig_yaw_speed = self->yaw_speed;
// self->yaw_speed = 1;
self->flags |= FL_IMMUNE_LASER;
self->monsterinfo.aiflags |= AI_IGNORE_SHOTS;
self->pain = carrier_pain;
self->die = carrier_die;
self->monsterinfo.melee = NULL;
self->monsterinfo.stand = carrier_stand;
self->monsterinfo.walk = carrier_walk;
self->monsterinfo.run = carrier_run;
self->monsterinfo.attack = carrier_attack;
// self->monsterinfo.search = carrier_search;
self->monsterinfo.sight = carrier_sight;
self->monsterinfo.checkattack = Carrier_CheckAttack;
gi.linkentity (self);
self->monsterinfo.currentmove = &carrier_move_stand;
self->monsterinfo.scale = MODEL_SCALE;
CarrierPrecache();
flymonster_start (self);
self->monsterinfo.attack_finished = 0;
switch ((int)skill->value)
{
case 0:
self->monsterinfo.monster_slots = 3;
break;
case 1:
case 2:
self->monsterinfo.monster_slots = 6;
break;
case 3:
self->monsterinfo.monster_slots = 9;
break;
default:
self->monsterinfo.monster_slots = 6;
break;
}
}
Reference in New Issue View Git Blame Copy Permalink