void
boss2_firebullet_left(edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
if (!self)
{
return;
}
AngleVectors(self->s.angles, forward, right, NULL);
G_ProjectSource(self->s.origin, monster_flash_offset[MZ2_BOSS2_MACHINEGUN_L1],
forward, right, start);
VectorMA(self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract(target, start, forward);
VectorNormalize(forward);
monster_fire_bullet(self, start, forward, 6, 4,
DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD,
MZ2_BOSS2_MACHINEGUN_L1);
}
void supertankMachineGun (edict_t *self)
{
vec3_t dir;
vec3_t vec;
vec3_t start;
vec3_t forward, right;
int flash_number;
if(!self->enemy || !self->enemy->inuse) //PGM
return; //PGM
flash_number = MZ2_SUPERTANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak1_1);
//FIXME!!!
dir[0] = 0;
dir[1] = self->s.angles[1];
dir[2] = 0;
AngleVectors (dir, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorCopy (self->enemy->s.origin, vec);
VectorMA (vec, 0, self->enemy->velocity, vec);
vec[2] += self->enemy->viewheight;
VectorSubtract (vec, start, forward);
VectorNormalize (forward);
}
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void
GunnerFire(edict_t *self)
{
vec3_t start;
vec3_t forward, right;
vec3_t target;
vec3_t aim;
q_int32_t flash_number;
if (!self)
{
return;
}
flash_number = MZ2_GUNNER_MACHINEGUN_1 + (self->s.frame - FRAME_attak216);
AngleVectors(self->s.angles, forward, right, NULL);
G_ProjectSource(self->s.origin, monster_flash_offset[flash_number],
forward, right, start);
/* project enemy back a bit and target there */
VectorCopy(self->enemy->s.origin, target);
VectorMA(target, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract(target, start, aim);
VectorNormalize(aim);
monster_fire_bullet(self, start, aim, 3, 4,
DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD,
flash_number);
}
void actorMachineGun (edict_t *self)
{
vec3_t start, target;
vec3_t forward, right;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_ACTOR_MACHINEGUN_1], forward, right, start);
if (self->enemy)
{
if (self->enemy->health > 0)
{
VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
}
else
{
VectorCopy (self->enemy->absmin, target);
target[2] += (self->enemy->size[2] / 2);
}
VectorSubtract (target, start, forward);
VectorNormalize (forward);
}
else
{
AngleVectors (self->s.angles, forward, NULL, NULL);
}
monster_fire_bullet (self, start, forward, 3, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MZ2_ACTOR_MACHINEGUN_1);
}
void TankMachineGun (edict_t *self)
{
vec3_t dir;
vec3_t vec;
vec3_t start;
vec3_t forward, right;
int flash_number;
flash_number = MZ2_TANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak406);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorCopy (self->enemy->s.origin, vec);
vec[2] += self->enemy->viewheight;
VectorSubtract (vec, start, vec);
vectoangles (vec, vec);
dir[0] = vec[0];
}
else
{
dir[0] = 0;
}
if (self->s.frame <= FRAME_attak415)
dir[1] = self->s.angles[1] - 8 * (self->s.frame - FRAME_attak411);
else
dir[1] = self->s.angles[1] + 8 * (self->s.frame - FRAME_attak419);
dir[2] = 0;
AngleVectors (dir, forward, NULL, NULL);
monster_fire_bullet (self, start, forward, 20, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void jorg_firebullet_left (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
int damage;
float spreadmult = 5 - 0.1 * self->monsterinfo.aim_frames;
float aimmult = -0.25 + 0.0125 * self->monsterinfo.aim_frames;
if (spreadmult < 1) {
spreadmult = 1;
}
if (aimmult > 0) {
aimmult = 0;
}
if (!self->enemy)
return;
if (self->radius_dmg)
damage = (int) ceil(22 + 1.8 * self->monsterinfo.skill);
else
damage = (int) ceil(11 + 0.9 * self->monsterinfo.skill);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_JORG_MACHINEGUN_L1], forward, right, start);
VectorMA (self->enemy->s.origin, aimmult, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract (target, start, forward);
VectorNormalize (forward);
monster_fire_bullet (self, start, forward, damage, 4, DEFAULT_BULLET_HSPREAD * spreadmult, DEFAULT_BULLET_VSPREAD * spreadmult, MZ2_JORG_MACHINEGUN_L1);
}
void GunnerFire (edict_t *self)
{
vec3_t start;
vec3_t forward, right;
vec3_t target;
vec3_t aim;
int flash_number;
flash_number = MZ2_GUNNER_MACHINEGUN_1 + (self->s.frame - FRAME_attak216);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
// project enemy back a bit and target there
VectorCopy (self->enemy->s.origin, target);
VectorMA (target, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
target[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (target, start, aim);
VectorNormalize (aim);
monster_fire_bullet (self, start, aim, 3, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void
carrier_firebullet_left(edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
int flashnum;
if (!self)
{
return;
}
/* 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);
target[2] += self->enemy->viewheight;
VectorSubtract(target, start, forward);
VectorNormalize(forward);
monster_fire_bullet(self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD * 3,
DEFAULT_BULLET_VSPREAD, flashnum);
}
void
soldier_fire(edict_t * self, int flash_number)
{
vec3_t start;
vec3_t forward, right, up;
vec3_t aim;
vec3_t dir;
vec3_t end;
float r , u;
int flash_index;
if (self->s.skinnum < 2)
flash_index = blaster_flash[flash_number];
else if (self->s.skinnum < 4)
flash_index = shotgun_flash[flash_number];
else
flash_index = machinegun_flash[flash_number];
AngleVectors(self->s.angles, forward, right, NULL);
G_ProjectSource(self->s.origin, monster_flash_offset[flash_index], forward, right, start);
if (flash_number == 5 || flash_number == 6) {
VectorCopy(forward, aim);
} else {
VectorCopy(self->enemy->s.origin, end);
end[2] += self->enemy->viewheight;
VectorSubtract(end, start, aim);
vectoangles(aim, dir);
AngleVectors(dir, forward, right, up);
r = crandom() * 1000;
u = crandom() * 500;
VectorMA(start, 8192, forward, end);
VectorMA(end, r, right, end);
VectorMA(end, u, up, end);
VectorSubtract(end, start, aim);
VectorNormalize(aim);
}
if (self->s.skinnum <= 1) {
monster_fire_blaster(self, start, aim, 5, 600, flash_index, EF_BLASTER);
} else if (self->s.skinnum <= 3) {
monster_fire_shotgun(self, start, aim, 2, 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SHOTGUN_COUNT, flash_index);
} else {
if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
self->monsterinfo.pausetime = level.time + (3 + rand() % 8) * FRAMETIME;
monster_fire_bullet(self, start, aim, 2, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_index);
if (level.time >= self->monsterinfo.pausetime)
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
else
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
}
void InfantryMachineGun (edict_t *self)
{
vec3_t start, target;
vec3_t forward, right;
vec3_t vec;
int flash_number;
if(!self->enemy || !self->enemy->inuse) //PGM
return; //PGM
// pmm - new attack start frame
if (self->s.frame == FRAME_attak104)
{
flash_number = MZ2_INFANTRY_MACHINEGUN_1;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
target[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (target, start, forward);
VectorNormalize (forward);
}
else
{
AngleVectors (self->s.angles, forward, right, NULL);
}
}
else
{
flash_number = MZ2_INFANTRY_MACHINEGUN_2 + (self->s.frame - FRAME_death211);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
VectorSubtract (self->s.angles, aimangles[flash_number-MZ2_INFANTRY_MACHINEGUN_2], vec);
AngleVectors (vec, forward, NULL, NULL);
}
monster_fire_bullet (self, start, forward, 3, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void TankMachineGun (edict_t *self)
{
vec3_t dir;
vec3_t vec;
vec3_t start;
vec3_t forward, right;
int flash_number;
// check if enemy went away
if (!self->enemy || !self->enemy->inuse)
return;
flash_number = MZ2_TANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak406);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorCopy (self->enemy->s.origin, vec);
vec[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
vec[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
vec[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
vec[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (vec, start, vec);
vectoangles (vec, vec);
dir[0] = vec[0];
}
else
{
dir[0] = 0;
}
if (self->s.frame <= FRAME_attak415)
dir[1] = self->s.angles[1] - 8 * (self->s.frame - FRAME_attak411);
else
dir[1] = self->s.angles[1] + 8 * (self->s.frame - FRAME_attak419);
dir[2] = 0;
AngleVectors (dir, forward, NULL, NULL);
monster_fire_bullet (self, start, forward, 20, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void myTankMachineGun (edict_t *self)
{
vec3_t forward, start;
int flash_number, damage;
// sanity check
if (!self->enemy || !self->enemy->inuse)
return;
flash_number = MZ2_TANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak406);
damage = 20 + 2*self->monsterinfo.level;
MonsterAim(self, 0.8, 0, false, flash_number, forward, start);
monster_fire_bullet (self, start, forward, damage, damage,
DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void myGunnerFire (edict_t *self)
{
int damage, flash_number;
vec3_t forward, start;
// sanity check
if (!self->enemy || !self->enemy->inuse)
return;
flash_number = MZ2_GUNNER_MACHINEGUN_1 + (self->s.frame - FRAME_attak216);
damage = 10 + self->monsterinfo.level;
MonsterAim(self, 0.8, 0, false, flash_number, forward, start);
monster_fire_bullet (self, start, forward, damage, damage,
DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void InfantryMachineGun(edict_t * self)
{
vec3_t start, target;
vec3_t forward, right;
vec3_t vec;
int flash_number;
if (self->s.frame == FRAME_attak111) {
flash_number = MZ2_INFANTRY_MACHINEGUN_1;
AngleVectors(self->s.angles, forward, right, NULL);
G_ProjectSource(self->s.origin,
monster_flash_offset[flash_number], forward,
right, start);
if (self->enemy) {
VectorMA(self->enemy->s.origin, -0.2,
self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract(target, start, forward);
VectorNormalize(forward);
} else {
AngleVectors(self->s.angles, forward, right, NULL);
}
} else {
flash_number =
MZ2_INFANTRY_MACHINEGUN_2 + (self->s.frame -
FRAME_death211);
AngleVectors(self->s.angles, forward, right, NULL);
G_ProjectSource(self->s.origin,
monster_flash_offset[flash_number], forward,
right, start);
VectorSubtract(self->s.angles,
aimangles[flash_number -
MZ2_INFANTRY_MACHINEGUN_2], vec);
AngleVectors(vec, forward, NULL, NULL);
}
monster_fire_bullet(self, start, forward, 3, 4, DEFAULT_BULLET_HSPREAD,
DEFAULT_BULLET_VSPREAD, flash_number);
}
void TankMachineGun (edict_t *self)
{
vec3_t dir;
vec3_t vec;
vec3_t start;
vec3_t forward, right;
int flash_number;
flash_number = MZ2_TANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak406);
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorCopy (self->enemy->s.origin, vec);
vec[2] += self->enemy->viewheight;
VectorSubtract (vec, start, vec);
vectoangles (vec, vec);
dir[0] = vec[0];
}
else
{
dir[0] = 0;
}
if (self->s.frame <= FRAME_attak415)
dir[1] = self->s.angles[1] - 8 * (self->s.frame - FRAME_attak411);
else
dir[1] = self->s.angles[1] + 8 * (self->s.frame - FRAME_attak419);
dir[2] = 0;
AngleVectors (dir, forward, NULL, NULL);
if(EMPNukeCheck(self, start))
{
gi.sound (self, CHAN_AUTO, gi.soundindex("items/empnuke/emp_missfire.wav"), 1, ATTN_NORM, 0);
return;
}
monster_fire_bullet (self, start, forward, 20, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
void jorg_firebullet_left (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_JORG_MACHINEGUN_L1], forward, right, start);
VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract (target, start, forward);
VectorNormalize (forward);
if(EMPNukeCheck(self, start))
{
gi.sound (self, CHAN_AUTO, gi.soundindex("items/empnuke/emp_missfire.wav"), 1, ATTN_NORM, 0);
return;
}
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MZ2_JORG_MACHINEGUN_L1);
}
void boss2_firebullet_right (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_BOSS2_MACHINEGUN_R1], forward, right, start);
VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
target[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
target[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (target, start, forward);
VectorNormalize (forward);
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MZ2_BOSS2_MACHINEGUN_R1);
}
void supertankMachineGun (edict_t *self)
{
vec3_t dir;
vec3_t vec;
vec3_t start;
vec3_t forward, right;
int flash_number;
flash_number = MZ2_SUPERTANK_MACHINEGUN_1 + (self->s.frame - FRAME_attak1_1);
//FIXME!!!
dir[0] = 0;
dir[1] = self->s.angles[1];
dir[2] = 0;
AngleVectors (dir, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_number], forward, right, start);
if (self->enemy)
{
VectorCopy (self->enemy->s.origin, vec);
VectorMA (vec, 0, self->enemy->velocity, vec);
vec[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
vec[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
vec[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
vec[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (vec, start, forward);
VectorNormalize (forward);
}
monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_number);
}
//==========================================
// M_default_FireWeapon
// Fire if needed
//==========================================
void M_default_FireWeapon (edict_t *self)
{
float firedelay;
vec3_t target;
vec3_t angles;
if (!self->enemy)
return;
// Aim
VectorCopy(self->enemy->s.origin,target);
// modify attack angles based on accuracy (mess this up to make the bot's aim not so deadly)
target[0] += (random()-0.5) * ((MAX_BOT_SKILL - self->ai->pers.skillLevel) *2);
target[1] += (random()-0.5) * ((MAX_BOT_SKILL - self->ai->pers.skillLevel) *2);
// Set direction
VectorSubtract (target, self->s.origin, self->ai->move_vector);
vectoangles (self->ai->move_vector, angles);
VectorCopy(angles,self->s.angles);
// Set the attack
firedelay = random()*(MAX_BOT_SKILL*1.8);
if (firedelay > (MAX_BOT_SKILL - self->ai->pers.skillLevel) && M_default_CheckShot(self, target))
{
vec3_t start, forward, right;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, tv(15,15,0), forward, right, start);
//monster_fire_bullet (self, start, forward, 4, 4, MZ2_INFANTRY_MACHINEGUN_2);
monster_fire_bullet (self, start, forward, 4, 4, rand(), rand(), MZ2_INFANTRY_MACHINEGUN_2);
}
//if(AIDevel.debugMode && bot_debugmonster->integer)
// G_PrintMsg (NULL, PRINT_HIGH, "monster: attacking\n");
}
void soldier_fire (edict_t *self, int flash_number)
{
vec3_t start;
vec3_t forward, right, up;
vec3_t aim;
vec3_t dir;
vec3_t end;
float r, u;
int flash_index;
if ((self->s.skinnum % 6) < 2)
flash_index = blaster_flash[flash_number];
else if ((self->s.skinnum % 6) < 4)
flash_index = shotgun_flash[flash_number];
else
flash_index = machinegun_flash[flash_number];
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_index], forward, right, start);
if (flash_number == 5 || flash_number == 6)
{
VectorCopy (forward, aim);
}
else
{
VectorCopy (self->enemy->s.origin, end);
end[2] += self->enemy->viewheight;
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
end[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
end[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
end[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (end, start, aim);
// Lazarus: Accuracy is skill level dependent
if(skill->value < 3)
{
vectoangles (aim, dir);
AngleVectors (dir, forward, right, up);
r = crandom()*(1000 - 333*skill->value);
u = crandom()*(500 - 167*skill->value);
VectorMA (start, 8192, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
VectorSubtract (end, start, aim);
}
VectorNormalize (aim);
}
if ((self->s.skinnum % 6) <= 1)
{
// Lazarus: make bolt speed skill level dependent
monster_fire_blaster (self, start, aim, 5, 600 + 100*skill->value, flash_index, EF_BLASTER, BLASTER_ORANGE);
}
else if ((self->s.skinnum % 6) <= 3)
{
monster_fire_shotgun (self, start, aim, 2, 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SHOTGUN_COUNT, flash_index);
}
else
{
if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
self->monsterinfo.pausetime = level.time + (3 + rand() % 8) * FRAMETIME;
monster_fire_bullet (self, start, aim, 2, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_index);
if (level.time >= self->monsterinfo.pausetime)
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
else
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
}
void soldier_fire (edict_t *self, int flash_number)
{
vec3_t start;
vec3_t forward, right, up;
vec3_t aim;
vec3_t dir;
vec3_t end;
float r, u;
int flash_index;
if (!self->enemy)
return;
if (self->s.skinnum < 2)
flash_index = blaster_flash[flash_number];
else if (self->s.skinnum < 4)
flash_index = shotgun_flash[flash_number];
else
flash_index = machinegun_flash[flash_number];
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_index], forward, right, start);
if (flash_number == 5 || flash_number == 6)
{
VectorCopy (forward, aim);
}
else
{
VectorMA(self->enemy->s.origin, 0.3, self->enemy->velocity, end);
end[2] += self->enemy->viewheight;
VectorSubtract (end, start, aim);
vectoangles (aim, dir);
AngleVectors (dir, forward, right, up);
if (self->s.skinnum <= 1)
{
r = crandom()*(500 - 6 * self->monsterinfo.skill);
u = crandom()*(250 - 3 * self->monsterinfo.skill);
} else {
r = crandom()*(800 - 16 * self->monsterinfo.skill);
u = crandom()*(400 - 8 * self->monsterinfo.skill);
}
VectorMA (start, 8192, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
VectorSubtract (end, start, aim);
VectorNormalize (aim);
}
if (self->s.skinnum <= 1) {
if (self->radius_dmg)
monster_fire_blaster (self, start, aim, (int) ceil(8.0 + 5.0 * self->monsterinfo.skill), 1500 + 50 * self->monsterinfo.skill, flash_index, 0);
else
monster_fire_blaster (self, start, aim, (int) ceil(4.0 + 2.5 * self->monsterinfo.skill), 900 + 30 * self->monsterinfo.skill, flash_index, 0);
if (self->s.frame == 41) {
if (level.time >= self->monsterinfo.pausetime) {
if (visible(self, self->enemy) && (self->enemy->health > 0) && (random() <= 0.9)) {
self->monsterinfo.pausetime = level.time + (4 + rand() % 4) * FRAMETIME;
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
} else {
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
}
} else {
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
}
}
else if (self->s.skinnum <= 3)
{
if (self->radius_dmg)
monster_fire_shotgun (self, start, aim, (int) ceil(2.0 + 0.6 * self->monsterinfo.skill), 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SHOTGUN_COUNT, flash_index);
else
monster_fire_shotgun (self, start, aim, (int) ceil(1.0 + 0.3 * self->monsterinfo.skill), 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SHOTGUN_COUNT, flash_index);
}
else
{
vec3_t target;
if ((!(self->monsterinfo.aiflags & AI_HOLD_FRAME)) && (self->health > 0))
self->monsterinfo.pausetime = level.time + (3 + rand() % 8) * FRAMETIME;
// project enemy back a bit and target there
VectorCopy (self->enemy->s.origin, target);
VectorMA (target, (-0.5 + 0.015 * self->monsterinfo.skill), self->enemy->velocity, target);
target[2] += self->enemy->viewheight;
VectorSubtract (target, start, aim);
VectorNormalize (aim);
if (self->radius_dmg)
monster_fire_bullet (self, start, aim, (int) ceil(4.2 + 2.2 * self->monsterinfo.skill), 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_index);
else
monster_fire_bullet (self, start, aim, (int) ceil(2.1 + 1.1 * self->monsterinfo.skill), 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_index);
if (level.time >= self->monsterinfo.pausetime)
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
else {
self->s.frame--;
// self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
}
}
//void soldier_fire (edict_t *self, int flash_number) PMM
void soldier_fire (edict_t *self, int in_flash_number)
{
vec3_t start;
vec3_t forward, right, up;
vec3_t aim;
vec3_t dir;
vec3_t end;
float r, u;
int flash_index;
int flash_number;
#ifdef RUN_SHOOT
vec3_t aim_norm;
float angle;
#endif
#ifdef CHECK_TARGET
trace_t tr;
vec3_t aim_good;
#endif
if ((!self->enemy) || (!self->enemy->inuse))
{
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
return;
}
if (in_flash_number < 0)
{
flash_number = -1 * in_flash_number;
}
else
flash_number = in_flash_number;
if (self->s.skinnum < 2)
flash_index = blaster_flash[flash_number];
else if (self->s.skinnum < 4)
flash_index = shotgun_flash[flash_number];
else
flash_index = machinegun_flash[flash_number];
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[flash_index], forward, right, start);
if (flash_number == 5 || flash_number == 6) // he's dead
{
VectorCopy (forward, aim);
}
else
{
VectorCopy (self->enemy->s.origin, end);
end[2] += self->enemy->viewheight;
VectorSubtract (end, start, aim);
#ifdef CHECK_TARGET
VectorCopy (end, aim_good);
#endif
#ifdef RUN_SHOOT
//PMM
if (in_flash_number < 0)
{
VectorCopy (aim, aim_norm);
VectorNormalize (aim_norm);
angle = DotProduct (aim_norm, forward);
//gi.dprintf ("Dot Product: %f", DotProduct (aim_norm, forward));
if (angle < 0.9) // ~25 degree angle
{
// if(g_showlogic && g_showlogic->value)
// gi.dprintf (" not firing due to bad dotprod %f\n", angle);
return;
}
// else
// {
// if(g_showlogic && g_showlogic->value)
// gi.dprintf (" firing: dotprod = %f\n", angle);
// }
}
//-PMM
#endif
vectoangles (aim, dir);
AngleVectors (dir, forward, right, up);
if (skill->value < 2)
{
r = crandom()*1000;
u = crandom()*500;
}
else
{
r = crandom()*500;
u = crandom()*250;
}
VectorMA (start, 8192, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
VectorSubtract (end, start, aim);
VectorNormalize (aim);
}
#ifdef CHECK_TARGET
if (!(flash_number == 5 || flash_number == 6)) // he's dead
{
tr = gi.trace (start, NULL, NULL, aim_good, self, MASK_SHOT);
if ((tr.ent != self->enemy) && (tr.ent != world))
{
// if(g_showlogic && g_showlogic->value)
// gi.dprintf ("infantry shot aborted due to bad target\n");
return;
}
}
#endif
if (self->s.skinnum <= 1)
{
monster_fire_blaster (self, start, aim, 5, 600, flash_index, EF_BLASTER);
}
else if (self->s.skinnum <= 3)
{
monster_fire_shotgun (self, start, aim, 2, 1, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SHOTGUN_COUNT, flash_index);
}
else
{
// PMM - changed to wait from pausetime to not interfere with dodge code
if (!(self->monsterinfo.aiflags & AI_HOLD_FRAME))
self->wait = level.time + (3 + rand() % 8) * FRAMETIME;
monster_fire_bullet (self, start, aim, 2, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, flash_index);
if (level.time >= self->wait)
self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
else
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
}
