468 lines
16 KiB
C
468 lines
16 KiB
C
//
|
|
// Heretic II
|
|
// Copyright 1998 Raven Software
|
|
//
|
|
|
|
#include "g_local.h"
|
|
#include "fx.h"
|
|
#include "vector.h"
|
|
#include "angles.h"
|
|
#include "matrix.h"
|
|
#include "g_volume_effect.h"
|
|
#include "Utilities.h"
|
|
#include "g_playstats.h"
|
|
#include "random.h"
|
|
|
|
#define ARROW_RADIUS 2.0F
|
|
#define ARROW_BACKUP (45.0F - ARROW_RADIUS)
|
|
|
|
extern void AlertMonsters (edict_t *self, edict_t *enemy, float lifetime, qboolean ignore_shadows);
|
|
|
|
void create_redarrow(edict_t *redarrow);
|
|
|
|
void RedRainRemove(edict_t *self)
|
|
{
|
|
gi.RemoveEffects(&self->s, 0);
|
|
G_SetToFree(self);
|
|
}
|
|
|
|
void RedRainThink(edict_t *self)
|
|
{
|
|
edict_t *victim=NULL;
|
|
vec3_t startpos, endpos, diffpos, min, max, hitpos, vec;
|
|
trace_t trace;
|
|
qboolean poweredup;
|
|
float lradius, rradius, rad_dmg;
|
|
int damage;
|
|
|
|
if(deathmatch->value)
|
|
rad_dmg = self->dmg * 0.25;
|
|
else
|
|
rad_dmg = self->dmg;
|
|
|
|
// find all the entities in the volume
|
|
while(victim = findinblocking(victim, self))
|
|
{
|
|
if(victim != self->owner && victim->takedamage &&
|
|
(victim->client || victim->svflags & SVF_MONSTER) && !(victim->svflags & SVF_DEADMONSTER))
|
|
{ // No damage to casting player
|
|
VectorSubtract(self->pos1, victim->s.origin, vec);
|
|
VectorNormalize(vec);
|
|
VectorMA(victim->s.origin, victim->maxs[0], vec, hitpos);
|
|
|
|
if (victim->svflags & SVF_BOSS)
|
|
{
|
|
T_Damage(victim, self, self->owner, vec3_origin, hitpos, vec3_origin,
|
|
rad_dmg/2, 0, DAMAGE_SPELL,MOD_STORM);
|
|
}
|
|
else
|
|
{
|
|
T_Damage(victim, self, self->owner, vec3_origin, hitpos, vec3_origin,
|
|
rad_dmg, 0, DAMAGE_SPELL,MOD_STORM);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (self->delay <= level.time || (self->owner->red_rain_count - self->red_rain_count) > NUM_STORMS_PER_PLAYER)
|
|
{
|
|
self->owner->red_rain_count--;
|
|
self->s.effects |= EF_DISABLE_EXTRA_FX;
|
|
self->nextthink = level.time + 1.0;//lasts another 1.0 secs
|
|
self->think = RedRainRemove;
|
|
}
|
|
else
|
|
{
|
|
// Powerup value comes from the health in the edict.
|
|
poweredup = self->health;
|
|
|
|
// Check for lightning
|
|
if (self->delay - level.time < RED_RAIN_LIGHTNING_DURATION && irand(0, RED_RAIN_LIGHTNING_CHANCE) == 0)
|
|
{ // First check the area for a potential victim.
|
|
if (!poweredup)
|
|
{
|
|
rradius = RED_RAIN_RADIUS;
|
|
lradius = RED_RAIN_LIGHTNING_RADIUS;
|
|
}
|
|
else
|
|
{
|
|
rradius = POWER_RAIN_RADIUS;
|
|
lradius = POWER_RAIN_LIGHTNING_RADIUS;
|
|
}
|
|
|
|
// Find the bounds to search under.
|
|
VectorSet(min, -lradius, -lradius, self->mins[2]);
|
|
// Only search the lower half of the area for lightning hits.
|
|
VectorSet(max, lradius, lradius, self->mins[2] + ((self->maxs[2] - self->mins[2])*0.5));
|
|
VectorAdd(self->s.origin, min, min);
|
|
VectorAdd(self->s.origin, max, max);
|
|
victim=NULL;
|
|
while (victim = findinbounds(victim, min, max))
|
|
{
|
|
if (victim != self->owner && victim->takedamage &&
|
|
(victim->client || victim->svflags & SVF_MONSTER) && !(victim->svflags & SVF_DEADMONSTER))
|
|
break;
|
|
}
|
|
if (victim)
|
|
{ // Try to zap somebody with lightning
|
|
VectorSet(startpos,
|
|
flrand(-rradius*0.6, rradius*0.6),
|
|
flrand(-rradius*0.6, rradius*0.6),
|
|
self->maxs[2]);
|
|
VectorAdd(startpos, self->s.origin, startpos);
|
|
VectorSet(endpos,
|
|
flrand(victim->mins[0]*0.5, victim->maxs[0]*0.5),
|
|
flrand(victim->mins[1]*0.5, victim->maxs[1]*0.5),
|
|
flrand(victim->mins[2]*0.5, victim->maxs[2]*0.5));
|
|
VectorAdd(endpos, victim->s.origin, endpos);
|
|
|
|
gi.trace(startpos, vec3_origin, vec3_origin, endpos, self->owner, MASK_SOLID,&trace);
|
|
if (!trace.startsolid && trace.fraction == 1.0)
|
|
{ // FINALLY! A clear lightning strike!
|
|
VectorSubtract(endpos, startpos, diffpos);
|
|
VectorNormalize(diffpos);
|
|
if (!poweredup)
|
|
{
|
|
gi.CreateEffect(NULL, FX_LIGHTNING, CEF_FLAG6,
|
|
startpos, "vbb", endpos, (byte)RED_RAIN_LIGHTNING_WIDTH, (byte)0);
|
|
gi.sound(victim,CHAN_WEAPON,gi.soundindex("weapons/Lightning.wav"),1,ATTN_NORM,0);
|
|
|
|
// Do a nasty looking blast at the impact point
|
|
gi.CreateEffect(&victim->s, FX_LIGHTNING_HIT, CEF_OWNERS_ORIGIN | CEF_FLAG7, NULL, "t", diffpos);
|
|
|
|
if(!(EntReflecting(victim, true, true)))
|
|
{
|
|
T_Damage(victim, self, self->owner, diffpos, endpos, vec3_origin,
|
|
irand(RED_RAIN_DMG_LIGHTNING_MIN, RED_RAIN_DMG_LIGHTNING_MAX), 0, DAMAGE_SPELL,MOD_STORM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gi.CreateEffect(NULL, FX_POWER_LIGHTNING, 0,
|
|
startpos, "vb", endpos, (byte)POWER_RAIN_LIGHTNING_WIDTH);
|
|
gi.sound(victim,CHAN_WEAPON,gi.soundindex("weapons/LightningPower.wav"),1,ATTN_NORM,0);
|
|
|
|
if(!(EntReflecting(victim, true, true)))
|
|
{
|
|
damage = irand(POWER_RAIN_DMG_LIGHTNING_MIN, POWER_RAIN_DMG_LIGHTNING_MAX);
|
|
|
|
T_DamageRadiusFromLoc(endpos, self, self->owner, self->owner, POWER_RAIN_DMG_LIGHTNING_RADIUS,
|
|
damage, damage*0.25, DAMAGE_SPELL,MOD_P_STORM);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VectorSet(startpos,
|
|
flrand(-rradius*0.75, rradius*0.75),
|
|
flrand(-rradius*0.75, rradius*0.75),
|
|
self->maxs[2]);
|
|
VectorAdd(startpos, self->s.origin, startpos);
|
|
VectorSet(endpos,
|
|
flrand(-rradius, rradius),
|
|
flrand(-rradius, rradius),
|
|
self->mins[2]);
|
|
VectorAdd(endpos, self->s.origin, endpos);
|
|
if (!poweredup)
|
|
{
|
|
gi.CreateEffect(NULL, FX_LIGHTNING, CEF_FLAG6,
|
|
startpos, "vbb", endpos, (byte)RED_RAIN_LIGHTNING_WIDTH, (byte)0);
|
|
gi.sound(self, CHAN_WEAPON, gi.soundindex("weapons/Lightning.wav"), 2, ATTN_NORM,0);
|
|
}
|
|
else
|
|
{
|
|
gi.CreateEffect(NULL, FX_POWER_LIGHTNING, 0,
|
|
startpos, "vb", endpos, (byte)POWER_RAIN_LIGHTNING_WIDTH);
|
|
gi.sound(self, CHAN_WEAPON, gi.soundindex("weapons/LightningPower.wav"), 2, ATTN_NORM,0);
|
|
|
|
// The lightning does radius damage even if no target.
|
|
damage = irand(POWER_RAIN_DMG_LIGHTNING_MIN, POWER_RAIN_DMG_LIGHTNING_MAX);
|
|
T_DamageRadiusFromLoc(endpos, self, self->owner, self->owner, POWER_RAIN_DMG_LIGHTNING_RADIUS,
|
|
damage, damage*0.25, DAMAGE_SPELL,MOD_P_STORM);
|
|
}
|
|
}
|
|
}
|
|
self->nextthink = level.time + self->wait;
|
|
}
|
|
}
|
|
|
|
|
|
// ****************************************************************************
|
|
// RedRainMissile reflect
|
|
// ****************************************************************************
|
|
|
|
edict_t *RedRainMissileReflect(edict_t *self, edict_t *other, vec3_t vel)
|
|
{
|
|
edict_t *redarrow;
|
|
|
|
// create a new missile to replace the old one - this is necessary cos physics will do nasty shit
|
|
// with the existing one,since we hit something. Hence, we create a new one totally.
|
|
redarrow = G_Spawn();
|
|
VectorCopy(self->s.origin, redarrow->s.origin);
|
|
redarrow->health = self->health;
|
|
redarrow->owner = other;
|
|
redarrow->enemy = self->owner;
|
|
redarrow->owner->red_rain_count++;
|
|
self->owner->red_rain_count--;
|
|
create_redarrow(redarrow);
|
|
|
|
VectorCopy(vel, redarrow->velocity);
|
|
redarrow->reflect_debounce_time = self->reflect_debounce_time -1;
|
|
G_LinkMissile(redarrow);
|
|
gi.CreateEffect(&redarrow->s, FX_WEAPON_REDRAINMISSILE,
|
|
CEF_OWNERS_ORIGIN|(redarrow->health<<5)|CEF_FLAG8, NULL, "t", redarrow->velocity);
|
|
|
|
// kill the existing missile, since its a pain in the ass to modify it so the physics won't screw it.
|
|
G_SetToFree(self);
|
|
|
|
// Do a nasty looking blast at the impact point
|
|
gi.CreateEffect(&redarrow->s, FX_LIGHTNING_HIT, CEF_OWNERS_ORIGIN, NULL, "t", redarrow->velocity);
|
|
|
|
return(redarrow);
|
|
}
|
|
|
|
|
|
// ****************************************************************************
|
|
// RedRainMissile touch
|
|
// ****************************************************************************
|
|
|
|
void RedRainMissileTouch(edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surface)
|
|
{
|
|
vec3_t org, end;
|
|
edict_t *damagearea;
|
|
trace_t trace;
|
|
float radius;
|
|
|
|
// has the target got reflection turned on ?
|
|
if (self->reflect_debounce_time)
|
|
{
|
|
if(EntReflecting(other, true, true))
|
|
{
|
|
Create_rand_relect_vect(self->velocity, self->velocity);
|
|
Vec3ScaleAssign(RED_ARROW_SPEED/2, self->velocity);
|
|
RedRainMissileReflect(self, other, self->velocity);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(other->takedamage)
|
|
{ // Damage from direct impact of arrow, normal or powered up.
|
|
T_Damage(other, self, self->owner, self->movedir, self->s.origin, plane->normal, self->dmg, self->dmg, DAMAGE_SPELL,MOD_STORM);
|
|
}
|
|
AlertMonsters (self, self->owner, 5, false);
|
|
|
|
// Backup effect a little so it doesn`t appear in the wall (but only if we hit the wall)
|
|
if(other->svflags & SVF_MONSTER)
|
|
{
|
|
VectorCopy(self->s.origin, org);
|
|
}
|
|
else
|
|
{
|
|
VectorNormalize2(self->velocity, org);
|
|
Vec3ScaleAssign(-ARROW_BACKUP, org);
|
|
Vec3AddAssign(self->s.origin, org);
|
|
}
|
|
VectorClear(self->velocity);
|
|
|
|
// Create a damage handling effect
|
|
damagearea = G_Spawn();
|
|
VectorCopy(org, damagearea->s.origin);
|
|
damagearea->think = RedRainThink;
|
|
damagearea->nextthink = level.time + RED_RAIN_DAMAGE_INTERVAL;
|
|
damagearea->solid = SOLID_NOT;
|
|
damagearea->clipmask = CONTENTS_EMPTY;
|
|
damagearea->movetype = MOVETYPE_FLYMISSILE; // Necessary for proper processing of thinkers
|
|
damagearea->wait = RED_RAIN_DAMAGE_INTERVAL;
|
|
if(deathmatch->value)
|
|
damagearea->delay = level.time + RED_RAIN_DURATION - 2;//5 secs in DM
|
|
else
|
|
damagearea->delay = level.time + RED_RAIN_DURATION;
|
|
damagearea->owner = self->owner;
|
|
damagearea->red_rain_count = self->owner->red_rain_count;
|
|
damagearea->classname = "Spell_RedRain";
|
|
damagearea->health = self->health; // Copy over the powerup status.
|
|
damagearea->s.effects |= EF_ALWAYS_ADD_EFFECTS;
|
|
|
|
if (self->health == 0)
|
|
{ // Not powered up
|
|
damagearea->dmg = RED_RAIN_DAMAGE;
|
|
radius = RED_RAIN_RADIUS;
|
|
}
|
|
else
|
|
{ // Powered up rain
|
|
damagearea->dmg = POWER_RAIN_DAMAGE;
|
|
radius = POWER_RAIN_RADIUS;
|
|
}
|
|
|
|
// Find the top of the damage area. Check down in an area less than the max size.
|
|
VectorSet(damagearea->mins, -radius*0.5, -radius*0.5, -1.0F);
|
|
VectorSet(damagearea->maxs, radius*0.5, radius*0.5, 1.0F);
|
|
VectorCopy(org, end);
|
|
end[2] += MAX_REDRAINHEIGHT;
|
|
|
|
gi.trace(org, damagearea->mins, damagearea->maxs, end, damagearea, MASK_SOLID,&trace);
|
|
// if(trace.startsolid) // Ignore startsolids.
|
|
// damagearea->maxs[2] = 1.0;
|
|
// else
|
|
if (trace.fraction == 1.0F)
|
|
damagearea->maxs[2] = MAX_REDRAINHEIGHT; // Put the bounds up all the way
|
|
else
|
|
damagearea->maxs[2] = trace.endpos[2] - org[2]; // Set the bounds up only part way
|
|
|
|
// Find the bottom of the damage area.
|
|
end[2] = org[2] - MAX_REDRAINFALLDIST;
|
|
|
|
gi.trace(org, damagearea->mins, damagearea->maxs, end, damagearea, MASK_SOLID,&trace);
|
|
// if(trace.startsolid) // Startsolids mean that the area is too close to a wall
|
|
// damagearea->mins[2] = -1.0;
|
|
// else
|
|
if (trace.fraction == 1.0F)
|
|
damagearea->mins[2] = -MAX_REDRAINFALLDIST; // Put the bounds down all the way
|
|
else
|
|
damagearea->mins[2] = trace.endpos[2] - org[2]; // Set the bounds down where the trace stopped
|
|
|
|
// Put the bounds of the damage area out to the max position now.
|
|
damagearea->mins[0] = damagearea->mins[1] = -radius;
|
|
damagearea->maxs[0] = damagearea->maxs[1] = radius;
|
|
|
|
VectorSet(damagearea->pos1, damagearea->s.origin[0], damagearea->s.origin[1], damagearea->maxs[2]);
|
|
|
|
gi.linkentity(damagearea);
|
|
|
|
// Start the red rain
|
|
// Send along the health as a flag, to indicate if powered up.
|
|
gi.CreateEffect(&damagearea->s, FX_WEAPON_REDRAIN, CEF_BROADCAST|(self->health<<5), org, "");
|
|
|
|
// gi.sound(damagearea, CHAN_VOICE, gi.soundindex("weapons/RedRainFall.wav"), 2, ATTN_NORM,0);
|
|
damagearea->s.sound = gi.soundindex("weapons/RedRainFall.wav");
|
|
damagearea->s.sound_data = (255 & ENT_VOL_MASK) | ATTN_NORM;
|
|
|
|
// Turn off the client effect
|
|
gi.RemoveEffects(&self->s, FX_WEAPON_REDRAINMISSILE);
|
|
G_SetToFree(self);
|
|
}
|
|
|
|
|
|
// ****************************************************************************
|
|
// RedRainMissile think
|
|
// ****************************************************************************
|
|
|
|
void RedRainMissileThink(edict_t *self)
|
|
{
|
|
self->svflags |= SVF_NOCLIENT;
|
|
self->think = NULL;
|
|
}
|
|
|
|
// create the guts of the red rain missile
|
|
void create_redarrow(edict_t *redarrow)
|
|
{
|
|
redarrow->s.effects |= EF_ALWAYS_ADD_EFFECTS;
|
|
redarrow->svflags |= SVF_ALWAYS_SEND;
|
|
redarrow->movetype = MOVETYPE_FLYMISSILE;
|
|
|
|
VectorSet(redarrow->mins, -ARROW_RADIUS, -ARROW_RADIUS, -ARROW_RADIUS);
|
|
VectorSet(redarrow->maxs, ARROW_RADIUS, ARROW_RADIUS, ARROW_RADIUS);
|
|
|
|
redarrow->solid = SOLID_BBOX;
|
|
redarrow->clipmask = MASK_SHOT;
|
|
redarrow->touch = RedRainMissileTouch;
|
|
redarrow->think = RedRainMissileThink;
|
|
redarrow->classname = "Spell_RedRainArrow";
|
|
redarrow->nextthink = level.time + 0.1;
|
|
if (redarrow->health==1)
|
|
{ // powerup arrow
|
|
redarrow->dmg = irand(POWER_RAIN_DMG_ARROW_MIN, POWER_RAIN_DMG_ARROW_MAX);
|
|
}
|
|
else
|
|
{
|
|
redarrow->dmg = irand(RED_RAIN_DMG_ARROW_MIN, RED_RAIN_DMG_ARROW_MAX);
|
|
}
|
|
}
|
|
|
|
// ****************************************************************************
|
|
// SpellCastRedRain
|
|
// ****************************************************************************
|
|
|
|
void SpellCastRedRain(edict_t *Caster, vec3_t StartPos, vec3_t AimAngles, vec3_t unused, float value)
|
|
{
|
|
edict_t *redarrow;
|
|
trace_t trace;
|
|
vec3_t dir, forward, endpos;
|
|
qboolean powerup;
|
|
|
|
redarrow = G_Spawn();
|
|
|
|
Caster->red_rain_count++;
|
|
// health indicates a level of powerup
|
|
if (Caster->client->playerinfo.powerup_timer > level.time)
|
|
{ // Shoot powered up red rain.
|
|
redarrow->health = 1;
|
|
powerup=true;
|
|
}
|
|
else
|
|
{ // Normal red rain arrow
|
|
redarrow->health = 0;
|
|
powerup=false;
|
|
}
|
|
|
|
VectorCopy(StartPos, redarrow->s.origin);
|
|
//Check ahead first to see if it's going to hit anything at this angle
|
|
AngleVectors(AimAngles, forward, NULL, NULL);
|
|
VectorMA(StartPos, RED_ARROW_SPEED, forward, endpos);
|
|
gi.trace(StartPos, vec3_origin, vec3_origin, endpos, Caster, MASK_MONSTERSOLID,&trace);
|
|
if(trace.ent && ok_to_autotarget(Caster, trace.ent))
|
|
{//already going to hit a valid target at this angle- so don't autotarget
|
|
VectorScale(forward, RED_ARROW_SPEED, redarrow->velocity);
|
|
}
|
|
else
|
|
{//autotarget current enemy
|
|
GetAimVelocity(Caster->enemy, redarrow->s.origin, RED_ARROW_SPEED, AimAngles, redarrow->velocity);
|
|
}
|
|
VectorNormalize2(redarrow->velocity, dir);
|
|
// naughty naughty - this requires a normalised vector
|
|
AnglesFromDir(dir, redarrow->s.angles);
|
|
|
|
create_redarrow(redarrow);
|
|
redarrow->reflect_debounce_time = MAX_REFLECT;
|
|
|
|
redarrow->owner = Caster;
|
|
G_LinkMissile(redarrow);
|
|
|
|
gi.RemoveEffects(&Caster->s, FX_WEAPON_REDRAINGLOW);
|
|
|
|
if (powerup)
|
|
{ // Play powerup firing sound
|
|
gi.sound(Caster, CHAN_WEAPON, gi.soundindex("weapons/RedRainPowerFire.wav"), 1, ATTN_NORM, 0);
|
|
}
|
|
else
|
|
{ // Player normal red rain firing sound
|
|
gi.sound(Caster, CHAN_WEAPON, gi.soundindex("weapons/RedRainFire.wav"), 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
// Trace from the player's origin because then if we hit a wall, the effect won't be inside it...
|
|
gi.trace(Caster->s.origin, redarrow->mins, redarrow->maxs, redarrow->s.origin, Caster, MASK_PLAYERSOLID,&trace);
|
|
if (trace.startsolid || trace.fraction < .99)
|
|
{
|
|
if (trace.startsolid)
|
|
VectorCopy(Caster->s.origin, redarrow->s.origin);
|
|
else
|
|
VectorCopy(trace.endpos, redarrow->s.origin);
|
|
RedRainMissileTouch(redarrow, trace.ent, &trace.plane, trace.surface);
|
|
return;
|
|
}
|
|
|
|
// Create the missile and trail effect only if we successfully launch the missile
|
|
if (powerup)
|
|
{ // Magenta trail
|
|
gi.CreateEffect(&redarrow->s, FX_WEAPON_REDRAINMISSILE, CEF_OWNERS_ORIGIN|CEF_FLAG6,
|
|
NULL, "t", redarrow->velocity);
|
|
}
|
|
else
|
|
{ // Red trail
|
|
gi.CreateEffect(&redarrow->s, FX_WEAPON_REDRAINMISSILE, CEF_OWNERS_ORIGIN,
|
|
NULL, "t", redarrow->velocity);
|
|
}
|
|
}
|
|
|
|
// end
|