ioquake
/
jedi-academy
mirror of https://github.com/ioquake/jedi-academy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
jedi-academy/code/game/g_turret.cpp

2516 lines
68 KiB
C++
Raw Blame History

// leave this line at the top for all g_xxxx.cpp files...
#include "g_headers.h"
#include "g_local.h"
#include "g_functions.h"
#include "b_local.h"
extern cvar_t *g_spskill;
void G_SetEnemy( gentity_t *self, gentity_t *enemy );
void finish_spawning_turret( gentity_t *base );
void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
//special routine for tracking angles between client and server -rww
void turret_SetBoneAngles(gentity_t *ent, char *bone, const vec3_t angles);
#define ARM_ANGLE_RANGE 60
#define HEAD_ANGLE_RANGE 90
#define SPF_TURRETG2_TURBO 4
#define SPF_TURRETG2_LEAD_ENEMY 8
#define name "models/map_objects/imp_mine/turret_canon.glm"
#define name2 "models/map_objects/imp_mine/turret_damage.md3"
#define name3 "models/map_objects/wedge/laser_cannon_model.glm"
//------------------------------------------------------------------------------------------------------------
void TurretPain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc )
//------------------------------------------------------------------------------------------------------------
{
vec3_t dir;
VectorSubtract( point, self->currentOrigin, dir );
VectorNormalize( dir );
if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
{
// DEMP2 makes the turret stop shooting for a bit..and does extra feedback
self->attackDebounceTime = level.time + 800 + random() * 500;
G_PlayEffect( "sparks/spark_exp_nosnd", point, dir );
}
if ( !self->enemy )
{//react to being hit
G_SetEnemy( self, attacker );
}
G_PlayEffect( "sparks/spark_exp_nosnd", point, dir );
}
//------------------------------------------------------------------------------------------------------------
void turret_die ( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc )
//------------------------------------------------------------------------------------------------------------
{
vec3_t forward = { 0,0,-1 }, pos;
// Turn off the thinking of the base & use it's targets
self->e_ThinkFunc = thinkF_NULL;
self->e_UseFunc = useF_NULL;
// clear my data
self->e_DieFunc = dieF_NULL;
self->takedamage = qfalse;
self->health = 0;
self->s.loopSound = 0;
// hack the effect angle so that explode death can orient the effect properly
if ( self->spawnflags & 2 )
{
VectorSet( forward, 0, 0, 1 );
}
// VectorCopy( self->currentOrigin, self->s.pos.trBase );
if ( self->spawnflags & SPF_TURRETG2_TURBO )
{
G_PlayEffect( G_EffectIndex( "explosions/fighter_explosion2" ), self->currentOrigin, self->currentAngles );
}
else
{
if ( self->fxID > 0 )
{
VectorMA( self->currentOrigin, 12, forward, pos );
G_PlayEffect( self->fxID, pos, forward );
}
}
if ( self->splashDamage > 0 && self->splashRadius > 0 )
{
G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius, attacker, MOD_UNKNOWN );
}
if ( self->s.eFlags & EF_SHADER_ANIM )
{
self->s.frame = 1; // black
}
self->s.weapon = 0; // crosshair code uses this to mark crosshair red
if ( self->s.modelindex2 )
{
// switch to damage model if we should
self->s.modelindex = self->s.modelindex2;
VectorCopy( self->currentAngles, self->s.apos.trBase );
VectorClear( self->s.apos.trDelta );
if ( self->target )
{
G_UseTargets( self, attacker );
}
}
else
{
ObjectDie( self, inflictor, attacker, damage, meansOfDeath );
}
}
//start an animation on model_root both server side and client side
void TurboLaser_SetBoneAnim(gentity_t *eweb, int startFrame, int endFrame)
{
//set info on the entity so it knows to start the anim on the client next snapshot.
//eweb->s.eFlags |= EF_G2ANIMATING;
if (eweb->s.torsoAnim == startFrame && eweb->s.legsAnim == endFrame)
{ //already playing this anim, let's flag it to restart
//eweb->s.torsoFlip = !eweb->s.torsoFlip;
}
else
{
eweb->s.torsoAnim = startFrame;
eweb->s.legsAnim = endFrame;
}
//now set the animation on the server ghoul2 instance.
assert(&eweb->ghoul2[0]);
gi.G2API_SetBoneAnim(&eweb->ghoul2[0], "model_root", startFrame, endFrame,
(BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, level.time, -1, 100);
}
#define START_DIS 15
extern void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir );
//----------------------------------------------------------------
static void turret_fire ( gentity_t *ent, vec3_t start, vec3_t dir )
//----------------------------------------------------------------
{
vec3_t org, ang;
gentity_t *bolt;
if ( (gi.pointcontents( start, ent->s.number )&MASK_SHOT) )
{
return;
}
VectorMA( start, -START_DIS, dir, org ); // dumb....
if ( ent->random )
{
vectoangles( dir, ang );
ang[PITCH] += Q_flrand( -ent->random, ent->random );
ang[YAW] += Q_flrand( -ent->random, ent->random );
AngleVectors( ang, dir, NULL, NULL );
}
vectoangles(dir, ang);
if ( (ent->spawnflags&SPF_TURRETG2_TURBO) )
{
//muzzle flash
G_PlayEffect( G_EffectIndex( "turret/turb_muzzle_flash" ), org, ang );
G_SoundOnEnt( ent, CHAN_LESS_ATTEN, "sound/vehicles/weapons/turbolaser/fire1" );
WP_FireTurboLaserMissile( ent, start, dir );
if ( ent->alt_fire )
{
TurboLaser_SetBoneAnim( ent, 2, 3 );
}
else
{
TurboLaser_SetBoneAnim( ent, 0, 1 );
}
}
else
{
G_PlayEffect( "blaster/muzzle_flash", org, dir );
bolt = G_Spawn();
bolt->classname = "turret_proj";
bolt->nextthink = level.time + 10000;
bolt->e_ThinkFunc = thinkF_G_FreeEntity;
bolt->s.eType = ET_MISSILE;
bolt->s.weapon = WP_BLASTER;
bolt->owner = ent;
bolt->damage = ent->damage;
bolt->dflags = DAMAGE_NO_KNOCKBACK | DAMAGE_HEAVY_WEAP_CLASS; // Don't push them around, or else we are constantly re-aiming
bolt->splashDamage = 0;
bolt->splashRadius = 0;
bolt->methodOfDeath = MOD_ENERGY;
bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
bolt->trigger_formation = qfalse; // don't draw tail on first frame
VectorSet( bolt->maxs, 1.5, 1.5, 1.5 );
VectorScale( bolt->maxs, -1, bolt->mins );
bolt->s.pos.trType = TR_LINEAR;
bolt->s.pos.trTime = level.time;
VectorCopy( start, bolt->s.pos.trBase );
VectorScale( dir, 1100, bolt->s.pos.trDelta );
SnapVector( bolt->s.pos.trDelta ); // save net bandwidth
VectorCopy( start, bolt->currentOrigin);
}
}
//-----------------------------------------------------
void turret_head_think( gentity_t *self )
//-----------------------------------------------------
{
// if it's time to fire and we have an enemy, then gun 'em down! pushDebounce time controls next fire time
if ( self->enemy && self->pushDebounceTime < level.time && self->attackDebounceTime < level.time )
{
// set up our next fire time
self->pushDebounceTime = level.time + self->wait;
vec3_t fwd, org;
mdxaBone_t boltMatrix;
// Getting the flash bolt here
gi.G2API_GetBoltMatrix( self->ghoul2,
0,
(self->spawnflags&SPF_TURRETG2_TURBO) ? ( (self->alt_fire ? gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle2" ) : gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle1" )) ) : gi.G2API_AddBolt( &self->ghoul2[0], "*flash03" ),
&boltMatrix,
self->currentAngles,
self->currentOrigin,
level.time,
NULL,
self->modelScale );
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{
self->alt_fire = !self->alt_fire;
}
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, fwd );
}
else
{
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
}
VectorMA( org, START_DIS, fwd, org );
turret_fire( self, org, fwd );
self->fly_sound_debounce_time = level.time;//used as lastShotTime
}
}
//-----------------------------------------------------
static void turret_aim( gentity_t *self )
//-----------------------------------------------------
{
vec3_t enemyDir, org, org2;
vec3_t desiredAngles, setAngle;
float diffYaw = 0.0f, diffPitch = 0.0f;
float maxYawSpeed = ( self->spawnflags & SPF_TURRETG2_TURBO ) ? 30.0f : 14.0f;
float maxPitchSpeed = ( self->spawnflags & SPF_TURRETG2_TURBO ) ? 15.0f : 3.0f;
// move our gun base yaw to where we should be at this time....
EvaluateTrajectory( &self->s.apos, level.time, self->currentAngles );
self->currentAngles[YAW] = AngleNormalize360( self->currentAngles[YAW] );
self->speed = AngleNormalize360( self->speed );
if ( self->enemy )
{
// ...then we'll calculate what new aim adjustments we should attempt to make this frame
// Aim at enemy
if ( self->enemy->client )
{
VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
}
else
{
VectorCopy( self->enemy->currentOrigin, org );
}
if ( self->spawnflags & 2 )
{
org[2] -= 15;
}
else
{
org[2] -= 5;
}
mdxaBone_t boltMatrix;
// Getting the "eye" here
gi.G2API_GetBoltMatrix( self->ghoul2,
0,
(self->spawnflags&SPF_TURRETG2_TURBO) ? ( (self->alt_fire ? gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle2" ) : gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle1" )) ) : gi.G2API_AddBolt( &self->ghoul2[0], "*flash03" ),
&boltMatrix,
self->currentAngles,
self->s.origin,
level.time,
NULL,
self->modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
VectorSubtract( org, org2, enemyDir );
vectoangles( enemyDir, desiredAngles );
diffYaw = AngleSubtract( self->currentAngles[YAW], desiredAngles[YAW] );
diffPitch = AngleSubtract( self->speed, desiredAngles[PITCH] );
}
else
{
// no enemy, so make us slowly sweep back and forth as if searching for a new one
// diffYaw = sin( level.time * 0.0001f + self->count ) * 5.0f; // don't do this for now since it can make it go into walls.
}
if ( diffYaw )
{
// cap max speed....
if ( fabs(diffYaw) > maxYawSpeed )
{
diffYaw = ( diffYaw >= 0 ? maxYawSpeed : -maxYawSpeed );
}
// ...then set up our desired yaw
VectorSet( setAngle, 0.0f, diffYaw, 0.0f );
VectorCopy( self->currentAngles, self->s.apos.trBase );
VectorScale( setAngle,- 5, self->s.apos.trDelta );
self->s.apos.trTime = level.time;
self->s.apos.trType = TR_LINEAR;
}
if ( diffPitch )
{
if ( fabs(diffPitch) > maxPitchSpeed )
{
// cap max speed
self->speed += (diffPitch > 0.0f) ? -maxPitchSpeed : maxPitchSpeed;
}
else
{
// small enough, so just add half the diff so we smooth out the stopping
self->speed -= ( diffPitch );//desiredAngles[PITCH];
}
// Note that this is NOT interpolated, so it will be less smooth...On the other hand, it does use Ghoul2 to blend, so it may smooth it out a bit?
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{
if ( self->spawnflags & 2 )
{
VectorSet( desiredAngles, 0.0f, 0.0f, -self->speed );
}
else
{
VectorSet( desiredAngles, 0.0f, 0.0f, self->speed );
}
turret_SetBoneAngles(self, "pitch", desiredAngles);
}
else
{
// Note that this is NOT interpolated, so it will be less smooth...On the other hand, it does use Ghoul2 to blend, so it may smooth it out a bit?
if ( self->spawnflags & 2 )
{
VectorSet( desiredAngles, self->speed, 0.0f, 0.0f );
}
else
{
VectorSet( desiredAngles, -self->speed, 0.0f, 0.0f );
}
gi.G2API_SetBoneAngles( &self->ghoul2[0], "Bone_body", desiredAngles,
BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, 100, cg.time );
}
}
if ( diffYaw || diffPitch )
{
self->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
}
else
{
self->s.loopSound = 0;
}
}
//-----------------------------------------------------
static void turret_turnoff( gentity_t *self )
//-----------------------------------------------------
{
if ( self->enemy == NULL )
{
// we don't need to turnoff
return;
}
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{
TurboLaser_SetBoneAnim( self, 4, 5 );
}
// shut-down sound
G_Sound( self, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
// make turret play ping sound for 5 seconds
self->aimDebounceTime = level.time + 5000;
// Clear enemy
self->enemy = NULL;
}
//-----------------------------------------------------
static qboolean turret_find_enemies( gentity_t *self )
//-----------------------------------------------------
{
// HACK for t2_wedge!!!
if ( self->spawnflags & SPF_TURRETG2_TURBO )
return qfalse;
qboolean found = qfalse;
int count;
float bestDist = self->radius * self->radius;
float enemyDist;
vec3_t enemyDir, org, org2;
gentity_t *entity_list[MAX_GENTITIES], *target, *bestTarget = NULL;
if ( self->aimDebounceTime > level.time ) // time since we've been shut off
{
// We were active and alert, i.e. had an enemy in the last 3 secs
if ( self->painDebounceTime < level.time )
{
G_Sound(self, G_SoundIndex( "sound/chars/turret/ping.wav" ));
self->painDebounceTime = level.time + 1000;
}
}
VectorCopy( self->currentOrigin, org2 );
if ( self->spawnflags & 2 )
{
org2[2] += 20;
}
else
{
org2[2] -= 20;
}
count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
for ( int i = 0; i < count; i++ )
{
target = entity_list[i];
if ( !target->client )
{
// only attack clients
continue;
}
if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
{
continue;
}
if ( target->client->playerTeam == self->noDamageTeam )
{
// A bot we don't want to shoot
continue;
}
if ( !gi.inPVS( org2, target->currentOrigin ))
{
continue;
}
VectorCopy( target->client->renderInfo.eyePoint, org );
if ( self->spawnflags & 2 )
{
org[2] -= 15;
}
else
{
org[2] += 5;
}
trace_t tr;
gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
{
// Only acquire if have a clear shot, Is it in range and closer than our best?
VectorSubtract( target->currentOrigin, self->currentOrigin, enemyDir );
enemyDist = VectorLengthSquared( enemyDir );
if ( enemyDist < bestDist )// all things equal, keep current
{
if ( self->attackDebounceTime < level.time )
{
// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
G_Sound( self, G_SoundIndex( "sound/chars/turret/startup.wav" ));
// Wind up turrets for a bit
self->attackDebounceTime = level.time + 1400;
}
bestTarget = target;
bestDist = enemyDist;
found = qtrue;
}
}
}
if ( found )
{
if ( !self->enemy )
{//just aquired one
AddSoundEvent( bestTarget, self->currentOrigin, 256, AEL_DISCOVERED );
AddSightEvent( bestTarget, self->currentOrigin, 512, AEL_DISCOVERED, 20 );
}
G_SetEnemy( self, bestTarget );
if ( VALIDSTRING( self->target2 ))
{
G_UseTargets2( self, self, self->target2 );
}
}
return found;
}
//-----------------------------------------------------
void turret_base_think( gentity_t *self )
//-----------------------------------------------------
{
qboolean turnOff = qtrue;
float enemyDist;
vec3_t enemyDir, org, org2;
self->nextthink = level.time + FRAMETIME;
if ( self->spawnflags & 1 )
{
// not turned on
turret_turnoff( self );
turret_aim( self );
// No target
self->flags |= FL_NOTARGET;
return;
}
else
{
// I'm all hot and bothered
self->flags &= ~FL_NOTARGET;
}
if ( !self->enemy )
{
if ( turret_find_enemies( self ))
{
turnOff = qfalse;
}
}
else
{
if ( self->enemy->health > 0 )
{
// enemy is alive
VectorSubtract( self->enemy->currentOrigin, self->currentOrigin, enemyDir );
enemyDist = VectorLengthSquared( enemyDir );
if ( enemyDist < self->radius * self->radius )
{
// was in valid radius
if ( gi.inPVS( self->currentOrigin, self->enemy->currentOrigin ) )
{
// Every now and again, check to see if we can even trace to the enemy
trace_t tr;
if ( self->enemy->client )
{
VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
}
else
{
VectorCopy( self->enemy->currentOrigin, org );
}
VectorCopy( self->currentOrigin, org2 );
if ( self->spawnflags & 2 )
{
org2[2] += 10;
}
else
{
org2[2] -= 10;
}
gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
if ( self->spawnflags & SPF_TURRETG2_TURBO || ( !tr.allsolid && !tr.startsolid && tr.entityNum == self->enemy->s.number ) )
{
turnOff = qfalse; // Can see our enemy
}
}
}
}
turret_head_think( self );
}
if ( turnOff )
{
if ( self->bounceCount < level.time ) // bounceCount is used to keep the thing from ping-ponging from on to off
{
turret_turnoff( self );
}
}
else
{
// keep our enemy for a minimum of 2 seconds from now
self->bounceCount = level.time + 2000 + random() * 150;
}
turret_aim( self );
}
//-----------------------------------------------------------------------------
void turret_base_use( gentity_t *self, gentity_t *other, gentity_t *activator )
//-----------------------------------------------------------------------------
{
// Toggle on and off
self->spawnflags = (self->spawnflags ^ 1);
if (( self->s.eFlags & EF_SHADER_ANIM ) && ( self->spawnflags & 1 )) // Start_Off
{
self->s.frame = 1; // black
}
else
{
self->s.frame = 0; // glow
}
}
//special routine for tracking angles between client and server -rww
void turret_SetBoneAngles(gentity_t *ent, char *bone, const vec3_t angles)
{
/*
#ifdef _XBOX
byte *thebone = &ent->s.boneIndex1;
byte *firstFree = NULL;
#else
int *thebone = &ent->s.boneIndex1;
int *firstFree = NULL;
#endif
int i = 0;
int boneIndex = G_BoneIndex(bone);
int flags;
Eorientations up, right, forward;
vec3_t *boneVector = &ent->s.boneAngles1;
vec3_t *freeBoneVec = NULL;
while (thebone)
{
if (!*thebone && !firstFree)
{ //if the value is 0 then this index is clear, we can use it if we don't find the bone we want already existing.
firstFree = thebone;
freeBoneVec = boneVector;
}
else if (*thebone)
{
if (*thebone == boneIndex)
{ //this is it
break;
}
}
switch (i)
{
case 0:
thebone = &ent->s.boneIndex2;
boneVector = &ent->s.boneAngles2;
break;
case 1:
thebone = &ent->s.boneIndex3;
boneVector = &ent->s.boneAngles3;
break;
case 2:
thebone = &ent->s.boneIndex4;
boneVector = &ent->s.boneAngles4;
break;
default:
thebone = NULL;
boneVector = NULL;
break;
}
i++;
}
if (!thebone)
{ //didn't find it, create it
if (!firstFree)
{ //no free bones.. can't do a thing then.
Com_Printf("WARNING: NPC has no free bone indexes\n");
return;
}
thebone = firstFree;
*thebone = boneIndex;
boneVector = freeBoneVec;
}
//If we got here then we have a vector and an index.
//Copy the angles over the vector in the entitystate, so we can use the corresponding index
//to set the bone angles on the client.
VectorCopy(angles, *boneVector);
*/
//Now set the angles on our server instance if we have one.
if ( !ent->ghoul2.size() )
{
return;
}
int flags = BONE_ANGLES_POSTMULT;
Eorientations up, right, forward;
up = POSITIVE_Y;
right = NEGATIVE_Z;
forward = NEGATIVE_X;
//first 3 bits is forward, second 3 bits is right, third 3 bits is up
//ent->s.boneOrient = ((forward)|(right<<3)|(up<<6));
gi.G2API_SetBoneAngles( &ent->ghoul2[0], bone, angles, flags, up,
right, forward, NULL, 100, level.time );
}
void turret_set_models( gentity_t *self, qboolean dying )
{
if ( dying )
{
if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
{
self->s.modelindex = G_ModelIndex( name2 );
self->s.modelindex2 = G_ModelIndex( name );
}
gi.G2API_RemoveGhoul2Model( self->ghoul2, 0 );
/*G_KillG2Queue( self->s.number );
self->s.modelGhoul2 = 0;
gi.G2API_InitGhoul2Model( &self->ghoul2,
name2,
0, //base->s.modelindex,
//note, this is not the same kind of index - this one's referring to the actual
//index of the model in the g2 instance, whereas modelindex is the index of a
//configstring -rww
0,
0,
0,
0);
*/
}
else
{
if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
{
self->s.modelindex = G_ModelIndex( name );
self->s.modelindex2 = G_ModelIndex( name2 );
//set the new onw
gi.G2API_InitGhoul2Model( self->ghoul2,
name,
0, //base->s.modelindex,
//note, this is not the same kind of index - this one's referring to the actual
//index of the model in the g2 instance, whereas modelindex is the index of a
//configstring -rww
0,
0,
0,
0);
}
else
{
self->s.modelindex = G_ModelIndex( name3 );
//set the new onw
gi.G2API_InitGhoul2Model( self->ghoul2,
name3,
0, //base->s.modelindex,
//note, this is not the same kind of index - this one's referring to the actual
//index of the model in the g2 instance, whereas modelindex is the index of a
//configstring -rww
0,
0,
0,
0);
}
/*self->s.modelGhoul2 = 1;
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{//larger
self->s.g2radius = 128;
}
else
{
self->s.g2radius = 80;
}*/
if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
{//different pitch bone and muzzle flash points
turret_SetBoneAngles(self, "pitch", vec3_origin);
//self->genericValue11 = gi.G2API_AddBolt( self->ghoul2, 0, "*muzzle1" );
//self->genericValue12 = gi.G2API_AddBolt( self->ghoul2, 0, "*muzzle2" );
}
else
{
turret_SetBoneAngles(self, "Bone_body", vec3_origin);
//self->genericValue11 = gi.G2API_AddBolt( self->ghoul2, 0, "*flash03" );
}
}
}
/*QUAKED misc_turret (1 0 0) (-8 -8 -22) (8 8 0) START_OFF UPSIDE_DOWN TURBO
Turret that hangs from the ceiling, will aim and shoot at enemies
START_OFF - Starts off
UPSIDE_DOWN - make it rest on a surface/floor instead of hanging from the ceiling
TURBO - Big-ass, Boxy Death Star Turbo Laser version
radius - How far away an enemy can be for it to pick it up (default 512)
wait - Time between shots (default 150 ms)
dmg - How much damage each shot does (default 5)
health - How much damage it can take before exploding (default 100)
splashDamage - How much damage the explosion does
splashRadius - The radius of the explosion
NOTE: If either of the above two are 0, it will not make an explosion
targetname - Toggles it on/off
target - What to use when destroyed
target2 - What to use when it decides to start shooting at an enemy
team - team that is not targeted by and does not take damage from this turret
"player",
"enemy", (default)
"neutral"
*/
//-----------------------------------------------------
void SP_misc_turret( gentity_t *base )
//-----------------------------------------------------
{
/*base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/turret_canon.glm" );
base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/turret_damage.md3" );
base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/imp_mine/turret_canon.glm", base->s.modelindex );
base->s.radius = 80.0f;*/
turret_set_models( base, qfalse );
gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "Bone_body", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL );
base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash03" );
finish_spawning_turret( base );
if (( base->spawnflags & 1 )) // Start_Off
{
base->s.frame = 1; // black
}
else
{
base->s.frame = 0; // glow
}
base->s.eFlags |= EF_SHADER_ANIM;
}
//-----------------------------------------------------
void finish_spawning_turret( gentity_t *base )
{
vec3_t fwd;
if ( base->spawnflags & 2 )
{
base->s.angles[ROLL] += 180;
base->s.origin[2] -= 22.0f;
}
G_SetAngles( base, base->s.angles );
AngleVectors( base->currentAngles, fwd, NULL, NULL );
G_SetOrigin(base, base->s.origin);
base->noDamageTeam = TEAM_ENEMY;
base->s.eType = ET_GENERAL;
if ( base->team && base->team[0] )
{
base->noDamageTeam = (team_t)GetIDForString( TeamTable, base->team );
base->team = NULL;
}
// Set up our explosion effect for the ExplodeDeath code....
base->fxID = G_EffectIndex( "turret/explode" );
G_EffectIndex( "sparks/spark_exp_nosnd" );
base->e_UseFunc = useF_turret_base_use;
base->e_PainFunc = painF_TurretPain;
// don't start working right away
base->e_ThinkFunc = thinkF_turret_base_think;
base->nextthink = level.time + FRAMETIME * 5;
// this is really the pitch angle.....
base->speed = 0;
G_SpawnFloat( "shotspeed", "0", &base->mass );
if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
{
if ( !base->random )
{//error worked into projectile direction
base->random = 2.0f;
}
if ( !base->mass )
{//misnomer: speed of projectile
base->mass = 4000;
}
if ( !base->health )
{
base->health = 2000;
}
// search radius
if ( !base->radius )
{
base->radius = 32768;
}
// How quickly to fire
if ( !base->wait )
{
base->wait = 500;// + random() * 500;
}
if ( !base->splashDamage )
{
base->splashDamage = 200;
}
if ( !base->splashRadius )
{
base->splashRadius = 500;
}
// how much damage each shot does
if ( !base->damage )
{
base->damage = 10;
}
VectorSet( base->s.modelScale, 2.0f, 2.0f, 2.0f );
VectorSet( base->maxs, 128.0f, 128.0f, 120.0f );
VectorSet( base->mins, -128.0f, -128.0f, -120.0f );
// Cull Radius.
base->s.radius = 256;
//start in "off" anim
TurboLaser_SetBoneAnim( base, 4, 5 );
// Make sure it doesn't do sparks and such when saber contacts with it.
base->flags = FL_DMG_BY_HEAVY_WEAP_ONLY;
base->takedamage = qfalse;
base->contents = CONTENTS_BODY|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_SHOTCLIP;
base->noDamageTeam = TEAM_NEUTRAL;
base->team = NULL;
}
else
{
// this is a random time offset for the no-enemy-search-around-mode
base->count = random() * 9000;
if ( !base->health )
{
base->health = 100;
}
// search radius
if ( !base->radius )
{
base->radius = 512;
}
// How quickly to fire
if ( !base->wait )
{
base->wait = 150 + random() * 55;
}
if ( !base->splashDamage )
{
base->splashDamage = 10;
}
if ( !base->splashRadius )
{
base->splashRadius = 25;
}
// how much damage each shot does
if ( !base->damage )
{
base->damage = 5;
}
if ( base->spawnflags & 2 )
{//upside-down, invert mins and maxe
VectorSet( base->maxs, 10.0f, 10.0f, 30.0f );
VectorSet( base->mins, -10.0f, -10.0f, 0.0f );
}
else
{
VectorSet( base->maxs, 10.0f, 10.0f, 0.0f );
VectorSet( base->mins, -10.0f, -10.0f, -30.0f );
}
base->takedamage = qtrue;
base->contents = CONTENTS_BODY|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_SHOTCLIP;
}
// Precache special FX and moving sounds
if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
{
G_EffectIndex( "turret/turb_muzzle_flash" );
G_EffectIndex( "turret/turb_shot" );
G_EffectIndex( "turret/turb_impact" );
//FIXME: Turbo Laser Cannon sounds!
G_SoundIndex( "sound/vehicles/weapons/turbolaser/turn.wav" );
G_EffectIndex( "explosions/fighter_explosion2" );
RegisterItem( FindItemForWeapon( WP_TIE_FIGHTER ));
}
else
{
// Precache moving sounds
G_SoundIndex( "sound/chars/turret/startup.wav" );
G_SoundIndex( "sound/chars/turret/shutdown.wav" );
G_SoundIndex( "sound/chars/turret/ping.wav" );
G_SoundIndex( "sound/chars/turret/move.wav" );
}
base->max_health = base->health;
base->e_DieFunc = dieF_turret_die;
base->material = MAT_METAL;
if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
{
RegisterItem( FindItemForWeapon( WP_TURRET ));
base->svFlags |= SVF_NO_TELEPORT|SVF_SELF_ANIMATING;
}
else
{
// Register this so that we can use it for the missile effect
RegisterItem( FindItemForWeapon( WP_BLASTER ));
base->svFlags |= SVF_NO_TELEPORT|SVF_NONNPC_ENEMY|SVF_SELF_ANIMATING;
}
// But set us as a turret so that we can be identified as a turret
base->s.weapon = WP_TURRET;
gi.linkentity( base );
}
/*QUAKED misc_ns_turret (1 0 0) (-8 -8 -32) (8 8 29) START_OFF
NS turret that only hangs from the ceiling, will aim and shoot at enemies
START_OFF - Starts off
radius - How far away an enemy can be for it to pick it up (default 512)
wait - Time between shots (default 150 ms)
dmg - How much damage each shot does (default 5)
health - How much damage it can take before exploding (default 100)
splashDamage - How much damage the explosion does
splashRadius - The radius of the explosion
NOTE: If either of the above two are 0, it will not make an explosion
targetname - Toggles it on/off
target - What to use when destroyed
team - team that is not targeted by and does not take damage from this turret
"player",
"enemy", (default)
"neutral"
*/
//-----------------------------------------------------
void SP_misc_ns_turret( gentity_t *base )
//-----------------------------------------------------
{
base->s.modelindex = G_ModelIndex( "models/map_objects/nar_shaddar/turret/turret.glm" );
base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/turret_damage.md3" ); // FIXME!
base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/nar_shaddar/turret/turret.glm", base->s.modelindex );
base->s.radius = 80.0f;
gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "Bone_body", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL );
base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
finish_spawning_turret( base );
}
//--------------------------------------
void laser_arm_fire (gentity_t *ent)
{
vec3_t start, end, fwd, rt, up;
trace_t trace;
if ( ent->attackDebounceTime < level.time && ent->alt_fire )
{
// If I'm firing the laser and it's time to quit....then quit!
ent->alt_fire = qfalse;
// ent->e_ThinkFunc = thinkF_NULL;
// return;
}
ent->nextthink = level.time + FRAMETIME;
// If a fool gets in the laser path, fry 'em
AngleVectors( ent->currentAngles, fwd, rt, up );
VectorMA( ent->currentOrigin, 20, fwd, start );
//VectorMA( start, -6, rt, start );
//VectorMA( start, -3, up, start );
VectorMA( start, 4096, fwd, end );
gi.trace( &trace, start, NULL, NULL, end, ENTITYNUM_NONE, MASK_SHOT );//ignore
ent->fly_sound_debounce_time = level.time;//used as lastShotTime
// Only deal damage when in alt-fire mode
if ( trace.fraction < 1.0 && ent->alt_fire )
{
if ( trace.entityNum < ENTITYNUM_WORLD )
{
gentity_t *hapless_victim = &g_entities[trace.entityNum];
if ( hapless_victim && hapless_victim->takedamage && ent->damage )
{
G_Damage( hapless_victim, ent, ent->nextTrain->activator, fwd, trace.endpos, ent->damage, DAMAGE_IGNORE_TEAM, MOD_UNKNOWN );
}
}
}
if ( ent->alt_fire )
{
// CG_FireLaser( start, trace.endpos, trace.plane.normal, ent->nextTrain->startRGBA, qfalse );
}
else
{
// CG_AimLaser( start, trace.endpos, trace.plane.normal );
}
}
void laser_arm_use (gentity_t *self, gentity_t *other, gentity_t *activator)
{
vec3_t newAngles;
self->activator = activator;
switch( self->count )
{
case 0:
default:
//Fire
//gi.Printf("FIRE!\n");
// self->lastEnemy->lastEnemy->e_ThinkFunc = thinkF_laser_arm_fire;
// self->lastEnemy->lastEnemy->nextthink = level.time + FRAMETIME;
//For 3 seconds
self->lastEnemy->lastEnemy->alt_fire = qtrue; // Let 'er rip!
self->lastEnemy->lastEnemy->attackDebounceTime = level.time + self->lastEnemy->lastEnemy->wait;
G_Sound(self->lastEnemy->lastEnemy, G_SoundIndex("sound/chars/l_arm/fire.wav"));
break;
case 1:
//Yaw left
//gi.Printf("LEFT...\n");
VectorCopy( self->lastEnemy->currentAngles, newAngles );
newAngles[1] += self->speed;
G_SetAngles( self->lastEnemy, newAngles );
// bolt_head_to_arm( self->lastEnemy, self->lastEnemy->lastEnemy, LARM_FOFS, LARM_ROFS, LARM_UOFS );
G_Sound( self->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
break;
case 2:
//Yaw right
//gi.Printf("RIGHT...\n");
VectorCopy( self->lastEnemy->currentAngles, newAngles );
newAngles[1] -= self->speed;
G_SetAngles( self->lastEnemy, newAngles );
// bolt_head_to_arm( self->lastEnemy, self->lastEnemy->lastEnemy, LARM_FOFS, LARM_ROFS, LARM_UOFS );
G_Sound( self->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
break;
case 3:
//pitch up
//gi.Printf("UP...\n");
//FIXME: Clamp
VectorCopy( self->lastEnemy->lastEnemy->currentAngles, newAngles );
newAngles[0] -= self->speed;
if ( newAngles[0] < -45 )
{
newAngles[0] = -45;
}
G_SetAngles( self->lastEnemy->lastEnemy, newAngles );
G_Sound( self->lastEnemy->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
break;
case 4:
//pitch down
//gi.Printf("DOWN...\n");
//FIXME: Clamp
VectorCopy( self->lastEnemy->lastEnemy->currentAngles, newAngles );
newAngles[0] += self->speed;
if ( newAngles[0] > 90 )
{
newAngles[0] = 90;
}
G_SetAngles( self->lastEnemy->lastEnemy, newAngles );
G_Sound( self->lastEnemy->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
break;
}
}
/*QUAKED misc_laser_arm (1 0 0) (-8 -8 -8) (8 8 8)
What it does when used depends on it's "count" (can be set by a script)
count:
0 (default) - Fire in direction facing
1 turn left
2 turn right
3 aim up
4 aim down
speed - How fast it turns (degrees per second, default 30)
dmg - How much damage the laser does 10 times a second (default 5 = 50 points per second)
wait - How long the beam lasts, in seconds (default is 3)
targetname - to use it
target - What thing for it to be pointing at to start with
"startRGBA" - laser color, Red Green Blue Alpha, range 0 to 1 (default 1.0 0.85 0.15 0.75 = Yellow-Orange)
*/
void laser_arm_start (gentity_t *base)
{
vec3_t armAngles;
vec3_t headAngles;
base->e_ThinkFunc = thinkF_NULL;
//We're the base, spawn the arm and head
gentity_t *arm = G_Spawn();
gentity_t *head = G_Spawn();
VectorCopy( base->s.angles, armAngles );
VectorCopy( base->s.angles, headAngles );
if ( base->target && base->target[0] )
{//Start out pointing at something
gentity_t *targ = G_Find( NULL, FOFS(targetname), base->target );
if ( !targ )
{//couldn't find it!
Com_Printf(S_COLOR_RED "ERROR : laser_arm can't find target %s!\n", base->target);
}
else
{//point at it
vec3_t dir, angles;
VectorSubtract(targ->currentOrigin, base->s.origin, dir );
vectoangles( dir, angles );
armAngles[1] = angles[1];
headAngles[0] = angles[0];
headAngles[1] = angles[1];
}
}
//Base
//Base does the looking for enemies and pointing the arm and head
G_SetAngles( base, base->s.angles );
//base->s.origin[2] += 4;
G_SetOrigin(base, base->s.origin);
gi.linkentity(base);
//FIXME: need an actual model
base->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_base.md3");
base->s.eType = ET_GENERAL;
G_SpawnVector4( "startRGBA", "1.0 0.85 0.15 0.75", (float *)&base->startRGBA );
//anglespeed - how fast it can track the player, entered in degrees per second, so we divide by FRAMETIME/1000
if ( !base->speed )
{
base->speed = 3.0f;
}
else
{
base->speed *= FRAMETIME/1000.0f;
}
base->e_UseFunc = useF_laser_arm_use;
base->nextthink = level.time + FRAMETIME;
//Arm
//Does nothing, not solid, gets removed when head explodes
G_SetOrigin( arm, base->s.origin );
gi.linkentity(arm);
G_SetAngles( arm, armAngles );
// bolt_head_to_arm( arm, head, LARM_FOFS, LARM_ROFS, LARM_UOFS );
arm->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_arm.md3");
//Head
//Fires when enemy detected, animates, can be blown up
//Need to normalize the headAngles pitch for the clamping later
if ( headAngles[0] < -180 )
{
headAngles[0] += 360;
}
else if ( headAngles[0] > 180 )
{
headAngles[0] -= 360;
}
G_SetAngles( head, headAngles );
head->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_head.md3");
head->s.eType = ET_GENERAL;
// head->svFlags |= SVF_BROADCAST;// Broadcast to all clients
VectorSet( head->mins, -8, -8, -8 );
VectorSet( head->maxs, 8, 8, 8 );
head->contents = CONTENTS_BODY;
gi.linkentity(head);
//dmg
if ( !base->damage )
{
head->damage = 5;
}
else
{
head->damage = base->damage;
}
base->damage = 0;
//lifespan of beam
if ( !base->wait )
{
head->wait = 3000;
}
else
{
head->wait = base->wait * 1000;
}
base->wait = 0;
//Precache firing and explode sounds
G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
G_SoundIndex("sound/chars/l_arm/fire.wav");
G_SoundIndex("sound/chars/l_arm/move.wav");
//Link them up
base->lastEnemy = arm;
arm->lastEnemy = head;
head->owner = arm;
arm->nextTrain = head->nextTrain = base;
// The head should always think, since it will be either firing a damage laser or just a target laser
head->e_ThinkFunc = thinkF_laser_arm_fire;
head->nextthink = level.time + FRAMETIME;
head->alt_fire = qfalse; // Don't do damage until told to
}
void SP_laser_arm (gentity_t *base)
{
base->e_ThinkFunc = thinkF_laser_arm_start;
base->nextthink = level.time + START_TIME_LINK_ENTS;
}
//--------------------------
// PERSONAL ASSAULT SENTRY
//--------------------------
#define PAS_DAMAGE 2
//-----------------------------------------------------------------------------
void pas_use( gentity_t *self, gentity_t *other, gentity_t *activator )
//-----------------------------------------------------------------------------
{
// Toggle on and off
self->spawnflags = (self->spawnflags ^ 1);
if ( self->spawnflags & 1 )
{
self->nextthink = 0; // turn off and do nothing
self->e_ThinkFunc = thinkF_NULL;
}
else
{
self->nextthink = level.time + 50;
self->e_ThinkFunc = thinkF_pas_think;
}
}
//----------------------------------------------------------------
void pas_fire( gentity_t *ent )
//----------------------------------------------------------------
{
vec3_t fwd, org;
mdxaBone_t boltMatrix;
// Getting the flash bolt here
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel,
ent->torsoBolt,
&boltMatrix, ent->currentAngles, ent->s.origin, (cg.time?cg.time:level.time),
NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
G_PlayEffect( "turret/muzzle_flash", org, fwd );
gentity_t *bolt;
bolt = G_Spawn();
bolt->classname = "turret_proj";
bolt->nextthink = level.time + 10000;
bolt->e_ThinkFunc = thinkF_G_FreeEntity;
bolt->s.eType = ET_MISSILE;
bolt->s.weapon = WP_TURRET;
bolt->owner = ent;
bolt->damage = PAS_DAMAGE;
bolt->dflags = DAMAGE_NO_KNOCKBACK; // Don't push them around, or else we are constantly re-aiming
bolt->splashDamage = 0;
bolt->splashRadius = 0;
bolt->methodOfDeath = MOD_ENERGY;
bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
VectorSet( bolt->maxs, 1, 1, 1 );
VectorScale( bolt->maxs, -1, bolt->mins );
bolt->s.pos.trType = TR_LINEAR;
bolt->s.pos.trTime = level.time; // move a bit on the very first frame
VectorCopy( org, bolt->s.pos.trBase );
VectorScale( fwd, 900, bolt->s.pos.trDelta );
SnapVector( bolt->s.pos.trDelta ); // save net bandwidth
VectorCopy( org, bolt->currentOrigin);
}
//-----------------------------------------------------
static qboolean pas_find_enemies( gentity_t *self )
//-----------------------------------------------------
{
qboolean found = qfalse;
int count;
float bestDist = self->radius * self->radius;
float enemyDist;
vec3_t enemyDir, org, org2;
gentity_t *entity_list[MAX_GENTITIES], *target;
if ( self->aimDebounceTime > level.time ) // time since we've been shut off
{
// We were active and alert, i.e. had an enemy in the last 3 secs
if ( self->painDebounceTime < level.time )
{
G_Sound(self, G_SoundIndex( "sound/chars/turret/ping.wav" ));
self->painDebounceTime = level.time + 1000;
}
}
mdxaBone_t boltMatrix;
// Getting the "eye" here
gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel,
self->torsoBolt,
&boltMatrix, self->currentAngles, self->s.origin, (cg.time?cg.time:level.time),
NULL, self->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
for ( int i = 0; i < count; i++ )
{
target = entity_list[i];
if ( !target->client )
{
continue;
}
if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
{
continue;
}
if ( target->client->playerTeam == self->noDamageTeam )
{
// A bot we don't want to shoot
continue;
}
if ( !gi.inPVS( org2, target->currentOrigin ))
{
continue;
}
if ( target->client )
{
VectorCopy( target->client->renderInfo.eyePoint, org );
org[2] -= 15;
}
else
{
VectorCopy( target->currentOrigin, org );
}
trace_t tr;
gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
{
// Only acquire if have a clear shot, Is it in range and closer than our best?
VectorSubtract( target->currentOrigin, self->currentOrigin, enemyDir );
enemyDist = VectorLengthSquared( enemyDir );
if ( target->s.number ) // don't do this for the player
{
G_StartFlee( target, self, self->currentOrigin, AEL_DANGER, 3000, 5000 );
}
if ( enemyDist < bestDist )// all things equal, keep current
{
if ( self->attackDebounceTime + 2000 < level.time )
{
// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
G_Sound( self, G_SoundIndex( "sound/chars/turret/startup.wav" ));
// Wind up turrets for a bit
self->attackDebounceTime = level.time + 900 + random() * 200;
}
G_SetEnemy( self, target );
bestDist = enemyDist;
found = qtrue;
}
}
}
if ( found && VALIDSTRING( self->target2 ))
{
G_UseTargets2( self, self, self->target2 );
}
return found;
}
//---------------------------------
void pas_adjust_enemy( gentity_t *ent )
//---------------------------------
{
qboolean keep = qtrue;
if ( ent->enemy->health <= 0 )
{
keep = qfalse;
}
else// if ( random() > 0.5f )
{
// do a trace every now and then.
mdxaBone_t boltMatrix;
vec3_t org, org2;
// Getting the "eye" here
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel,
ent->torsoBolt,
&boltMatrix, ent->currentAngles, ent->s.origin, (cg.time?cg.time:level.time),
NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
if ( ent->enemy->client )
{
VectorCopy( ent->enemy->client->renderInfo.eyePoint, org );
org[2] -= 15;
}
else
{
VectorCopy( ent->enemy->currentOrigin, org );
}
trace_t tr;
gi.trace( &tr, org2, NULL, NULL, org, ent->s.number, MASK_SHOT );
if ( tr.allsolid || tr.startsolid || tr.entityNum != ent->enemy->s.number )
{
// trace failed
keep = qfalse;
}
}
if ( keep )
{
ent->bounceCount = level.time + 500 + random() * 150;
}
else if ( ent->bounceCount < level.time ) // don't ping pong on and off
{
ent->enemy = NULL;
// shut-down sound
G_Sound( ent, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
// make turret play ping sound for 5 seconds
ent->aimDebounceTime = level.time + 5000;
}
}
//---------------------------------
void pas_think( gentity_t *ent )
//---------------------------------
{
if ( !ent->damage )
{
// let us do our animation, then we are good to go in terms of pounding the crap out of enemies.
ent->damage = 1;
gi.G2API_SetBoneAnimIndex( &ent->ghoul2[ent->playerModel], ent->rootBone, 0, 11, BONE_ANIM_OVERRIDE_FREEZE, 0.8f, cg.time );
ent->nextthink = level.time + 1200;
return;
}
if ( !ent->count )
{
// turrets that have no ammo may as well do nothing
return;
}
ent->nextthink = level.time + FRAMETIME;
if ( ent->enemy )
{
// make sure that the enemy is still valid
pas_adjust_enemy( ent );
}
if ( !ent->enemy )
{
pas_find_enemies( ent );
}
qboolean moved = qfalse;
float diffYaw = 0.0f, diffPitch = 0.0f;
vec3_t enemyDir, org;
vec3_t frontAngles, backAngles;
vec3_t desiredAngles;
ent->speed = AngleNormalize360( ent->speed );
ent->random = AngleNormalize360( ent->random );
if ( ent->enemy )
{
// ...then we'll calculate what new aim adjustments we should attempt to make this frame
// Aim at enemy
if ( ent->enemy->client )
{
VectorCopy( ent->enemy->client->renderInfo.eyePoint, org );
org[2] -= 40;
}
else
{
VectorCopy( ent->enemy->currentOrigin, org );
}
VectorSubtract( org, ent->currentOrigin, enemyDir );
vectoangles( enemyDir, desiredAngles );
diffYaw = AngleSubtract( ent->speed, desiredAngles[YAW] );
diffPitch = AngleSubtract( ent->random, desiredAngles[PITCH] );
}
else
{
// no enemy, so make us slowly sweep back and forth as if searching for a new one
diffYaw = sin( level.time * 0.0001f + ent->count ) * 2.0f;
}
if ( fabs(diffYaw) > 0.25f )
{
moved = qtrue;
if ( fabs(diffYaw) > 10.0f )
{
// cap max speed
ent->speed += (diffYaw > 0.0f) ? -10.0f : 10.0f;
}
else
{
// small enough
ent->speed -= diffYaw;
}
}
if ( fabs(diffPitch) > 0.25f )
{
moved = qtrue;
if ( fabs(diffPitch) > 4.0f )
{
// cap max speed
ent->random += (diffPitch > 0.0f) ? -4.0f : 4.0f;
}
else
{
// small enough
ent->random -= diffPitch;
}
}
// the bone axes are messed up, so hence some dumbness here
VectorSet( frontAngles, -ent->random, 0.0f, 0.0f );
VectorSet( backAngles, 0.0f, 0.0f, ent->speed - ent->s.angles[YAW] );
gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_barrel", frontAngles,
BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, NEGATIVE_X, NULL,100,cg.time);
gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_gback", frontAngles,
BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, NEGATIVE_X, NULL,100,cg.time);
gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_hinge", backAngles,
BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL,100,cg.time);
if ( moved )
{
//ent->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
}
else
{
ent->s.loopSound = 0;
}
if ( ent->enemy && ent->attackDebounceTime < level.time && random() > 0.3f )
{
ent->count--;
if ( ent->count )
{
pas_fire( ent );
ent->fly_sound_debounce_time = level.time;//used as lastShotTime
}
else
{
ent->nextthink = 0;
G_Sound( ent, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
}
}
}
/*QUAKED misc_sentry_turret (1 0 0) (-16 -16 0) (16 16 24) START_OFF RESERVED
personal assault sentry, like the ones you can carry in your inventory
RESERVED - do no use this flag for anything, does nothing..etc.
radius - How far away an enemy can be for it to pick it up (default 512)
count - number of shots before thing deactivates. -1 = infinite, default 150
health - How much damage it can take before exploding (default 50)
splashDamage - How much damage the explosion does
splashRadius - The radius of the explosion
NOTE: If either of the above two are 0, it will not make an explosion
target - What to use when destroyed
target2 - What to use when it decides to fire at an enemy
team - team that does not take damage from this item
"player",
"enemy",
"neutral"
*/
//---------------------------------
void SP_PAS( gentity_t *base )
//---------------------------------
{
base->classname = "PAS";
G_SetOrigin( base, base->s.origin );
G_SetAngles( base, base->s.angles );
base->speed = base->s.angles[YAW];
base->s.modelindex = G_ModelIndex( "models/items/psgun.glm" );
base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/items/psgun.glm", base->s.modelindex );
base->s.radius = 30.0f;
VectorSet( base->s.modelScale, 1.0f, 1.0f, 1.0f );
base->rootBone = gi.G2API_GetBoneIndex( &base->ghoul2[base->playerModel], "model_root", qtrue );
gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_hinge", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL );
gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_gback", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL );
gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_barrel", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL );
base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
base->s.eType = ET_GENERAL;
if ( !base->radius )
{
base->radius = 512;
}
if ( base->count == 0 )
{
// give ammo
base->count = 150;
}
base->e_UseFunc = useF_pas_use;
base->damage = 0; // start animation flag
base->contents = CONTENTS_SHOTCLIP|CONTENTS_CORPSE;//for certain traces
VectorSet( base->mins, -8, -8, 0 );
VectorSet( base->maxs, 8, 8, 18 );
if ( !(base->spawnflags & 1 )) // START_OFF
{
base->nextthink = level.time + 1000; // we aren't starting off, so start working right away
base->e_ThinkFunc = thinkF_pas_think;
}
// Set up our explosion effect for the ExplodeDeath code....
base->fxID = G_EffectIndex( "turret/explode" );
G_EffectIndex( "sparks/spark_exp_nosnd" );
if ( !base->health )
{
base->health = 50;
}
base->max_health = base->health;
base->takedamage = qtrue;
base->e_PainFunc = painF_TurretPain;
base->e_DieFunc = dieF_turret_die;
// hack this flag on so that when it calls the turret die code, it will orient the effect up
// HACK
//--------------------------------------
base->spawnflags |= 2;
// Use this for our missile effect
RegisterItem( FindItemForWeapon( WP_TURRET ));
base->s.weapon = WP_TURRET;
base->svFlags |= SVF_NONNPC_ENEMY;
base->noDamageTeam = TEAM_NEUTRAL;
if ( base->team && base->team[0] )
{
base->noDamageTeam = (team_t)GetIDForString( TeamTable, base->team );
base->team = NULL;
}
gi.linkentity( base );
}
//------------------------------------------------------------------------
qboolean place_portable_assault_sentry( gentity_t *self, vec3_t origin, vec3_t angs )
//------------------------------------------------------------------------
{
vec3_t fwd, pos;
vec3_t mins, maxs;
trace_t tr;
gentity_t *pas;
VectorSet( maxs, 9, 9, 0 );
VectorScale( maxs, -1, mins );
angs[PITCH] = 0;
angs[ROLL] = 0;
AngleVectors( angs, fwd, NULL, NULL );
// and move a consistent distance away from us so we don't have the dumb thing spawning inside of us.
VectorMA( origin, 30, fwd, pos );
gi.trace( &tr, origin, NULL, NULL, pos, self->s.number, MASK_SHOT );
// find the ground
tr.endpos[2] += 20;
VectorCopy( tr.endpos, pos );
pos[2] -= 64;
gi.trace( &tr, tr.endpos, mins, maxs, pos, self->s.number, MASK_SHOT );
// check for a decent surface, meaning mostly flat...should probably also check surface parms so we don't set us down on lava or something.
if ( !tr.startsolid && !tr.allsolid && tr.fraction < 1.0f && tr.plane.normal[2] > 0.9f && tr.entityNum >= ENTITYNUM_WORLD )
{
// Then spawn us if it seems cool.
pas = G_Spawn();
if ( pas )
{
VectorCopy( tr.endpos, pas->s.origin );
SP_PAS( pas );
pas->contents |= CONTENTS_PLAYERCLIP; // player placed ones can block players but not npcs
pas->e_UseFunc = useF_NULL; // placeable ones never need to be used
// we don't hurt us or anyone who belongs to the same team as us.
if ( self->client )
{
pas->noDamageTeam = self->client->playerTeam;
}
G_Sound( self, G_SoundIndex( "sound/player/use_sentry" ));
pas->activator = self;
return qtrue;
}
}
return qfalse;
}
//-------------
// ION CANNON
//-------------
//----------------------------------------
void ion_cannon_think( gentity_t *self )
//----------------------------------------
{
if ( self->spawnflags & 2 )
{
if ( self->count )
{
// still have bursts left, so keep going
self->count--;
}
else
{
// done with burst, so wait delay amount, plus a random bit
self->nextthink = level.time + ( self->delay + crandom() * self->random );
self->count = Q_irand(0,5); // 0-5 bursts
// Not firing this time
return;
}
}
if ( self->fxID )
{
vec3_t fwd, org;
mdxaBone_t boltMatrix;
// Getting the flash bolt here
gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel,
self->torsoBolt,
&boltMatrix, self->s.angles, self->s.origin, (cg.time?cg.time:level.time),
NULL, self->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
G_PlayEffect( self->fxID, org, fwd );
}
if ( self->target2 )
{
// If we have a target2 fire it off in sync with our gun firing
G_UseTargets2( self, self, self->target2 );
}
gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 0, 8, BONE_ANIM_OVERRIDE_FREEZE, 0.6f, cg.time );
self->nextthink = level.time + self->wait + crandom() * self->random;
}
//----------------------------------------------------------------------------------------------
void ion_cannon_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
//----------------------------------------------------------------------------------------------
{
vec3_t org;
// dead, so nuke the ghoul model and put in the damage md3 version
if ( self->playerModel >= 0 )
{
gi.G2API_RemoveGhoul2Model( self->ghoul2, self->playerModel );
}
self->s.modelindex = self->s.modelindex2;
self->s.modelindex2 = 0;
// Turn off the thinking of the base & use it's targets
self->e_ThinkFunc = thinkF_NULL;
self->e_UseFunc = useF_NULL;
if ( self->target )
{
G_UseTargets( self, attacker );
}
// clear my data
self->e_DieFunc = dieF_NULL;
self->takedamage = qfalse;
self->health = 0;
self->takedamage = qfalse;//stop chain reaction runaway loops
self->s.loopSound = 0;
// not solid anymore
self->contents = 0;
VectorCopy( self->currentOrigin, self->s.pos.trBase );
VectorCopy( self->currentOrigin, org );
org[2] += 20;
G_PlayEffect( "env/ion_cannon_explosion", org );
if ( self->splashDamage > 0 && self->splashRadius > 0 )
{
G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius,
attacker, MOD_UNKNOWN );
}
gi.linkentity( self );
}
//----------------------------------------------------------------------------
void ion_cannon_use( gentity_t *self, gentity_t *other, gentity_t *activator )
//----------------------------------------------------------------------------
{
// toggle
if ( self->e_ThinkFunc == thinkF_NULL )
{
// start thinking now
self->e_ThinkFunc = thinkF_ion_cannon_think;
self->nextthink = level.time + FRAMETIME; // fires right on being used
}
else
{
self->e_ThinkFunc = thinkF_NULL;
}
}
/*QUAKED misc_ion_cannon (1 0 0) (-280 -280 0) (280 280 640) START_OFF BURSTS SHIELDED
Huge ion cannon, like the ones at the rebel base on Hoth.
START_OFF - Starts off
BURSTS - adds more variation, shots come out in bursts
SHIELDED - cannon is shielded, any kind of shot bounces off.
wait - How fast it shoots (default 1500 ms between shots, can't be less than 500 ms)
random - milliseconds wait variation (default 400 ms...up to plus or minus .4 seconds)
delay - Number of milliseconds between bursts (default 6000 ms, can't be less than 1000 ms, only works when BURSTS checked)
health - default 2000
splashDamage - how much damage to do when it dies, must be greater than 0 to actually work
splashRadius - damage radius, must be greater than 0 to actually work
targetname - Toggles it on/off
target - What to use when destroyed
target2 - What to use when it fires a shot.
*/
//-----------------------------------------------------
void SP_misc_ion_cannon( gentity_t *base )
//-----------------------------------------------------
{
G_SetAngles( base, base->s.angles );
G_SetOrigin(base, base->s.origin);
base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/ion_cannon.glm" );
base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/imp_mine/ion_cannon.glm", base->s.modelindex );
base->s.radius = 320.0f;
VectorSet( base->s.modelScale, 2.0f, 2.0f, 2.0f );
base->rootBone = gi.G2API_GetBoneIndex( &base->ghoul2[base->playerModel], "model_root", qtrue );
base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
// register damage model
base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/ion_cannon_damage.md3" );
base->e_UseFunc = useF_ion_cannon_use;
// How quickly to fire
if ( base->wait == 0.0f )
{
base->wait = 1500.0f;
}
else if ( base->wait < 500.0f )
{
base->wait = 500.0f;
}
if ( base->random == 0.0f )
{
base->random = 400.0f;
}
if ( base->delay == 0 )
{
base->delay = 6000;
}
else if ( base->delay < 1000 )
{
base->delay = 1000;
}
// we only take damage from a heavy weapon class missile
base->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
if ( base->spawnflags & 4 )//shielded
{
base->flags |= FL_SHIELDED; //technically, this would only take damage from a lightsaber, but the other flag just above would cancel that out too.
}
G_SpawnInt( "health", "2000", &base->health );
base->e_DieFunc = dieF_ion_cannon_die;
base->takedamage = qtrue;
// Start Off?
if ( base->spawnflags & 1 )
{
base->e_ThinkFunc = thinkF_NULL;
}
else
{
// start thinking now, otherwise, we'll wait until we are used
base->e_ThinkFunc = thinkF_ion_cannon_think;
base->nextthink = level.time + base->wait + crandom() * base->random;
}
// Bursts?
if ( base->spawnflags & 2 )
{
base->count = Q_irand(0,5); // 0-5 bursts
}
// precache
base->fxID = G_EffectIndex( "env/ion_cannon" );
// Set up our explosion effect for the ExplodeDeath code....
G_EffectIndex( "env/ion_cannon_explosion" );
base->contents = CONTENTS_BODY;
VectorSet( base->mins, -141.0f, -148.0f, 0.0f );
VectorSet( base->maxs, 142.0f, 135.0f, 245.0f );
gi.linkentity( base );
}
//-----------------------------------------------------
void spotlight_use( gentity_t *self, gentity_t *other, gentity_t *activator )
{
if ( self->e_ThinkFunc == thinkF_NULL )
{
// start thinking now, otherwise, we'll wait until we are used
self->e_ThinkFunc = thinkF_spotlight_think;
self->nextthink = level.time + FRAMETIME;
}
else
{
self->e_ThinkFunc = thinkF_NULL;
self->s.eFlags &= ~EF_ALT_FIRING;
}
}
//-----------------------------------------------------
void spotlight_think( gentity_t *ent )
{
vec3_t dir, end;
trace_t tr;
// dumb hack flag so that we can draw an interpolated light cone cgame side.
ent->s.eFlags |= EF_ALT_FIRING;
VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, dir );
VectorNormalize( dir );
vectoangles( dir, ent->s.apos.trBase );
ent->s.apos.trType = TR_INTERPOLATE;
VectorMA( ent->currentOrigin, 2048, dir, end ); // just pick some max trace distance
gi.trace( &tr, ent->currentOrigin, vec3_origin, vec3_origin, end, ent->s.number, CONTENTS_SOLID );
ent->radius = tr.fraction * 2048.0f;
if ( tr.fraction < 1 )
{
if ( DistanceSquared( tr.endpos, g_entities[0].currentOrigin ) < 140 * 140 )
{
// hit player--use target2
G_UseTargets2( ent, &g_entities[0], ent->target2 );
#ifndef FINAL_BUILD
if ( g_developer->integer == PRINT_DEVELOPER )
{
Com_Printf( S_COLOR_MAGENTA "Spotlight hit player at time: %d!!!\n", level.time );
}
#endif
}
}
ent->nextthink = level.time + 50;
}
//-----------------------------------------------------
void spotlight_link( gentity_t *ent )
{
gentity_t *target = 0;
target = G_Find( target, FOFS(targetname), ent->target );
if ( !target )
{
Com_Printf( S_COLOR_RED "ERROR: spotlight_link: bogus target %s\n", ent->target );
G_FreeEntity( ent );
return;
}
ent->enemy = target;
// Start Off?
if ( ent->spawnflags & 1 )
{
ent->e_ThinkFunc = thinkF_NULL;
ent->s.eFlags &= ~EF_ALT_FIRING;
}
else
{
// start thinking now, otherwise, we'll wait until we are used
ent->e_ThinkFunc = thinkF_spotlight_think;
ent->nextthink = level.time + FRAMETIME;
}
}
/*QUAKED misc_spotlight (1 0 0) (-10 -10 0) (10 10 10) START_OFF
model="models/map_objects/imp_mine/spotlight.md3"
Search spotlight that must be targeted at a func_train or other entity
Uses its target2 when it detects the player
START_OFF - Starts off
targetname - Toggles it on/off
target - What to point at
target2 - What to use when detects player
*/
//-----------------------------------------------------
void SP_misc_spotlight( gentity_t *base )
//-----------------------------------------------------
{
if ( !base->target )
{
Com_Printf( S_COLOR_RED "ERROR: misc_spotlight must have a target\n" );
G_FreeEntity( base );
return;
}
G_SetAngles( base, base->s.angles );
G_SetOrigin( base, base->s.origin );
base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/spotlight.md3" );
G_SpawnInt( "health", "300", &base->health );
// Set up our lightcone effect, though we will have it draw cgame side so it looks better
G_EffectIndex( "env/light_cone" );
base->contents = CONTENTS_BODY;
base->e_UseFunc = useF_spotlight_use;
// the thing we need to target may not have spawned yet, so try back in a bit
base->e_ThinkFunc = thinkF_spotlight_link;
base->nextthink = level.time + 100;
gi.linkentity( base );
}
/*QUAKED misc_panel_turret (0 0 1) (-8 -8 -12) (8 8 16) HEALTH
Creates a turret that, when the player uses a panel, takes control of this turret and adopts the turret view
HEALTH - gun turret has health and displays a hud with its current health
"target" - thing to use when player enters the turret view
"target2" - thing to use when player leaves the turret view
"target3" - thing to use when it dies.
radius - the max yaw range in degrees, (default 90) which means you can move 90 degrees on either side of the start angles.
random - the max pitch range in degrees, (default 60) which means you can move 60 degrees above or below the start angles.
delay - time between shots, in milliseconds (default 200).
damage - amount of damage shots do, (default 50).
speed - missile speed, (default 3000)
heatlh - how much heatlh the thing has, (default 200) only works if HEALTH is checked, otherwise it can't be destroyed.
*/
extern gentity_t *player;
extern qboolean G_ClearViewEntity( gentity_t *ent );
extern void G_SetViewEntity( gentity_t *self, gentity_t *viewEntity );
extern gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
void panel_turret_shoot( gentity_t *self, vec3_t org, vec3_t dir)
{
gentity_t *missile = CreateMissile( org, dir, self->speed, 10000, self );
missile->classname = "b_proj";
missile->s.weapon = WP_TIE_FIGHTER;
VectorSet( missile->maxs, 9, 9, 9 );
VectorScale( missile->maxs, -1, missile->mins );
missile->bounceCount = 0;
missile->damage = self->damage;
missile->dflags = DAMAGE_DEATH_KNOCKBACK;
missile->methodOfDeath = MOD_ENERGY;
missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
G_SoundOnEnt( self, CHAN_AUTO, "sound/movers/objects/ladygun_fire" );
VectorMA( org, 32, dir, org );
org[2] -= 4;
G_PlayEffect( "ships/imp_blastermuzzleflash", org, dir );
}
//-----------------------------------------
void misc_panel_turret_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
{
if ( self->target3 )
{
G_UseTargets2( self, player, self->target3 );
}
// FIXME: might need some other kind of logic or functionality in here??
G_UseTargets2( self, player, self->target2 );
G_ClearViewEntity( player );
cg.overrides.active &= ~CG_OVERRIDE_FOV;
cg.overrides.fov = 0;
}
//-----------------------------------------
void panel_turret_think( gentity_t *self )
{
// Ensure that I am the viewEntity
if ( player && player->client && player->client->ps.viewEntity == self->s.number )
{
usercmd_t *ucmd = &player->client->usercmd;
// We are the viewEnt so update our new viewangles based on the sum of our start angles and the ucmd angles
for ( int i = 0; i < 3; i++ )
{
// convert our base angle to a short, add with the usercmd.angle ( a short ), then switch use back to a real angle
self->s.apos.trBase[i] = AngleNormalize180( SHORT2ANGLE( ucmd->angles[i] + ANGLE2SHORT( self->s.angles[i] ) + self->pos3[i] ));
}
// Only clamp if we have a PITCH clamp
if ( self->random != 0.0f )
// Angle clamping -- PITCH
{
if ( self->s.apos.trBase[PITCH] > self->random ) // random is PITCH
{
self->pos3[PITCH] += ANGLE2SHORT( AngleNormalize180( self->random - self->s.apos.trBase[PITCH]));
self->s.apos.trBase[PITCH] = self->random;
}
else if ( self->s.apos.trBase[PITCH] < -self->random )
{
self->pos3[PITCH] -= ANGLE2SHORT( AngleNormalize180( self->random + self->s.apos.trBase[PITCH]));
self->s.apos.trBase[PITCH] = -self->random;
}
}
// Only clamp if we have a YAW clamp
if ( self->radius != 0.0f )
{
float yawDif = AngleSubtract( self->s.apos.trBase[YAW], self->s.angles[YAW] );
// Angle clamping -- YAW
if ( yawDif > self->radius ) // radius is YAW
{
self->pos3[YAW] += ANGLE2SHORT( self->radius - yawDif );
self->s.apos.trBase[YAW] = AngleNormalize180( self->s.angles[YAW] + self->radius );
}
else if ( yawDif < -self->radius ) // radius is YAW
{
self->pos3[YAW] -= ANGLE2SHORT( self->radius + yawDif );
self->s.apos.trBase[YAW] = AngleNormalize180( self->s.angles[YAW] - self->radius );
}
}
// Let cgame interpolation smooth out the angle changes
self->s.apos.trType = TR_INTERPOLATE;
self->s.pos.trType = TR_INTERPOLATE; // not really moving, but this fixes an interpolation bug in cg_ents.
// Check for backing out of turret
if ( ( self->useDebounceTime < level.time ) && ((ucmd->buttons & BUTTON_USE) || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove) )
{
self->useDebounceTime = level.time + 200;
G_UseTargets2( self, player, self->target2 );
G_ClearViewEntity( player );
G_Sound( player, self->soundPos2 );
cg.overrides.active &= ~CG_OVERRIDE_FOV;
cg.overrides.fov = 0;
if ( ucmd->upmove > 0 )
{//stop player from doing anything for a half second after
player->aimDebounceTime = level.time + 500;
}
// can be drawn
// self->s.eFlags &= ~EF_NODRAW;
}
else
{
// don't draw me when being looked through
// self->s.eFlags |= EF_NODRAW;
// self->s.modelindex = 0;
// we only need to think when we are being used
self->nextthink = level.time + 50;
cg.overrides.active |= CG_OVERRIDE_FOV;
cg.overrides.fov = 90;
}
if ( ucmd->buttons & BUTTON_ATTACK || ucmd->buttons & BUTTON_ALT_ATTACK )
{
if ( self->attackDebounceTime < level.time )
{
vec3_t dir, pt;
AngleVectors( self->s.apos.trBase, dir, NULL, NULL );
VectorCopy( self->currentOrigin, pt );
pt[2] -= 4;
panel_turret_shoot( self, pt, dir );
self->attackDebounceTime = level.time + self->delay;
}
}
}
}
//-----------------------------------------
void panel_turret_use( gentity_t *self, gentity_t *other, gentity_t *activator )
{
// really only usable by the player
if ( !activator || !activator->client || activator->s.number )
{
return;
}
if ( self->useDebounceTime > level.time )
{
// can't use it again right away.
return;
}
if ( self->spawnflags & 1 ) // health...presumably the lady luck gun
{
G_Sound( self, G_SoundIndex( "sound/movers/objects/ladygun_on" ));
}
self->useDebounceTime = level.time + 200;
// Compensating for the difference between the players view at the time of use and the start angles that the gun object has
self->pos3[PITCH] = -activator->client->usercmd.angles[PITCH];
self->pos3[YAW] = -activator->client->usercmd.angles[YAW];
self->pos3[ROLL] = 0;
// set me as view entity
G_UseTargets2( self, activator, self->target );
G_SetViewEntity( activator, self );
G_Sound( activator, self->soundPos1 );
self->e_ThinkFunc = thinkF_panel_turret_think;
// panel_turret_think( self );
self->nextthink = level.time + 150;
}
//-----------------------------------------
void SP_misc_panel_turret( gentity_t *self )
{
G_SpawnFloat( "radius", "90", &self->radius ); // yaw
G_SpawnFloat( "random", "60", &self->random ); // pitch
G_SpawnFloat( "speed" , "3000", &self->speed );
G_SpawnInt( "delay", "200", &self->delay );
G_SpawnInt( "damage", "50", &self->damage );
VectorSet( self->pos3, 0.0f, 0.0f, 0.0f );
if ( self->spawnflags & 1 ) // heatlh
{
self->takedamage = qtrue;
self->contents = CONTENTS_SHOTCLIP;
G_SpawnInt( "health", "200", &self->health );
self->max_health = self->health;
self->dflags |= DAMAGE_CUSTOM_HUD; // dumb, but we draw a custom hud
G_SoundIndex( "sound/movers/objects/ladygun_on" );
}
self->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/ladyluck_gun.md3" );
self->soundPos1 = G_SoundIndex( "sound/movers/camera_on.mp3" );
self->soundPos2 = G_SoundIndex( "sound/movers/camera_off.mp3" );
G_SoundIndex( "sound/movers/objects/ladygun_fire" );
G_EffectIndex("ships/imp_blastermuzzleflash");
G_SetOrigin( self, self->s.origin );
G_SetAngles( self, self->s.angles );
VectorSet( self->mins, -8, -8, -12 );
VectorSet( self->maxs, 8, 8, 0 );
self->contents = CONTENTS_SOLID;
self->s.weapon = WP_TURRET;
RegisterItem( FindItemForWeapon( WP_EMPLACED_GUN ));
gi.linkentity( self );
self->e_UseFunc = useF_panel_turret_use;
self->e_DieFunc = dieF_misc_panel_turret_die;
}
#undef name
#undef name2
#undef name3
Reference in New Issue View Git Blame Copy Permalink