ritual/sin-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases 3 Packages Wiki Activity
sin-sdk/quantumd.cpp
archive 09e039d47e as released 1998-12-20
1998-12-20 00:00:00 +00:00

1077 lines
25 KiB
C++
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Logfile:: /Quake 2 Engine/Sin/code/game/quantumd.cpp $
// $Revision:: 46 $
// $Author:: Aldie $
// $Date:: 11/18/98 8:28p $
//
// Copyright (C) 1998 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source is may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
// $Log:: /Quake 2 Engine/Sin/code/game/quantumd.cpp $
//
// 46 11/18/98 8:28p Aldie
// Added NOION check for quantum overload
//
// 45 11/15/98 12:22a Markd
// Fixed pre-caching issues
//
// 44 11/09/98 3:46a Aldie
// Fixed health death problems
//
// 43 10/26/98 2:50p Aldie
// Fixed a bug with checking of NULL owners
//
// 42 10/24/98 12:42a Markd
// changed origins to worldorigins where appropriate
//
// 41 10/22/98 7:57p Markd
// put in proper pre-caching in all the classes
//
// 40 10/22/98 5:52p Aldie
// Went back to single mode firing
//
// 39 10/21/98 2:28a Aldie
// Fixed bug with destruct function
//
// 38 10/20/98 8:26p Markd
// Added Attacker to DamageSurface stuff
//
// 37 10/19/98 12:07a Jimdose
// made all code use fast checks for inheritance (no text lookups when
// possible)
// isSubclassOf no longer requires ::_classinfo()
//
// 36 10/18/98 7:58p Aldie
// Changed quantum to do a full trace
//
// 35 10/16/98 10:22p Aldie
// Updated single player damage settings
//
// 34 10/16/98 9:50p Aldie
// Added SecondaryAmmo command and flame effect
//
// 33 10/14/98 12:12a Aldie
// Took out seeking
//
// 32 10/13/98 7:33p Aldie
// Fixed event problem
//
// 31 10/13/98 7:14p Aldie
// Added seeking
//
// 30 10/11/98 5:33p Aldie
// Tweak damage
//
// 29 10/11/98 12:03a Aldie
// Change velocity
//
// 28 10/10/98 9:59p Aldie
// Added radius damage
//
// 27 10/10/98 5:58p Aldie
// More quantumdestab fixes
//
// 26 10/06/98 9:17p Aldie
// Make sure you kill all with quantum
//
// 25 10/06/98 2:51p Aldie
// Fix killing of the player for quantum
//
// 24 10/05/98 10:42p Aldie
// Fixed dropping of quantum bug
//
// 23 10/04/98 10:38p Markd
// Commented out player trapped in quantum code for the time being
//
// 22 10/04/98 10:28p Aldie
// Added multiple weapon changes. Damage, flashes, quantum stuff
//
// 21 10/01/98 8:01p Aldie
// Tweaked power
//
// 20 10/01/98 4:01p Markd
// Added Archive and Unarchive functions
//
// 19 9/30/98 1:26p Aldie
// Fixed damage function when quantum self destructs
//
// 18 9/29/98 11:46p Aldie
// Added unfreeze and killsight effects
//
// 17 9/25/98 2:59p Aldie
// Change rate of ammo
//
// 16 9/23/98 10:08p Aldie
// Added self destruct mechanism
//
// 15 9/22/98 8:10p Aldie
// Freeze stuff
//
// 14 9/21/98 5:31p Markd
// took out owner out of projectile subclasses, working on archive and
// unarchive
//
// 13 9/21/98 1:34a Aldie
// Made the quantum eat ammo
//
// 12 9/20/98 5:12p Aldie
// New effects for quantum
//
// 11 9/17/98 4:37p Aldie
// Temporary checkin
//
// 10 9/16/98 8:58p Aldie
// Added ability to do a hold down weapon charge
//
// 9 9/16/98 4:03p Aldie
// Intermediate checkin
//
// 8 9/11/98 3:54p Aldie
// Put in releasefire
//
// 7 8/18/98 5:51p Aldie
// Added support for dual mode weapons.
//
// 6 8/18/98 2:32p Aldie
// Fixed some bugs with animation control
//
// 5 8/06/98 10:53p Aldie
// Added weapon tweaks and kickback. Also modified blast radius damage and
// rocket jumping.
//
// 4 8/03/98 1:16p Aldie
// Changed ammo type
//
// 3 7/29/98 5:56p Aldie
// Changed classname
//
// 2 7/29/98 3:38p Aldie
// First version of QD
//
// 1 7/29/98 3:15p Aldie
//
// DESCRIPTION:
// Quantum Destabilizer
#include "quantumd.h"
#include "specialfx.h"
#include "explosion.h"
#include "player.h"
#include "surface.h"
#define ION_MODE 1
#define DESTAB_MODE 2
class EXPORT_FROM_DLL IonBurst : public Projectile
{
private:
float power;
public:
CLASS_PROTOTYPE( IonBurst );
IonBurst();
virtual void Setup( Entity *owner, Vector pos, float power );
virtual void Explode( Event *ev );
virtual void Archive( Archiver &arc );
virtual void Unarchive( Archiver &arc );
};
EXPORT_FROM_DLL void IonBurst::Archive
(
Archiver &arc
)
{
Projectile::Archive( arc );
arc.WriteFloat( power );
}
EXPORT_FROM_DLL void IonBurst::Unarchive
(
Archiver &arc
)
{
Projectile::Unarchive( arc );
arc.ReadFloat( &power );
}
class EXPORT_FROM_DLL Ion : public Projectile
{
private:
float power;
public:
CLASS_PROTOTYPE( Ion );
Ion();
virtual void Setup( Entity *owner, Vector pos, Vector dir, float power );
virtual void Explode( Event *ev );
qboolean CanSee( Entity *ent );
virtual void Seek( Event *ev );
float AdjustAngle( float maxadjust, float currangle, float targetangle );
virtual void Archive( Archiver &arc );
virtual void Unarchive( Archiver &arc );
};
EXPORT_FROM_DLL void Ion::Archive
(
Archiver &arc
)
{
Projectile::Archive( arc );
arc.WriteFloat( power );
}
EXPORT_FROM_DLL void Ion::Unarchive
(
Archiver &arc
)
{
Projectile::Unarchive( arc );
arc.ReadFloat( &power );
}
CLASS_DECLARATION( Projectile, IonBurst, NULL );
ResponseDef IonBurst::Responses[] =
{
{ &EV_Touch, ( Response )IonBurst::Explode },
{ NULL, NULL }
};
IonBurst::IonBurst
(
)
{
}
void IonBurst::Explode
(
Event *ev
)
{
Entity *other;
Entity *owner;
float damg;
other = ev->GetEntity( 1 );
assert( other );
// Do damage to what we hit
if ( other->isSubclassOf( Teleporter ) )
{
return;
}
if ( other->entnum == this->owner )
{
return;
}
// Hit the sky, so remove everything
if ( HitSky() )
{
PostEvent( EV_Remove, 0 );
return;
}
owner = G_GetEntity( this->owner );
if ( !owner )
owner = world;
damg = 20 + power * 20;
if ( other->takedamage )
{
other->Damage( this, owner, damg, worldorigin, velocity, level.impact_trace.plane.normal, 32, 0, MOD_ION, -1, -1, 1.0f );
PostEvent( EV_Remove, 0 );
}
}
void IonBurst::Setup
(
Entity *owner,
Vector pos,
float power
)
{
Event *event;
this->owner = owner->entnum;
edict->owner = owner->edict;
setMoveType( MOVETYPE_BOUNCE );
setSolidType( SOLID_BBOX );
edict->clipmask = MASK_PROJECTILE;
SetGravityAxis( owner->gravaxis );
showModel();
setModel( "qp_burst.def" );
RandomAnimate( "flyburst", NULL );
this->power = power;
// Set the flying velocity
velocity[0] = 300.0 * crandom() + 200 * power;
velocity[1] = 300.0 * crandom() + 200 * power;
velocity[2] = 300.0 + 300.0 * random() + 200 * power;
takedamage = DAMAGE_NO;
// Set the light and effects
edict->s.renderfx |= RF_DLIGHT;
edict->s.effects |= EF_EVERYFRAME;
edict->s.radius = 200;
edict->s.color_r = 1.0f;
edict->s.color_g = 0.2;
edict->s.color_b = 0.1;
setScale( 0.3 );
// Set size and origin
setSize( "-2 -2 -2", "2 2 2" );
setOrigin( pos );
worldorigin.copyTo(edict->s.old_origin);
event = new Event( EV_Remove );
PostEvent( event, 1.2 );
}
CLASS_DECLARATION( Projectile, Ion, NULL );
Event EV_Ion_Seek( "ionseek" );
ResponseDef Ion::Responses[] =
{
{ &EV_Touch, ( Response )Ion::Explode },
{ &EV_Ion_Seek, ( Response )Ion::Seek },
{ NULL, NULL }
};
Ion::Ion()
{
}
qboolean Ion::CanSee
(
Entity *ent
)
{
Vector delta;
Vector start;
Vector end;
trace_t trace;
start = worldorigin;
end = ent->centroid;
// Check if he's visible
trace = G_Trace( start, vec_zero, vec_zero, end, this, MASK_OPAQUE, "Ion::CanSee" );
if ( trace.fraction == 1.0 || trace.ent == ent->edict )
{
return true;
}
return false;
}
float Ion::AdjustAngle
(
float maxadjust,
float currangle,
float targetangle
)
{
float dangle;
float magangle;
dangle = currangle - targetangle;
if ( dangle )
{
magangle = ( float )fabs( dangle );
if ( magangle < maxadjust )
{
currangle = targetangle;
}
else
{
if ( magangle > 180.0f )
{
maxadjust = -maxadjust;
}
if ( dangle > 0 )
{
maxadjust = -maxadjust;
}
currangle += maxadjust;
}
}
while( currangle >= 360.0f )
{
currangle -= 360.0f;
}
while( currangle < 0.0f )
{
currangle += 360.0f;
}
return currangle;
}
void Ion::Seek
(
Event *ev
)
{
Entity *ent;
Vector delta;
float dist;
Entity *bestent = NULL;
float bestdist = 999999;
Vector newangles, newdir;
ent = findradius( NULL, worldorigin.vec3(), 256 );
while( ent )
{
if ( ( ent->entnum != owner ) && ( ent->takedamage ) && ent->isSubclassOf( Sentient ) )
{
delta = worldorigin - ent->centroid;
dist = delta.length();
if ( ( dist < bestdist ) && CanSee( ent ) )
{
bestent = ent;
bestdist = dist;
}
}
ent = findradius( ent, worldorigin.vec3(), 1000 );
}
if (!bestent)
{
PostEvent( ev, FRAMETIME );
return;
}
newdir = bestent->centroid - worldorigin;
newdir.normalize();
velocity = newdir * 250;
angles = newdir.toAngles();
angles[ PITCH ] = -angles[ PITCH ];
setAngles( angles );
PostEvent( ev, FRAMETIME );
}
void Ion::Explode
(
Event *ev
)
{
Entity *other;
Entity *owner;
int damg;
Vector v;
other = ev->GetEntity( 1 );
assert( other );
if ( other->isSubclassOf( Teleporter ) )
{
return;
}
if ( other->entnum == this->owner )
{
return;
}
owner = G_GetEntity( this->owner );
if ( !owner )
owner = world;
setSolidType( SOLID_NOT );
// Hit the sky, so remove everything
if ( HitSky() )
{
PostEvent( EV_Remove, 0 );
return;
}
damg = 50 + ( power * 200 );
// Single player packs a bigger punch
if ( !deathmatch->value && owner->isClient() )
damg *= 1.5;
if ( other->takedamage )
{
other->Damage( this, owner, damg, worldorigin, velocity, level.impact_trace.plane.normal, 0, 0, MOD_ION, -1, -1, 1.0f );
if ( other->isSubclassOf( Sentient ) )
{
Sentient *sent = (Sentient * )other;
sent->ProcessEvent( EV_Sentient_Freeze );
sent->PostEvent( EV_Sentient_UnFreeze, 1 );
}
}
v = velocity;
v.normalize();
v = worldorigin - v * 36;
RadiusDamage( this, owner, damg, this, MOD_ION );
edict->s.effects &= ~EF_EVERYFRAME;
// Process the explode animation, then remove this thing
RandomAnimate( "explode", EV_Remove );
#if 0
// Fire off some gib bursts
for ( i=0; i<3; i++ )
{
IonBurst *burst;
burst = new IonBurst;
burst->Setup( owner, v, power );
}
#endif
FlashPlayers(v, 1, 1, 1, 0.5, 500 );
}
void Ion::Setup
(
Entity *owner,
Vector pos,
Vector dir,
float power
)
{
Event *event;
this->owner = owner->entnum;
edict->owner = owner->edict;
this->power = power;
// Align the projectile
angles = dir.toAngles();
angles[ PITCH ] = -angles[ PITCH ];
setAngles( angles );
edict->s.angles[ROLL] = rand() % 360;
// Flies like a rocket
setMoveType( MOVETYPE_FLYMISSILE );
setSolidType( SOLID_BBOX );
edict->clipmask = MASK_PROJECTILE;
setModel( "qp_burst.def" );
RandomAnimate( "idle", NULL );
//PostEvent( EV_Ion_Seek, 0.1f );
// Set the flying velocity
velocity = dir * 1000;
gravity = 0;
avelocity = Vector( "0 0 2000" );
takedamage = DAMAGE_NO;
// Set the light and effects
edict->s.renderfx |= RF_DLIGHT;
edict->s.effects |= EF_EVERYFRAME;
edict->s.radius = 200;
edict->s.color_r = 1.0f;
edict->s.color_g = 0;
edict->s.color_b = 0;
// Adjust scale by power
edict->s.scale *= power;
edict->s.scale += 0.2f;
// Set size and origin
setSize( "-1 -1 -1", "1 1 1" );
setOrigin( pos );
worldorigin.copyTo(edict->s.old_origin);
event = new Event( EV_Remove );
PostEvent( event, 20 );
}
CLASS_DECLARATION( BulletWeapon, QuantumDestabilizer, "weapon_quantumdestabilizer" );
Event EV_Quantum_EatAmmo( "eatammo" );
Event EV_Quantum_Destruct( "destruct" );
Event EV_Quantum_StartSelfDestruct( "destruct_time" );
Event EV_Quantum_SentientOverload( "sentient_overload" );
ResponseDef QuantumDestabilizer::Responses[] =
{
{ &EV_Weapon_Shoot, ( Response )QuantumDestabilizer::Shoot },
{ &EV_Quantum_EatAmmo, ( Response )QuantumDestabilizer::EatAmmo },
{ &EV_Quantum_Destruct, ( Response )QuantumDestabilizer::Destruct },
{ &EV_Quantum_StartSelfDestruct, ( Response )QuantumDestabilizer::StartSelfDestruct },
{ &EV_Quantum_SentientOverload, ( Response )QuantumDestabilizer::SentientOverload },
{ NULL, NULL }
};
QuantumDestabilizer::QuantumDestabilizer
(
)
{
#ifdef SIN_DEMO
PostEvent( EV_Remove, 0 );
return;
#endif
SetModels( "quantum.def", "view_quantum.def" );
modelIndex( "qp_burst.def" );
modelIndex( "sprites/qp_exhaust.spr" );
modelIndex( "sprites/qp_sphere.spr" );
modelIndex( "sprites/shockwave2.spr" );
modelIndex( "sphere3.def" );
gi.soundindex( "weapons/quantum/burst.wav" );
SetAmmo( "BulletPulse", 20, 100 );
//SetSecondaryAmmo( "BulletPulse", 5, 100);
SetRank( 90, 90 );
SetType( WEAPON_2HANDED_LO );
trapped_sent = NULL;
//dualmode = true;
}
void QuantumDestabilizer::EatAmmo
(
Event *ev
)
{
Event *event;
Ammo * ammo;
assert( owner );
if ( owner && owner->isClient() && !( owner->flags & FL_GODMODE ) )
{
if ( ammotype.length() )
{
ammo = ( Ammo * )owner->FindItem( ammotype.c_str() );
// Eat 1 ammo per charge up
if ( !ammo || !ammo->Use( 1 ) )
{
// Ran out of ammo, fire this sucker
event = new Event( EV_Sentient_ReleaseAttack );
event->AddFloat( level.time - owner->firedowntime );
owner->ProcessEvent( event );
owner->firedown = false;
}
else
{
PostEvent( EV_Quantum_EatAmmo, 0.1 );
}
}
}
}
void QuantumDestabilizer::Destruct
(
Event *ev
)
{
Entity *ent;
CancelEventsOfType( EV_Quantum_EatAmmo );
CreateExplosion( owner->centroid, 200, 1.0f, true, this, owner, owner );
ent = findradius( NULL, owner->centroid, 512 );
while( ent )
{
if ( ( ent != owner ) && ( !ent->deadflag ) && ( ent->takedamage ) && !(ent->flags & FL_NOION ) )
{
ent->Damage( this, owner, 10000+ent->health, ent->worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR|DAMAGE_NO_SKILL, MOD_ION, -1, -1, 1.0f );
}
ent = findradius( ent, owner->centroid, 512 );
}
// Make owner deceased
owner->Damage( this, owner, 10000+owner->health, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR|DAMAGE_NO_SKILL, MOD_ION_DESTRUCT, -1, -1, 1.0f );
}
void QuantumDestabilizer::SentientOverload
(
Event *ev
)
{
#if 0
if ( trapped_sent )
{
if ( trapped_sent->isClient() )
{
Player *player = (Player * )(Sentient *)trapped_sent;
// Clear this so we don't get thrown out of the gun when it gets dropped
trapped_sent = NULL;
player->trappedInQuantum = false;
player->edict->svflags &= ~SVF_HIDEOWNER;
player->edict->owner = NULL;
player->origin = owner->origin;
player->ProcessEvent( EV_Sentient_UnFreeze );
player->showModel();
player->setSolidType( SOLID_BBOX );
player->unlink();
SpawnTeleportEffect(player->worldorigin, 123);
KillBox( player );
player->setOrigin( player->origin );
player->worldorigin.copyTo(player->edict->s.old_origin);
player->SetCamera( NULL );
}
else
{
// Kill the owner
owner->health = 0;
owner->Damage( this, owner, 1000, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR|DAMAGE_NO_SKILL, MOD_ION_DESTRUCT, -1, -1, 1.0f );
}
}
#endif
}
void QuantumDestabilizer::StartSelfDestruct
(
Event *ev
)
{
float time = ev->GetFloat( 1 );
PostEvent( EV_Quantum_Destruct, time );
}
void QuantumDestabilizer::ReleaseFire
(
float holdfiretime
)
{
if ( weaponmode == PRIMARY )
{
CancelEventsOfType( EV_Quantum_EatAmmo );
CancelEventsOfType( EV_Quantum_Destruct );
if ( holdfiretime > 5 )
holdfiretime = 5;
if ( holdfiretime < 0 )
holdfiretime = 0;
power = holdfiretime / 5.0f;
RandomAnimate( "releasefire", EV_Weapon_DoneFiring );
last_attack_time = level.time;
}
}
qboolean QuantumDestabilizer::ShootSentient
(
Vector pos,
Vector dir
)
{
return false;
#if 0
Vector end;
trace_t trace;
if ( trapped_sent )
{
// Check to see if there is empty space in front of the gun
end = pos + dir * 50;
trace = G_Trace( pos, trapped_sent->mins, trapped_sent->maxs, end, this, MASK_SOLID, "QuantumDestabilizer::ShootSentient" );
if ( trace.fraction != 1.0 )
return false;
trapped_sent->origin = pos + dir *25;
trapped_sent->origin -= (trapped_sent->maxs - trapped_sent->mins) * 0.5f;
trapped_sent->velocity = pos + dir * 750;
trapped_sent->setOrigin( trapped_sent->origin );
trapped_sent->worldorigin.copyTo(trapped_sent->edict->s.old_origin);
trapped_sent->ProcessEvent( EV_Sentient_UnFreeze );
trapped_sent->showModel();
trapped_sent->setSolidType( SOLID_BBOX );
trapped_sent->setMoveType( MOVETYPE_HURL );
if ( trapped_sent->isClient() )
{
Player *player = (Player *)(Sentient *)trapped_sent;
player->edict->svflags &= ~SVF_HIDEOWNER;
player->edict->owner = NULL;
player->trappedInQuantum = false;
}
trapped_sent = NULL;
CancelEventsOfType( EV_Quantum_SentientOverload );
return( true );
}
else
{
gi.dprintf("No sentient in quantum destabilizer" );
return( false );
}
#endif
}
void QuantumDestabilizer::SuckSentient
(
Vector pos,
Vector dir
)
{
#if 0
Vector end;
trace_t trace;
end = pos + dir * 8192;
trace = G_FullTrace( pos, vec_zero, vec_zero, end, 5, owner, MASK_SHOT, "QuantumDestabilizer::SuckSentient" );
// Check to see if we hit a sentient
if ( trace.ent )
{
if ( trace.ent->entity->isSubclassOf( Sentient ) )
{
// Freeze them, hide the model, set notsolid
Sentient *sent = ( Sentient * )trace.ent->entity;
sent->ProcessEvent( EV_Sentient_Freeze );
sent->hideModel();
sent->setSolidType( SOLID_NOT );
// Do the implosion tess effect
TesselateModel( sent,
1,
1000,
dir,
100,
1.0f,
0,
vec3_origin,
TESSELATE_IMPLODE,
126
);
// If they are a client, set some flags so they don't see the owner
// of this weapon.
if ( sent->isClient() )
{
Player *player;
player = ( Player * )sent;
player->trappedInQuantum = true;
player->SetCamera( owner );
player->edict->svflags |= SVF_HIDEOWNER;
player->edict->owner = owner->edict;
}
trapped_sent = sent;
// We have a sentient trapped, set a destruct timer for 5 seconds
PostEvent( EV_Quantum_SentientOverload, 5 );
}
}
#endif
}
// This is the trace that the laser portion of this weapon does.
void QuantumDestabilizer::TraceAttack
(
Vector start,
Vector end,
int damage,
trace_t *trace,
int numricochets,
int kick,
int dflags
)
{
Vector org;
Vector dir;
int surfflags;
int surftype;
Entity *ent;
if ( HitSky( trace ) )
{
return;
}
dir = end - start;
dir.normalize();
org = end - dir * 4;
if ( !trace->surface )
{
surfflags = 0;
surftype = 0;
}
else
{
surfflags = trace->surface->flags;
surftype = SURFACETYPE_FROM_FLAGS( surfflags );
surfaceManager.DamageSurface( trace, damage, owner );
}
ent = trace->ent->entity;
if ( ent && ent->takedamage )
{
if ( trace->intersect.valid )
{
// We hit a valid group so send in location based damage
ent->Damage( this,
owner,
damage,
trace->endpos,
dir,
trace->plane.normal,
kick,
dflags,
MOD_QUANTUM,
trace->intersect.parentgroup,
-1,
trace->intersect.damage_multiplier );
}
else
{
// We didn't hit any groups, so send in generic damage
ent->Damage( this,
owner,
damage,
trace->endpos,
dir,
trace->plane.normal,
kick,
dflags,
MOD_QUANTUM,
-1,
-1,
1 );
}
}
}
void QuantumDestabilizer::Shoot
(
Event *ev
)
{
Vector pos,dir;
Vector end,delta;
Ion *ion = new Ion;
assert( owner );
if ( !owner )
{
return;
}
GetMuzzlePosition( &pos, &dir );
ion->Setup( owner, pos, dir, power );
NextAttack( 1 );
#if 0
if ( weaponmode == PRIMARY )
{
Ion *ion = new Ion;
ion->Setup( owner, pos, dir, power );
NextAttack( 1 );
}
else
{
length = ev->GetInteger( 1 );
end = pos + dir * length;
trace = G_FullTrace( pos, vec_zero, vec_zero, end, 30, this, MASK_PROJECTILE, "QuantumDestabilizer::Shoot" );
delta = trace.endpos - pos;
// Set the pitch of this weapon so the client can use it to flame in the right direction
dir = Vector( owner->orientation[ 0 ] );
angles = dir.toAngles();
setAngles( angles );
damg = 25;
TraceAttack( pos, trace.endpos, damg, &trace, 0, 0, 0 );
NextAttack( 0 );
}
#endif
#if 0
// DESTABILIZE MODE
{
if ( trapped_sent )
{
ShootSentient(pos, dir);
ammorequired = 0;
}
else
{
SuckSentient(pos,dir);
ammorequired = 20;
}
}
NextAttack( 0.5 );
#endif
}
qboolean QuantumDestabilizer::Drop
(
void
)
{
#if 0
ammorequired = 20;
if ( trapped_sent )
{
if ( !ShootSentient( worldorigin, Vector( 0,0,1 ) ) )
{
// Can't shoot the sentient out, so kill it
trapped_sent->health = 0;
trapped_sent->Damage( this, owner, 1000, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR|DAMAGE_NO_SKILL, MOD_ION_DESTRUCT, -1, -1, 1.0f );
}
}
#endif
CancelEventsOfType( EV_Quantum_EatAmmo );
CancelEventsOfType( EV_Quantum_Destruct );
return( Weapon::Drop() );
}
Reference in a new issue View git blame Copy permalink