blendo/thirtyflightsofloving
0
0
Fork 0
mirror of https://github.com/blendogames/thirtyflightsofloving.git synced 2024-11-15 00:41:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
thirtyflightsofloving/missionpack/m_widow2.c

1878 lines
49 KiB
C
Raw Normal View History

Added source code from official mission pack support DLL.
2020-01-05 02:25:00 +00:00
/*
==============================================================================
black widow, part 2
==============================================================================
*/
// timestamp used to prevent rapid fire of melee attack
#include "g_local.h"
#include "m_widow2.h"
#define NUM_STALKERS_SPAWNED 6 // max # of stalkers she can spawn
#define DISRUPT_TIME 3
static int sound_pain1;
static int sound_pain2;
static int sound_pain3;
static int sound_death;
static int sound_search1;
static int sound_disrupt;
static int sound_tentacles_retract;
// sqrt(64*64*2) + sqrt(28*28*2) => 130.1
static vec3_t spawnpoints[] = {
{30, 135, 0},
{30, -135, 0}
};
static float sweep_angles[] = {
-40.0, -32.0, -24.0, -16.0, -8.0, 0.0, 8.0, 16.0, 24.0, 32.0, 40.0
};
extern vec3_t stalker_mins, stalker_maxs;
qboolean infront (edict_t *self, edict_t *other);
void WidowCalcSlots (edict_t *self);
void WidowPowerups (edict_t *self);
void widow2_run (edict_t *self);
void widow2_stand (edict_t *self);
void widow2_dead (edict_t *self);
void widow2_attack (edict_t *self);
void widow2_attack_beam (edict_t *self);
void widow2_reattack_beam (edict_t *self);
void widow2_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
void widow_start_spawn (edict_t *self);
void widow_done_spawn (edict_t *self);
void widow2_spawn_check (edict_t *self);
void widow2_prep_spawn (edict_t *self);
void Widow2SaveBeamTarget(edict_t *self);
// death stuff
void WidowExplode (edict_t *self);
void gib_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
void gib_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf);
void ThrowWidowGibReal (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean large, int hitsound, qboolean fade);
void ThrowWidowGibSized (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, int hitsound, qboolean fade);
void ThrowWidowGibLoc (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean fade);
void WidowExplosion1 (edict_t *self);
void WidowExplosion2 (edict_t *self);
void WidowExplosion3 (edict_t *self);
void WidowExplosion4 (edict_t *self);
void WidowExplosion5 (edict_t *self);
void WidowExplosion6 (edict_t *self);
void WidowExplosion7 (edict_t *self);
void WidowExplosionLeg (edict_t *self);
void ThrowArm1 (edict_t *self);
void ThrowArm2 (edict_t *self);
void ClipGibVelocity (edict_t *ent);
// end of death stuff
// these offsets used by the tongue
static vec3_t offsets[] = {
{17.48, 0.10, 68.92},
{17.47, 0.29, 68.91},
{17.45, 0.53, 68.87},
{17.42, 0.78, 68.81},
{17.39, 1.02, 68.75},
{17.37, 1.20, 68.70},
{17.36, 1.24, 68.71},
{17.37, 1.21, 68.72},
};
void showme (edict_t *self);
void pauseme (edict_t *self)
{
self->monsterinfo.aiflags |= AI_HOLD_FRAME;
}
void widow2_search (edict_t *self)
{
if (random() < 0.5)
gi.sound (self, CHAN_VOICE, sound_search1, 1, ATTN_NONE, 0);
}
void Widow2Beam (edict_t *self)
{
vec3_t forward, right, target;
vec3_t start, end, targ_angles, vec;
int flashnum;
if ((!self->enemy) || (!self->enemy->inuse))
return;
AngleVectors (self->s.angles, forward, right, NULL);
if ((self->s.frame >= FRAME_fireb05) && (self->s.frame <= FRAME_fireb09))
{
// regular beam attack
Widow2SaveBeamTarget(self);
flashnum = MZ2_WIDOW2_BEAMER_1 + self->s.frame - FRAME_fireb05;
G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
VectorCopy (self->pos2, target);
target[2] += self->enemy->viewheight-10;
// 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_heat (self, start, forward, vec3_origin, 10, 50, flashnum);
}
else if ((self->s.frame >= FRAME_spawn04) && (self->s.frame <= FRAME_spawn14))
{
// sweep
flashnum = MZ2_WIDOW2_BEAM_SWEEP_1 + self->s.frame - FRAME_spawn04;
G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
VectorCopy(self->enemy->s.origin, end);
// 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, target);
vectoangles2 (target, targ_angles);
VectorCopy (self->s.angles, vec);
vec[PITCH] += targ_angles[PITCH];
vec[YAW] -= sweep_angles[flashnum-MZ2_WIDOW2_BEAM_SWEEP_1];
AngleVectors (vec, forward, NULL, NULL);
monster_fire_heat (self, start, forward, vec3_origin, 10, 50, flashnum);
/*
if (self->s.frame == FRAME_spawn04)
{
VectorMA (start, 1024, forward, debugend);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_DEBUGTRAIL);
gi.WritePosition (start);
gi.WritePosition (debugend);
gi.multicast (start, MULTICAST_ALL);
drawbbox (self);
self->monsterinfo.aiflags |= AI_HOLD_FRAME|AI_MANUAL_STEERING;
}
*/
}
else
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("bad fire frame for widow2 beam -- tell me you saw this!\n");
Widow2SaveBeamTarget(self);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_WIDOW2_BEAMER_1], forward, right, start);
VectorCopy (self->pos2, target);
target[2] += self->enemy->viewheight-10;
// 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_heat (self, start, forward, vec3_origin, 10, 50, 0);
}
}
void Widow2Spawn (edict_t *self)
{
vec3_t f, r, u, offset, startpoint, spawnpoint;
edict_t *ent, *designated_enemy;
int i;
AngleVectors (self->s.angles, f, r, u);
for (i=0; i < 2; i++)
{
VectorCopy (spawnpoints[i], offset);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
if (FindSpawnPoint (startpoint, stalker_mins, stalker_maxs, spawnpoint, 64))
{
ent = CreateGroundMonster (spawnpoint, self->s.angles, stalker_mins, stalker_maxs, "monster_stalker", 256);
if (!ent)
continue;
self->monsterinfo.monster_used++;
ent->monsterinfo.commander = self;
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("widow: post-spawn : %d slots left\n", SELF_SLOTS_LEFT);
ent->nextthink = level.time;
ent->think (ent);
//ent->monsterinfo.aiflags |= AI_SPAWNED_WIDOW|AI_DO_NOT_COUNT|AI_IGNORE_SHOTS;
ent->monsterinfo.aiflags |= AI_IGNORE_SHOTS;
ent->monsterinfo.monsterflags |= MFL_SPAWNED_WIDOW|MFL_DO_NOT_COUNT;
if (!(coop && coop->value))
{
designated_enemy = self->enemy;
}
else
{
designated_enemy = PickCoopTarget(ent);
if (designated_enemy)
{
// try to avoid using my enemy
if (designated_enemy == self->enemy)
{
designated_enemy = PickCoopTarget(ent);
if (designated_enemy)
{
// if ((g_showlogic) && (g_showlogic->value))
// {
// gi.dprintf ("PickCoopTarget returned a %s - ", designated_enemy->classname);
// if (designated_enemy->client)
// gi.dprintf ("with name %s\n", designated_enemy->client->pers.netname);
// else
// gi.dprintf ("NOT A CLIENT\n");
// }
}
else
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("pick coop failed, using my current enemy\n");
designated_enemy = self->enemy;
}
}
}
else
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("pick coop failed, using my current enemy\n");
designated_enemy = self->enemy;
}
}
if ((designated_enemy->inuse) && (designated_enemy->health > 0))
{
ent->enemy = designated_enemy;
FoundTarget (ent);
ent->monsterinfo.attack(ent);
}
}
}
}
void widow2_spawn_check (edict_t *self)
{
Widow2Beam(self);
Widow2Spawn (self);
}
void widow2_ready_spawn (edict_t *self)
{
vec3_t f, r, u, offset, startpoint, spawnpoint;
int i;
Widow2Beam(self);
AngleVectors (self->s.angles, f, r, u);
for (i=0; i < 2; i++)
{
VectorCopy (spawnpoints[i], offset);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
if (FindSpawnPoint (startpoint, stalker_mins, stalker_maxs, spawnpoint, 64))
{
SpawnGrow_Spawn (spawnpoint, 1);
}
}
}
mframe_t widow2_frames_stand [] =
{
// ai_stand, 0, drawbbox
ai_stand, 0, NULL
};
mmove_t widow2_move_stand = {FRAME_blackwidow3, FRAME_blackwidow3, widow2_frames_stand, NULL};
mframe_t widow2_frames_walk [] =
{
// ai_walk, 9.01, drawbbox,
ai_walk, 9.01, NULL,
ai_walk, 7.55, NULL,
ai_walk, 7.01, NULL,
ai_walk, 6.66, NULL,
ai_walk, 6.20, NULL,
ai_walk, 5.78, NULL,
ai_walk, 7.25, NULL,
ai_walk, 8.37, NULL,
ai_walk, 10.41, NULL
};
mmove_t widow2_move_walk = {FRAME_walk01, FRAME_walk09, widow2_frames_walk, NULL};
mframe_t widow2_frames_run [] =
{
// ai_run, 9.01, drawbbox,
ai_run, 9.01, NULL,
ai_run, 7.55, NULL,
ai_run, 7.01, NULL,
ai_run, 6.66, NULL,
ai_run, 6.20, NULL,
ai_run, 5.78, NULL,
ai_run, 7.25, NULL,
ai_run, 8.37, NULL,
ai_run, 10.41, NULL
};
mmove_t widow2_move_run = {FRAME_walk01, FRAME_walk09, widow2_frames_run, NULL};
mframe_t widow2_frames_attack_pre_beam [] =
{
ai_charge, 4, NULL,
ai_charge, 4, NULL,
ai_charge, 4, NULL,
ai_charge, 4, widow2_attack_beam
};
mmove_t widow2_move_attack_pre_beam = {FRAME_fireb01, FRAME_fireb04, widow2_frames_attack_pre_beam, NULL};
// Loop this
mframe_t widow2_frames_attack_beam [] =
{
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, widow2_reattack_beam
};
mmove_t widow2_move_attack_beam = {FRAME_fireb05, FRAME_fireb09, widow2_frames_attack_beam, NULL};
mframe_t widow2_frames_attack_post_beam [] =
{
ai_charge, 4, NULL,
ai_charge, 4, NULL,
ai_charge, 4, NULL
};
mmove_t widow2_move_attack_post_beam = {FRAME_fireb06, FRAME_fireb07, widow2_frames_attack_post_beam, widow2_run};
void WidowDisrupt (edict_t *self)
{
vec3_t start;
vec3_t dir;
vec3_t forward, right;
float len;
AngleVectors (self->s.angles, forward, right, NULL);
G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_WIDOW_DISRUPTOR], forward, right, start);
VectorSubtract (self->pos1, self->enemy->s.origin, dir);
len = VectorLength (dir);
if (len < 30)
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("target locked - dist %2.2f\n", len);
// calc direction to where we targeted
// Lazarus fog reduction of accuracy
if(self->monsterinfo.visibility < FOG_CANSEEGOOD)
{
self->pos1[0] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
self->pos1[1] += crandom() * 640 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
self->pos1[2] += crandom() * 320 * (FOG_CANSEEGOOD - self->monsterinfo.visibility);
}
VectorSubtract (self->pos1, start, dir);
VectorNormalize (dir);
monster_fire_tracker(self, start, dir, 20, 500, self->enemy, MZ2_WIDOW_DISRUPTOR);
}
else
{
// if ((g_showlogic) && (g_showlogic->value))
// gi.dprintf ("target missed - dist %2.2f\n", len);
PredictAim (self->enemy, start, 1200, true, 0, dir, NULL);
// VectorSubtract (self->enemy->s.origin, start, dir);
// VectorNormalize (dir);
monster_fire_tracker(self, start, dir, 20, 1200, NULL, MZ2_WIDOW_DISRUPTOR);
}
}
void Widow2SaveDisruptLoc (edict_t *self)
{
if (self->enemy && self->enemy->inuse)
{
VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
self->pos1[2] += self->enemy->viewheight;
}
else
VectorCopy (vec3_origin, self->pos1);
};
void widow2_disrupt_reattack (edict_t *self)
{
float luck;
luck = random();
if (luck < (0.25 + ((float)(skill->value))*0.15))
self->monsterinfo.nextframe = FRAME_firea01;
}
mframe_t widow2_frames_attack_disrupt [] =
{
ai_charge, 2, NULL,
ai_charge, 2, NULL,
ai_charge, 2, Widow2SaveDisruptLoc,
ai_charge, -20, WidowDisrupt,
ai_charge, 2, NULL,
ai_charge, 2, NULL,
ai_charge, 2, widow2_disrupt_reattack
};
mmove_t widow2_move_attack_disrupt = {FRAME_firea01, FRAME_firea07, widow2_frames_attack_disrupt, widow2_run};
void Widow2SaveBeamTarget (edict_t *self)
{
if (self->enemy && self->enemy->inuse)
{
VectorCopy (self->pos1, self->pos2);
VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
}
else
{
VectorCopy (vec3_origin, self->pos1);
VectorCopy (vec3_origin, self->pos2);
}
}
void Widow2BeamTargetRemove (edict_t *self)
{
VectorCopy (vec3_origin, self->pos1);
VectorCopy (vec3_origin, self->pos2);
}
void Widow2StartSweep (edict_t *self)
{
Widow2SaveBeamTarget (self);
}
mframe_t widow2_frames_spawn [] =
{
ai_charge, 0, NULL,
ai_charge, 0, NULL,
ai_charge, 0, widow_start_spawn,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam, //5
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, widow2_ready_spawn, //10
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, Widow2Beam,
ai_charge, 0, widow2_spawn_check,
ai_charge, 0, NULL, //15
ai_charge, 0, NULL,
ai_charge, 0, NULL,
ai_charge, 0, widow2_reattack_beam
};
mmove_t widow2_move_spawn = {FRAME_spawn01, FRAME_spawn18, widow2_frames_spawn, NULL};
static qboolean widow2_tongue_attack_ok (vec3_t start, vec3_t end, float range)
{
vec3_t dir, angles;
// check for max distance
VectorSubtract (start, end, dir);
if (VectorLength(dir) > range)
return false;
// check for min/max pitch
vectoangles (dir, angles);
if (angles[0] < -180)
angles[0] += 360;
if (fabs(angles[0]) > 30)
return false;
return true;
}
void Widow2Tongue (edict_t *self)
{
vec3_t f, r, u;
vec3_t start, end, dir;
trace_t tr;
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offsets[self->s.frame - FRAME_tongs01], f, r, u, start);
VectorCopy (self->enemy->s.origin, end);
if (!widow2_tongue_attack_ok(start, end, 256))
{
end[2] = self->enemy->s.origin[2] + self->enemy->maxs[2] - 8;
if (!widow2_tongue_attack_ok(start, end, 256))
{
end[2] = self->enemy->s.origin[2] + self->enemy->mins[2] + 8;
if (!widow2_tongue_attack_ok(start, end, 256))
return;
}
}
VectorCopy (self->enemy->s.origin, end);
tr = gi.trace (start, NULL, NULL, end, self, MASK_SHOT);
if (tr.ent != self->enemy)
return;
gi.sound (self, CHAN_WEAPON, sound_tentacles_retract, 1, ATTN_NORM, 0);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_PARASITE_ATTACK);
gi.WriteShort (self - g_edicts);
gi.WritePosition (start);
gi.WritePosition (end);
gi.multicast (self->s.origin, MULTICAST_PVS);
VectorSubtract (start, end, dir);
T_Damage (self->enemy, self, self, dir, self->enemy->s.origin, vec3_origin, 2, 0, DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN);
}
void Widow2TonguePull (edict_t *self)
{
vec3_t vec;
float len;
vec3_t f, r, u;
vec3_t start, end;
if ((!self->enemy) || (!self->enemy->inuse))
{
self->monsterinfo.run (self);
return;
}
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offsets[self->s.frame - FRAME_tongs01], f, r, u, start);
VectorCopy (self->enemy->s.origin, end);
if (!widow2_tongue_attack_ok(start, end, 256))
{
return;
}
if (self->enemy->groundentity)
{
self->enemy->s.origin[2] += 1;
self->enemy->groundentity = NULL;
// interesting, you don't have to relink the player
}
VectorSubtract (self->s.origin, self->enemy->s.origin, vec);
len = VectorLength (vec);
if (self->enemy->client)
{
VectorNormalize (vec);
VectorMA (self->enemy->velocity, 1000, vec, self->enemy->velocity);
}
else
{
self->enemy->ideal_yaw = vectoyaw(vec);
M_ChangeYaw (self->enemy);
VectorScale (f, 1000, self->enemy->velocity);
}
}
void Widow2Crunch (edict_t *self)
{
vec3_t aim;
if ((!self->enemy) || (!self->enemy->inuse))
{
self->monsterinfo.run (self);
return;
}
Widow2TonguePull (self);
// 70 + 32
VectorSet (aim, 150, 0, 4);
if (self->s.frame != FRAME_tongs07)
fire_hit (self, aim, 20 + (rand() % 6), 0);
else
{
if (self->enemy->groundentity)
fire_hit (self, aim, (20 + (rand() % 6)), 500);
else // not as much kick if they're in the air .. makes it harder to land on her head
fire_hit (self, aim, (20 + (rand() % 6)), 250);
}
}
void Widow2Toss (edict_t *self)
{
self->timestamp = level.time + 3;
return;
}
mframe_t widow2_frames_tongs [] =
{
ai_charge, 0, Widow2Tongue,
ai_charge, 0, Widow2Tongue,
ai_charge, 0, Widow2Tongue,
ai_charge, 0, Widow2TonguePull,
ai_charge, 0, Widow2TonguePull, //5
ai_charge, 0, Widow2TonguePull,
ai_charge, 0, Widow2Crunch,
ai_charge, 0, Widow2Toss
};
mmove_t widow2_move_tongs = {FRAME_tongs01, FRAME_tongs08, widow2_frames_tongs, widow2_run};
mframe_t widow2_frames_pain [] =
{
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL
};
mmove_t widow2_move_pain = {FRAME_pain01, FRAME_pain05, widow2_frames_pain, widow2_run};
mframe_t widow2_frames_death [] =
{
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion1, // 3 boom
ai_move, 0, NULL,
ai_move, 0, NULL, // 5
ai_move, 0, WidowExplosion2, // 6 boom
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL, // 10
ai_move, 0, NULL,
ai_move, 0, NULL, // 12
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL, // 15
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion3, // 18
ai_move, 0, NULL, // 19
ai_move, 0, NULL, // 20
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion4, // 25
ai_move, 0, NULL, // 26
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion5,
ai_move, 0, WidowExplosionLeg, // 30
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion6,
ai_move, 0, NULL, // 35
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplosion7,
ai_move, 0, NULL,
ai_move, 0, NULL, // 40
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, NULL,
ai_move, 0, WidowExplode // 44
};
mmove_t widow2_move_death = {FRAME_death01, FRAME_death44, widow2_frames_death, NULL};
void widow2_start_searching (edict_t *self);
void widow2_keep_searching (edict_t *self);
void widow2_finaldeath (edict_t *self);
mframe_t widow2_frames_dead [] =
{
ai_move, 0, widow2_start_searching,
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, widow2_keep_searching
};
mmove_t widow2_move_dead = {FRAME_dthsrh01, FRAME_dthsrh15, widow2_frames_dead, NULL};
mframe_t widow2_frames_really_dead [] =
{
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, widow2_finaldeath
};
mmove_t widow2_move_really_dead = {FRAME_dthsrh16, FRAME_dthsrh22, widow2_frames_really_dead, NULL};
void widow2_start_searching (edict_t *self)
{
self->count = 0;
}
void widow2_keep_searching (edict_t *self)
{
if (self->count <= 2)
{
self->monsterinfo.currentmove = &widow2_move_dead;
self->s.frame = FRAME_dthsrh01;
self->count++;
return;
}
self->monsterinfo.currentmove = &widow2_move_really_dead;
}
void widow2_finaldeath (edict_t *self)
{
VectorSet (self->mins, -70, -70, 0);
VectorSet (self->maxs, 70, 70, 80);
self->movetype = MOVETYPE_TOSS;
// self->svflags |= SVF_DEADMONSTER;
self->takedamage = DAMAGE_YES;
self->nextthink = 0;
gi.linkentity (self);
M_FlyCheck (self);
}
void widow2_stand (edict_t *self)
{
// gi.dprintf ("widow2 stand\n");
self->monsterinfo.currentmove = &widow2_move_stand;
}
void widow2_run (edict_t *self)
{
// gi.dprintf ("widow2 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 = &widow2_move_stand;
else
self->monsterinfo.currentmove = &widow2_move_run;
}
void widow2_walk (edict_t *self)
{
self->monsterinfo.currentmove = &widow2_move_walk;
}
void widow2_melee (edict_t *self)
{
self->monsterinfo.currentmove = &widow2_move_tongs;
}
void widow2_attack (edict_t *self)
{
float range, luck;
qboolean blocked = false;
if (self->monsterinfo.aiflags & AI_BLOCKED)
{
blocked = true;
self->monsterinfo.aiflags &= ~AI_BLOCKED;
}
// gi.dprintf ("widow2 attack\n");
if (!self->enemy)
return;
if (self->bad_area)
{
if ((random() < 0.75) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &widow2_move_attack_pre_beam;
else
{
self->monsterinfo.currentmove = &widow2_move_attack_disrupt;
}
return;
}
WidowCalcSlots(self);
// if we can't see the target, spawn stuff
if ((self->monsterinfo.attack_state == AS_BLIND) && (SELF_SLOTS_LEFT >= 2))
{
self->monsterinfo.currentmove = &widow2_move_spawn;
return;
}
// accept bias towards spawning
if (blocked && (SELF_SLOTS_LEFT >= 2))
{
self->monsterinfo.currentmove = &widow2_move_spawn;
return;
}
range = realrange (self, self->enemy);
if (range < 600)
{
luck = random();
if (SELF_SLOTS_LEFT >= 2)
{
if (luck <= 0.40)
self->monsterinfo.currentmove = &widow2_move_attack_pre_beam;
else if ((luck <= 0.7) && !(level.time < self->monsterinfo.attack_finished))
{
// gi.sound (self, CHAN_WEAPON, sound_disrupt, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &widow2_move_attack_disrupt;
}
else
self->monsterinfo.currentmove = &widow2_move_spawn;
}
else
{
if ((luck <= 0.50) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &widow2_move_attack_pre_beam;
else
{
// gi.sound (self, CHAN_WEAPON, sound_disrupt, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &widow2_move_attack_disrupt;
}
}
}
else
{
luck = random();
if (SELF_SLOTS_LEFT >= 2)
{
if (luck < 0.3)
self->monsterinfo.currentmove = &widow2_move_attack_pre_beam;
else if ((luck < 0.65) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &widow2_move_spawn;
else
{
// gi.sound (self, CHAN_WEAPON, sound_disrupt, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &widow2_move_attack_disrupt;
}
}
else
{
if ((luck < 0.45) || (level.time < self->monsterinfo.attack_finished))
self->monsterinfo.currentmove = &widow2_move_attack_pre_beam;
else
{
// gi.sound (self, CHAN_WEAPON, sound_disrupt, 1, ATTN_NORM, 0);
self->monsterinfo.currentmove = &widow2_move_attack_disrupt;
}
}
}
}
void widow2_attack_beam (edict_t *self)
{
self->monsterinfo.currentmove = &widow2_move_attack_beam;
}
void widow2_reattack_beam (edict_t *self)
{
self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
if ( infront(self, self->enemy) )
if (random() <= 0.5)
if ((random() < 0.7) || (SELF_SLOTS_LEFT < 2))
self->monsterinfo.currentmove = &widow2_move_attack_beam;
else
self->monsterinfo.currentmove = &widow2_move_spawn;
else
self->monsterinfo.currentmove = &widow2_move_attack_post_beam;
else
self->monsterinfo.currentmove = &widow2_move_attack_post_beam;
}
void widow2_pain (edict_t *self, edict_t *other, float kick, int damage)
{
if (self->health < (self->max_health / 2))
{
self->s.skinnum |= 1;
Added support for quake2:// URLs. Pointer fixes to dedicated console. Renamed new teleport event. Partial cleanup to game DLL fog code. Added Zaero monsters and misc entities to missionpack DLL.
2020-04-07 06:02:54 +00:00
if (!(self->fogclip & 2)) // custom bloodtype flag check
self->blood_type = 3; // sparks and blood
Added source code from official mission pack support DLL.
2020-01-05 02:25:00 +00:00
}
if (skill->value == 3)
return; // no pain anims in nightmare
// gi.dprintf ("widow2 pain\n");
if (level.time < self->pain_debounce_time)
return;
self->pain_debounce_time = level.time + 5;
if (damage < 15)
{
gi.sound (self, CHAN_VOICE, sound_pain1, 1, ATTN_NONE, 0);
}
else if (damage < 75)
{
gi.sound (self, CHAN_VOICE, sound_pain2, 1, ATTN_NONE, 0);
if ((skill->value < 3) && (random() < (0.6 - (0.2*((float)skill->value)))))
{
self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
self->monsterinfo.currentmove = &widow2_move_pain;
}
}
else
{
gi.sound (self, CHAN_VOICE, sound_pain3, 1, ATTN_NONE, 0);
if ((skill->value < 3) && (random() < (0.75 - (0.1*((float)skill->value)))))
{
self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
self->monsterinfo.currentmove = &widow2_move_pain;
}
}
}
void widow2_dead (edict_t *self)
{
}
void KillChildren (edict_t *self)
{
edict_t *ent;
int field;
ent = NULL;
field = FOFS(classname);
while (1)
{
ent = G_Find (ent, field, "monster_stalker");
if(!ent)
return;
// FIXME - may need to stagger
if ((ent->inuse) && (ent->health > 0))
T_Damage (ent, self, self, vec3_origin, self->enemy->s.origin, vec3_origin, (ent->health + 1), 0, DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN);
}
}
void widow2_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
int n;
int clipped;
self->s.skinnum |= 1;
if (!(self->fogclip & 2)) //custom bloodtype flag check
self->blood_type = 3; //sparks and blood
self->monsterinfo.power_armor_type = POWER_ARMOR_NONE;
// check for gib
if (self->health <= self->gib_health && !(self->spawnflags & SF_MONSTER_NOGIB))
{
clipped = min (damage, 100);
gi.sound (self, CHAN_VOICE, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/bone/tris.md2", clipped, GIB_ORGANIC, NULL, false);
for (n= 0; n < 3; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", clipped, GIB_ORGANIC, NULL, false);
for (n= 0; n < 3; n++)
{
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib1/tris.md2", clipped, GIB_METALLIC, NULL,
0, false);
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib2/tris.md2", clipped, GIB_METALLIC, NULL,
gi.soundindex ("misc/fhit3.wav"), false);
}
for (n= 0; n < 2; n++)
{
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib3/tris.md2", clipped, GIB_METALLIC, NULL,
0, false);
ThrowWidowGibSized (self, "models/monsters/blackwidow/gib3/tris.md2", clipped, GIB_METALLIC, NULL,
0, false);
}
ThrowGib (self, "models/objects/gibs/chest/tris.md2", clipped, GIB_ORGANIC);
ThrowHead (self, "models/objects/gibs/head2/tris.md2", clipped, GIB_ORGANIC);
self->deadflag = DEAD_DEAD;
return;
}
if (self->deadflag == DEAD_DEAD)
return;
gi.sound (self, CHAN_VOICE, sound_death, 1, ATTN_NONE, 0);
self->deadflag = DEAD_DEAD;
self->takedamage = DAMAGE_NO;
self->count = 0;
KillChildren (self);
self->monsterinfo.quad_framenum = 0;
self->monsterinfo.double_framenum = 0;
self->monsterinfo.invincible_framenum = 0;
self->monsterinfo.currentmove = &widow2_move_death;
}
qboolean Widow2_CheckAttack (edict_t *self)
{
vec3_t spot1, spot2;
vec3_t temp;
float chance;
trace_t tr;
qboolean enemy_infront;
int enemy_range;
float enemy_yaw;
float real_enemy_range;
vec3_t f, r, u;
if (!self->enemy)
return false;
WidowPowerups(self);
if ((random() < 0.8) && (SELF_SLOTS_LEFT >= 2) && (realrange(self, self->enemy) > 150))
{
self->monsterinfo.aiflags |= AI_BLOCKED;
self->monsterinfo.attack_state = AS_MISSILE;
return true;
}
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_SLOTS_LEFT >= 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_range = range(self, self->enemy);
VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
enemy_yaw = vectoyaw2(temp);
self->ideal_yaw = enemy_yaw;
// melee attack
if (self->timestamp < level.time)
{
real_enemy_range = realrange (self, self->enemy);
if (real_enemy_range < 300)
{
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offsets[0], f, r, u, spot1);
VectorCopy (self->enemy->s.origin, spot2);
if (widow2_tongue_attack_ok(spot1, spot2, 256))
{
// melee attack ok
// be nice in easy mode
if (skill->value == 0 && (rand()&3) )
return false;
if (self->monsterinfo.melee)
self->monsterinfo.attack_state = AS_MELEE;
else
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_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 + 1.0 + 2*random();
return true;
}
return false;
}
void Widow2Precache ()
{
// cache in all of the stalker stuff, widow stuff, spawngro stuff, gibs
//Knightmare- I disabled these, since they weren't used.
// gi.soundindex ("parasite/parpain1.wav");
// gi.soundindex ("parasite/parpain2.wav");
// gi.soundindex ("parasite/pardeth1.wav");
// gi.soundindex ("parasite/paratck1.wav");
// gi.soundindex ("parasite/parsght1.wav");
gi.soundindex ("infantry/melee2.wav");
gi.soundindex ("misc/fhit3.wav");
gi.soundindex ("tank/tnkatck3.wav");
gi.soundindex ("weapons/disrupt.wav");
gi.soundindex ("weapons/disint2.wav");
gi.modelindex ("models/monsters/stalker/tris.md2");
gi.modelindex ("models/items/spawngro2/tris.md2");
gi.modelindex ("models/objects/gibs/sm_metal/tris.md2");
gi.modelindex ("models/proj/laser2/tris.md2");
gi.modelindex ("models/proj/disintegrator/tris.md2");
gi.modelindex ("models/monsters/blackwidow/gib1/tris.md2");
gi.modelindex ("models/monsters/blackwidow/gib2/tris.md2");
gi.modelindex ("models/monsters/blackwidow/gib3/tris.md2");
//Knightmare- this isn't used
//gi.modelindex ("models/monsters/blackwidow/gib4/tris.md2");
gi.modelindex ("models/monsters/blackwidow2/gib1/tris.md2");
gi.modelindex ("models/monsters/blackwidow2/gib2/tris.md2");
gi.modelindex ("models/monsters/blackwidow2/gib3/tris.md2");
gi.modelindex ("models/monsters/blackwidow2/gib4/tris.md2");
}
/*QUAKED monster_widow2 (1 .5 0) (-70 -70 0) (70 70 144) Ambush Trigger_Spawn Sight GoodGuy NoGib
*/
void SP_monster_widow2 (edict_t *self)
{
if (deathmatch->value)
{
G_FreeEdict (self);
return;
}
sound_pain1 = gi.soundindex ("widow/bw2pain1.wav");
sound_pain2 = gi.soundindex ("widow/bw2pain2.wav");
sound_pain3 = gi.soundindex ("widow/bw2pain3.wav");
sound_death = gi.soundindex ("widow/death.wav");
sound_search1 = gi.soundindex ("bosshovr/bhvunqv1.wav");
// sound_disrupt = gi.soundindex ("gladiator/railgun.wav");
sound_tentacles_retract = gi.soundindex ("brain/brnatck3.wav");
// self->s.sound = gi.soundindex ("bosshovr/bhvengn1.wav");
self->movetype = MOVETYPE_STEP;
self->solid = SOLID_BBOX;
// Lazarus: special purpose skins
if ( self->style )
{
PatchMonsterModel("models/monsters/blackwidow2/tris.md2");
self->s.skinnum = self->style * 2;
// self->style = 0; //clear for custom bloodtype flag
}
self->s.modelindex = gi.modelindex ("models/monsters/blackwidow2/tris.md2");
VectorSet (self->mins, -70, -70, 0);
VectorSet (self->maxs, 70, 70, 144);
if(!self->health)
self->health = 2000 + 800 + 1000 * (skill->value);
if (coop->value)
self->health += 500 * (skill->value);
if(!self->gib_health)
self->gib_health = -999;
if(!self->mass)
self->mass = 2500;
// Lazarus
if(self->powerarmor)
{
if (self->powerarmortype == 1)
self->monsterinfo.power_armor_type = POWER_ARMOR_SCREEN;
else
self->monsterinfo.power_armor_type = POWER_ARMOR_SHIELD;
self->monsterinfo.power_armor_power = self->powerarmor;
}
/* if (skill->value == 2)
{
self->monsterinfo.power_armor_type = POWER_ARMOR_SHIELD;
self->monsterinfo.power_armor_power = 500;
}*/
else if (skill->value == 3)
{
self->monsterinfo.power_armor_type = POWER_ARMOR_SHIELD;
self->monsterinfo.power_armor_power = 750;
}
self->yaw_speed = 30;
self->flags |= FL_IMMUNE_LASER;
self->monsterinfo.aiflags |= AI_IGNORE_SHOTS;
self->pain = widow2_pain;
self->die = widow2_die;
self->monsterinfo.melee = widow2_melee;
self->monsterinfo.stand = widow2_stand;
self->monsterinfo.walk = widow2_walk;
self->monsterinfo.run = widow2_run;
self->monsterinfo.attack = widow2_attack;
self->monsterinfo.search = widow2_search;
self->monsterinfo.checkattack = Widow2_CheckAttack;
if (!self->blood_type)
self->blood_type = 2; //sparks
else
self->fogclip |= 2; //custom bloodtype flag
self->common_name = "Black Widow";
gi.linkentity (self);
self->monsterinfo.currentmove = &widow2_move_stand;
self->monsterinfo.scale = MODEL_SCALE;
Widow2Precache();
WidowCalcSlots(self);
walkmonster_start (self);
}
//
// Death sequence stuff
//
void WidowVelocityForDamage (int damage, vec3_t v)
{
v[0] = damage * crandom();
v[1] = damage * crandom();
v[2] = damage * crandom() + 200.0;
}
void widow_gib_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
self->solid = SOLID_NOT;
self->touch = NULL;
self->s.angles[PITCH] = 0;
self->s.angles[ROLL] = 0;
VectorClear (self->avelocity);
if (self->plat2flags)
gi.sound (self, CHAN_VOICE, self->plat2flags, 1, ATTN_NORM, 0);
/*
if (plane)
{
if (plane->normal[2] < -0.8)
{
gi.sound (self, CHAN_VOICE, gi.soundindex ("misc/fhit3.wav"), 1, ATTN_NORM, 0);
}
//vectoangles (plane->normal, normal_angles);
//AngleVectors (normal_angles, NULL, right, NULL);
//vectoangles (right, self->s.angles);
//VectorClear (self->avelocity);
}
*/
}
void ThrowWidowGib (edict_t *self, char *gibname, int damage, int type)
{
ThrowWidowGibReal (self, gibname, damage, type, NULL, false, 0, true);
}
void ThrowWidowGibLoc (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean fade)
{
ThrowWidowGibReal (self, gibname, damage, type, startpos, false, 0, fade);
}
void ThrowWidowGibSized (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, int hitsound, qboolean fade)
{
ThrowWidowGibReal (self, gibname, damage, type, startpos, true, hitsound, fade);
}
void ThrowWidowGibReal (edict_t *self, char *gibname, int damage, int type, vec3_t startpos, qboolean sized, int hitsound, qboolean fade)
{
edict_t *gib;
vec3_t vd;
vec3_t origin;
vec3_t size;
float vscale;
if (!gibname)
return;
gib = G_Spawn();
if (startpos)
VectorCopy (startpos, gib->s.origin);
else
{
VectorScale (self->size, 0.5, size);
VectorAdd (self->absmin, size, origin);
gib->s.origin[0] = origin[0] + crandom() * size[0];
gib->s.origin[1] = origin[1] + crandom() * size[1];
gib->s.origin[2] = origin[2] + crandom() * size[2];
}
gib->solid = SOLID_NOT;
gib->s.effects |= EF_GIB;
gib->flags |= FL_NO_KNOCKBACK;
gib->takedamage = DAMAGE_YES;
gib->die = gib_die;
gib->s.renderfx |= RF_IR_VISIBLE;
if (fade)
{
if (!sized) //only nonsized gibs fade
{
gib->think = gib_fade; //Knightmare- gib fade, was G_FreeEdict
gib->nextthink = level.time + 5 + random()*10;
}
// sized gibs last longer
/* if (sized)
gib->nextthink = level.time + 20 + random()*15;
else
gib->nextthink = level.time + 5 + random()*10;*/
}
else
{
if (!sized) //only nonsized gibs fade
{
gib->think = gib_fade; //Knightmare- gib fade, was G_FreeEdict
gib->nextthink = level.time + 25 + random()*10;
}
// sized gibs last longer
/* if (sized)
gib->nextthink = level.time + 60 + random()*15;
else
gib->nextthink = level.time + 25 + random()*10;*/
}
if (type == GIB_ORGANIC)
{
gib->movetype = MOVETYPE_BOUNCE; //was MOVETYPE_TOSS
gib->touch = gib_touch;
vscale = 1.5;
}
else
{
gib->movetype = MOVETYPE_BOUNCE;
vscale = 1.0;
}
WidowVelocityForDamage (damage, vd);
VectorMA (self->velocity, vscale, vd, gib->velocity);
ClipGibVelocity (gib);
gi.setmodel (gib, gibname);
if (sized)
{
gib->plat2flags = hitsound;
gib->solid = SOLID_BBOX;
gib->avelocity[0] = random()*400;
gib->avelocity[1] = random()*400;
gib->avelocity[2] = random()*200;
if (gib->velocity[2] < 0)
gib->velocity[2] *= -1;
gib->velocity[0] *= 2;
gib->velocity[1] *= 2;
ClipGibVelocity (gib);
gib->velocity[2] = max((350 + (random()*100.0)), gib->velocity[2]);
gib->gravity = 0.25;
gib->touch = widow_gib_touch;
gib->owner = self;
if (gib->s.modelindex == gi.modelindex ("models/monsters/blackwidow2/gib2/tris.md2"))
{
VectorSet (gib->mins, -10, -10, 0);
VectorSet (gib->maxs, 10, 10, 10);
}
else
{
VectorSet (gib->mins, -5, -5, 0);
VectorSet (gib->maxs, 5, 5, 5);
}
}
else
{
gib->velocity[0] *= 2;
gib->velocity[1] *= 2;
gib->avelocity[0] = random()*600;
gib->avelocity[1] = random()*600;
gib->avelocity[2] = random()*600;
}
// gib->think = G_FreeEdict;
// gib->nextthink = level.time + 10 + random()*10;
gi.linkentity (gib);
}
void BloodFountain (edict_t *self, int number, vec3_t startpos, int damage)
{
int n;
vec3_t vd;
vec3_t origin, size, velocity;
return;
for (n= 0; n < number; n++)
{
if (startpos)
VectorCopy (startpos, origin);
else
{
VectorScale (self->size, 0.5, size);
VectorAdd (self->absmin, size, origin);
origin[0] = origin[0] + crandom() * size[0];
origin[1] = origin[1] + crandom() * size[1];
origin[2] = origin[2] + crandom() * size[2];
}
WidowVelocityForDamage (damage, vd);
VectorMA (self->velocity, 1.0, vd, velocity);
velocity[0] *= 2;
velocity[1] *= 2;
// gi.WriteByte (svc_temp_entity);
// gi.WriteByte (TE_BLOOD_FOUNTAIN);
// gi.WritePosition (origin);
// gi.WritePosition (velocity);
// gi.WriteShort (50);
// gi.multicast (self->s.origin, MULTICAST_ALL);
}
}
void ThrowSmallStuff (edict_t *self, vec3_t point)
{
int n;
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, point, false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, point, false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, point, false);
}
void ThrowMoreStuff (edict_t *self, vec3_t point)
{
int n;
if (coop && coop->value)
{
ThrowSmallStuff (self, point);
return;
}
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, point, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, point, false);
for (n= 0; n < 3; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, point, false);
}
void WidowExplode (edict_t *self)
{
vec3_t org;
int n;
self->think = WidowExplode;
// gi.dprintf ("count = %d\n");
//redo:
VectorCopy (self->s.origin, org);
org[2] += 24 + (rand()&15);
if (self->count < 8)
org[2] += 24 + (rand()&31);
switch (self->count)
{
case 0:
org[0] -= 24;
org[1] -= 24;
break;
case 1:
org[0] += 24;
org[1] += 24;
ThrowSmallStuff(self, org);
break;
case 2:
org[0] += 24;
org[1] -= 24;
break;
case 3:
org[0] -= 24;
org[1] += 24;
ThrowMoreStuff(self, org);
break;
case 4:
org[0] -= 48;
org[1] -= 48;
break;
case 5:
org[0] += 48;
org[1] += 48;
ThrowArm1 (self);
break;
case 6:
org[0] -= 48;
org[1] += 48;
ThrowArm2 (self);
break;
case 7:
org[0] += 48;
org[1] -= 48;
ThrowSmallStuff(self, org);
break;
case 8:
org[0] += 18;
org[1] += 18;
org[2] = self->s.origin[2] + 48;
ThrowMoreStuff(self, org);
break;
case 9:
org[0] -= 18;
org[1] += 18;
org[2] = self->s.origin[2] + 48;
break;
case 10:
org[0] += 18;
org[1] -= 18;
org[2] = self->s.origin[2] + 48;
break;
case 11:
org[0] -= 18;
org[1] -= 18;
org[2] = self->s.origin[2] + 48;
break;
case 12:
self->s.sound = 0;
for (n= 0; n < 1; n++)
ThrowWidowGib (self, "models/objects/gibs/sm_meat/tris.md2", 400, GIB_ORGANIC);
for (n= 0; n < 2; n++)
ThrowWidowGib (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC);
for (n= 0; n < 2; n++)
ThrowWidowGib (self, "models/objects/gibs/sm_metal/tris.md2", 400, GIB_METALLIC);
// ThrowGib (self, "models/objects/gibs/chest/tris.md2", 1000, GIB_ORGANIC);
// ThrowHead (self, "models/objects/gibs/gear/tris.md2", 1000, GIB_METALLIC);
self->deadflag = DEAD_DEAD;
self->think = monster_think;
self->nextthink = level.time + 0.1;
self->monsterinfo.currentmove = &widow2_move_dead;
return;
}
self->count++;
if (self->count >=9 && self->count <=12)
{
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1_BIG);
gi.WritePosition (org);
gi.multicast (self->s.origin, MULTICAST_ALL);
// goto redo;
}
else
{
// else
gi.WriteByte (svc_temp_entity);
if (self->count %2)
gi.WriteByte (TE_EXPLOSION1);
else
gi.WriteByte (TE_EXPLOSION1_NP);
gi.WritePosition (org);
gi.multicast (self->s.origin, MULTICAST_ALL);
}
self->nextthink = level.time + 0.1;
}
void WidowExplosion1 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {23.74, -37.67, 76.96};
// gi.dprintf ("1\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion2 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {-20.49, 36.92, 73.52};
// gi.dprintf ("2\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion3 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {2.11, 0.05, 92.20};
// gi.dprintf ("3\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion4 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {-28.04, -35.57, -77.56};
// gi.dprintf ("4\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion5 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {-20.11, -1.11, 40.76};
// gi.dprintf ("5\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion6 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {-20.11, -1.11, 40.76};
//gi.dprintf ("6\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosion7 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset = {-20.11, -1.11, 40.76};
//gi.dprintf ("7\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
for (n= 0; n < 1; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 300, GIB_METALLIC, startpoint, false);
}
void WidowExplosionLeg (edict_t *self)
{
// int n;
vec3_t f,r,u, startpoint;
vec3_t offset1 = {-31.89, -47.86, 67.02};
vec3_t offset2 = {-44.9, -82.14, 54.72};
//gi.dprintf ("Leg\n");
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset1, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1_BIG);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib2/tris.md2", 200, GIB_METALLIC, startpoint,
gi.soundindex ("misc/fhit3.wav"), false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
G_ProjectSource2 (self->s.origin, offset2, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib1/tris.md2", 300, GIB_METALLIC, startpoint,
gi.soundindex ("misc/fhit3.wav"), false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
}
void ThrowArm1 (edict_t *self)
{
int n;
vec3_t f,r,u, startpoint;
vec3_t offset1 = {65.76, 17.52, 7.56};
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset1, f, r, u, startpoint);
gi.WriteByte (svc_temp_entity);
gi.WriteByte (TE_EXPLOSION1_BIG);
gi.WritePosition (startpoint);
gi.multicast (self->s.origin, MULTICAST_ALL);
for (n= 0; n < 2; n++)
ThrowWidowGibLoc (self, "models/objects/gibs/sm_metal/tris.md2", 100, GIB_METALLIC, startpoint, false);
}
void ThrowArm2 (edict_t *self)
{
// int n;
vec3_t f,r,u, startpoint;
vec3_t offset1 = {65.76, 17.52, 7.56};
AngleVectors (self->s.angles, f, r, u);
G_ProjectSource2 (self->s.origin, offset1, f, r, u, startpoint);
ThrowWidowGibSized (self, "models/monsters/blackwidow2/gib4/tris.md2", 200, GIB_METALLIC, startpoint,
gi.soundindex ("misc/fhit3.wav"), false);
ThrowWidowGibLoc (self, "models/objects/gibs/sm_meat/tris.md2", 300, GIB_ORGANIC, startpoint, false);
}
Reference in a new issue Copy permalink