codemp/game/g_items.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
#include "g_local.h"
#include "../ghoul2/G2.h"
#include "q_shared.h"

/*

  Items are any object that a player can touch to gain some effect.

  Pickup will return the number of seconds until they should respawn.

  all items should pop when dropped in lava or slime

  Respawnable items don't actually go away when picked up, they are
  just made invisible and untouchable.  This allows them to ride
  movers and respawn apropriately.
*/


#define RESPAWN_ARMOR           20
#define RESPAWN_TEAM_WEAPON     30
#define RESPAWN_HEALTH          30
#define RESPAWN_AMMO            40
#define RESPAWN_HOLDABLE        60
#define RESPAWN_MEGAHEALTH      120
#define RESPAWN_POWERUP         120

// Item Spawn flags
#define ITMSF_SUSPEND           1
#define ITMSF_NOPLAYER          2
#define ITMSF_ALLOWNPC          4
#define ITMSF_NOTSOLID          8
#define ITMSF_VERTICAL          16
#define ITMSF_INVISIBLE         32

extern gentity_t *droppedRedFlag;
extern gentity_t *droppedBlueFlag;


//======================================================================
#define MAX_MEDPACK_HEAL_AMOUNT         25
#define MAX_MEDPACK_BIG_HEAL_AMOUNT     50
#define MAX_SENTRY_DISTANCE                     256

// For more than four players, adjust the respawn times, up to 1/4.
int adjustRespawnTime(float preRespawnTime, int itemType, int itemTag)
{
        float respawnTime = preRespawnTime;

        if (itemType == IT_WEAPON)
        {
                if (itemTag == WP_THERMAL ||
                        itemTag == WP_TRIP_MINE ||
                        itemTag == WP_DET_PACK)
                { //special case for these, use ammo respawn rate
                        respawnTime = RESPAWN_AMMO;
                }
        }

        if (!g_adaptRespawn.integer)
        {
                return((int)respawnTime);
        }

        if (level.numPlayingClients > 4)
        {       // Start scaling the respawn times.
                if (level.numPlayingClients > 32)
                {       // 1/4 time minimum.
                        respawnTime *= 0.25;
                }
                else if (level.numPlayingClients > 12)
                {       // From 12-32, scale from 0.5 to 0.25;
                        respawnTime *= 20.0 / (float)(level.numPlayingClients + 8);
                }
                else 
                {       // From 4-12, scale from 1.0 to 0.5;
                        respawnTime *= 8.0 / (float)(level.numPlayingClients + 4);
                }
        }

        if (respawnTime < 1.0)
        {       // No matter what, don't go lower than 1 second, or the pickups become very noisy!
                respawnTime = 1.0;
        }

        return ((int)respawnTime);
}


#define SHIELD_HEALTH                           250
#define SHIELD_HEALTH_DEC                       10              // 25 seconds   
#define MAX_SHIELD_HEIGHT                       254
#define MAX_SHIELD_HALFWIDTH            255
#define SHIELD_HALFTHICKNESS            4
#define SHIELD_PLACEDIST                        64

#define SHIELD_SIEGE_HEALTH                     2000
#define SHIELD_SIEGE_HEALTH_DEC         (SHIELD_SIEGE_HEALTH/25)        // still 25 seconds.

static qhandle_t        shieldLoopSound=0;
static qhandle_t        shieldAttachSound=0;
static qhandle_t        shieldActivateSound=0;
static qhandle_t        shieldDeactivateSound=0;
static qhandle_t        shieldDamageSound=0;


void ShieldRemove(gentity_t *self)
{
        self->think = G_FreeEntity;
        self->nextthink = level.time + 100;

        // Play kill sound...
        G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);
        self->s.loopSound = 0;
        self->s.loopIsSoundset = qfalse;

        return;
}


// Count down the health of the shield.
void ShieldThink(gentity_t *self)
{
        self->s.trickedentindex = 0;

        if ( g_gametype.integer == GT_SIEGE )
        {
                self->health -= SHIELD_SIEGE_HEALTH_DEC;
        }
        else
        {
                self->health -= SHIELD_HEALTH_DEC;
        }
        self->nextthink = level.time + 1000;
        if (self->health <= 0)
        {
                ShieldRemove(self);
        }
        return;
}


// The shield was damaged to below zero health.
void ShieldDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
{
        // Play damaging sound...
        G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

        ShieldRemove(self);
}


// The shield had damage done to it.  Make it flicker.
void ShieldPain(gentity_t *self, gentity_t *attacker, int damage)
{
        // Set the itemplaceholder flag to indicate the the shield drawing that the shield pain should be drawn.
        self->think = ShieldThink;
        self->nextthink = level.time + 400;

        // Play damaging sound...
        G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);

        self->s.trickedentindex = 1;

        return;
}


// Try to turn the shield back on after a delay.
void ShieldGoSolid(gentity_t *self)
{
        trace_t         tr;

        // see if we're valid
        self->health--;
        if (self->health <= 0)
        {
                ShieldRemove(self);
                return;
        }
        
        trap_Trace (&tr, self->r.currentOrigin, self->r.mins, self->r.maxs, self->r.currentOrigin, self->s.number, CONTENTS_BODY );
        if(tr.startsolid)
        {       // gah, we can't activate yet
                self->nextthink = level.time + 200;
                self->think = ShieldGoSolid;
                trap_LinkEntity(self);
        }
        else
        { // get hard... huh-huh...
                self->s.eFlags &= ~EF_NODRAW;

                self->r.contents = CONTENTS_SOLID;
                self->nextthink = level.time + 1000;
                self->think = ShieldThink;
                self->takedamage = qtrue;
                trap_LinkEntity(self);

                // Play raising sound...
                G_AddEvent(self, EV_GENERAL_SOUND, shieldActivateSound);
                self->s.loopSound = shieldLoopSound;
                self->s.loopIsSoundset = qfalse;
        }

        return;
}


// Turn the shield off to allow a friend to pass through.
void ShieldGoNotSolid(gentity_t *self)
{
        // make the shield non-solid very briefly
        self->r.contents = 0;
        self->s.eFlags |= EF_NODRAW;
        // nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
        self->nextthink = level.time + 200;
        self->think = ShieldGoSolid;
        self->takedamage = qfalse;
        trap_LinkEntity(self);

        // Play kill sound...
        G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);
        self->s.loopSound = 0;
        self->s.loopIsSoundset = qfalse;
}


// Somebody (a player) has touched the shield.  See if it is a "friend".
void ShieldTouch(gentity_t *self, gentity_t *other, trace_t *trace)
{
        if (g_gametype.integer >= GT_TEAM)
        { // let teammates through
                // compare the parent's team to the "other's" team
                if (self->parent && ( self->parent->client) && (other->client))
                {
                        if (OnSameTeam(self->parent, other))
                        {
                                ShieldGoNotSolid(self);
                        }
                }
        }
        else
        {//let the person who dropped the shield through
                if (self->parent && self->parent->s.number == other->s.number)
                {
                        ShieldGoNotSolid(self);
                }
        }
}


// After a short delay, create the shield by expanding in all directions.
void CreateShield(gentity_t *ent)
{
        trace_t         tr;
        vec3_t          mins, maxs, end, posTraceEnd, negTraceEnd, start;
        int                     height, posWidth, negWidth, halfWidth = 0;
        qboolean        xaxis;
        int                     paramData = 0;
        static int      shieldID;

        // trace upward to find height of shield
        VectorCopy(ent->r.currentOrigin, end);
        end[2] += MAX_SHIELD_HEIGHT;
        trap_Trace (&tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT );
        height = (int)(MAX_SHIELD_HEIGHT * tr.fraction);

        // use angles to find the proper axis along which to align the shield
        VectorSet(mins, -SHIELD_HALFTHICKNESS, -SHIELD_HALFTHICKNESS, 0);
        VectorSet(maxs, SHIELD_HALFTHICKNESS, SHIELD_HALFTHICKNESS, height);
        VectorCopy(ent->r.currentOrigin, posTraceEnd);
        VectorCopy(ent->r.currentOrigin, negTraceEnd);

        if ((int)(ent->s.angles[YAW]) == 0) // shield runs along y-axis
        {
                posTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;
                negTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
                xaxis = qfalse;
        }
        else  // shield runs along x-axis
        {
                posTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;
                negTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
                xaxis = qtrue;
        }

        // trace horizontally to find extend of shield
        // positive trace
        VectorCopy(ent->r.currentOrigin, start);
        start[2] += (height>>1);
        trap_Trace (&tr, start, 0, 0, posTraceEnd, ent->s.number, MASK_SHOT );
        posWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
        // negative trace
        trap_Trace (&tr, start, 0, 0, negTraceEnd, ent->s.number, MASK_SHOT );
        negWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;

        // kef -- monkey with dimensions and place origin in center
        halfWidth = (posWidth + negWidth)>>1;
        if (xaxis)
        {
                ent->r.currentOrigin[0] = ent->r.currentOrigin[0] - negWidth + halfWidth;
        }
        else
        {
                ent->r.currentOrigin[1] = ent->r.currentOrigin[1] - negWidth + halfWidth;
        }
        ent->r.currentOrigin[2] += (height>>1);

        // set entity's mins and maxs to new values, make it solid, and link it
        if (xaxis)
        {
                VectorSet(ent->r.mins, -halfWidth, -SHIELD_HALFTHICKNESS, -(height>>1));
                VectorSet(ent->r.maxs, halfWidth, SHIELD_HALFTHICKNESS, height>>1);
        }
        else
        {
                VectorSet(ent->r.mins, -SHIELD_HALFTHICKNESS, -halfWidth, -(height>>1));
                VectorSet(ent->r.maxs, SHIELD_HALFTHICKNESS, halfWidth, height);
        }
        ent->clipmask = MASK_SHOT;

        // Information for shield rendering.

//      xaxis - 1 bit
//      height - 0-254 8 bits
//      posWidth - 0-255 8 bits
//  negWidth - 0 - 255 8 bits

        paramData = (xaxis << 24) | (height << 16) | (posWidth << 8) | (negWidth);
        ent->s.time2 = paramData;

        if ( g_gametype.integer == GT_SIEGE )
        {
                ent->health = ceil((float)(SHIELD_SIEGE_HEALTH*1));
        }
        else
        {
                ent->health = ceil((float)(SHIELD_HEALTH*1));
        }

        ent->s.time = ent->health;//???
        ent->pain = ShieldPain;
        ent->die = ShieldDie;
        ent->touch = ShieldTouch;

        // see if we're valid
        trap_Trace (&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, CONTENTS_BODY ); 

        if (tr.startsolid)
        {       // Something in the way!
                // make the shield non-solid very briefly
                ent->r.contents = 0;
                ent->s.eFlags |= EF_NODRAW;
                // nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
                ent->nextthink = level.time + 200;
                ent->think = ShieldGoSolid;
                ent->takedamage = qfalse;
                trap_LinkEntity(ent);
        }
        else
        {       // Get solid.
                ent->r.contents = CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP;//CONTENTS_SOLID;

                ent->nextthink = level.time;
                ent->think = ShieldThink;

                ent->takedamage = qtrue;
                trap_LinkEntity(ent);

                // Play raising sound...
                G_AddEvent(ent, EV_GENERAL_SOUND, shieldActivateSound);
                ent->s.loopSound = shieldLoopSound;
                ent->s.loopIsSoundset = qfalse;
        }

        ShieldGoSolid(ent);

        return;
}

qboolean PlaceShield(gentity_t *playerent)
{
        static const gitem_t *shieldItem = NULL;
        gentity_t       *shield = NULL;
        trace_t         tr;
        vec3_t          fwd, pos, dest, mins = {-4,-4, 0}, maxs = {4,4,4};

        if (shieldAttachSound==0)
        {
                shieldLoopSound = G_SoundIndex("sound/movers/doors/forcefield_lp.wav");
                shieldAttachSound = G_SoundIndex("sound/weapons/detpack/stick.wav");
                shieldActivateSound = G_SoundIndex("sound/movers/doors/forcefield_on.wav");
                shieldDeactivateSound = G_SoundIndex("sound/movers/doors/forcefield_off.wav");
                shieldDamageSound = G_SoundIndex("sound/effects/bumpfield.wav");
                shieldItem = BG_FindItemForHoldable(HI_SHIELD);
        }

        // can we place this in front of us?
        AngleVectors (playerent->client->ps.viewangles, fwd, NULL, NULL);
        fwd[2] = 0;
        VectorMA(playerent->client->ps.origin, SHIELD_PLACEDIST, fwd, dest);
        trap_Trace (&tr, playerent->client->ps.origin, mins, maxs, dest, playerent->s.number, MASK_SHOT );
        if (tr.fraction > 0.9)
        {//room in front
                VectorCopy(tr.endpos, pos);
                // drop to floor
                VectorSet( dest, pos[0], pos[1], pos[2] - 4096 );
                trap_Trace( &tr, pos, mins, maxs, dest, playerent->s.number, MASK_SOLID );
                if ( !tr.startsolid && !tr.allsolid )
                {
                        // got enough room so place the portable shield
                        shield = G_Spawn();

                        // Figure out what direction the shield is facing.
                        if (fabs(fwd[0]) > fabs(fwd[1]))
                        {       // shield is north/south, facing east.
                                shield->s.angles[YAW] = 0;
                        }
                        else
                        {       // shield is along the east/west axis, facing north
                                shield->s.angles[YAW] = 90;
                        }
                        shield->think = CreateShield;
                        shield->nextthink = level.time + 500;   // power up after .5 seconds
                        shield->parent = playerent;

                        // Set team number.
                        shield->s.otherEntityNum2 = playerent->client->sess.sessionTeam;

                        shield->s.eType = ET_SPECIAL;
                        shield->s.modelindex =  HI_SHIELD;      // this'll be used in CG_Useable() for rendering.
                        shield->classname = shieldItem->classname;

                        shield->r.contents = CONTENTS_TRIGGER;

                        shield->touch = 0;
                        // using an item causes it to respawn
                        shield->use = 0; //Use_Item;

                        // allow to ride movers
                        shield->s.groundEntityNum = tr.entityNum;

                        G_SetOrigin( shield, tr.endpos );

                        shield->s.eFlags &= ~EF_NODRAW;
                        shield->r.svFlags &= ~SVF_NOCLIENT;

                        trap_LinkEntity (shield);

                        shield->s.owner = playerent->s.number;
                        shield->s.shouldtarget = qtrue;
                        if (g_gametype.integer >= GT_TEAM)
                        {
                                shield->s.teamowner = playerent->client->sess.sessionTeam;
                        }
                        else
                        {
                                shield->s.teamowner = 16;
                        }

                        // Play placing sound...
                        G_AddEvent(shield, EV_GENERAL_SOUND, shieldAttachSound);

                        return qtrue;
                }
        }
        // no room
        return qfalse;
}

void ItemUse_Binoculars(gentity_t *ent)
{
        if (!ent || !ent->client)
        {
                return;
        }

        if (ent->client->ps.weaponstate != WEAPON_READY)
        { //So we can't fool it and reactivate while switching to the saber or something.
                return;
        }

        /*
        if (ent->client->ps.weapon == WP_SABER)
        { //No.
                return;
        }
        */

        if (ent->client->ps.zoomMode == 0) // not zoomed or currently zoomed with the disruptor
        {
                ent->client->ps.zoomMode = 2;
                ent->client->ps.zoomLocked = qfalse;
                ent->client->ps.zoomFov = 40.0f;
        }
        else if (ent->client->ps.zoomMode == 2)
        {
                ent->client->ps.zoomMode = 0;
                ent->client->ps.zoomTime = level.time;
        }
}

void ItemUse_Shield(gentity_t *ent)
{
        PlaceShield(ent);
}

//--------------------------
// PERSONAL ASSAULT SENTRY
//--------------------------

#define PAS_DAMAGE      2

void SentryTouch(gentity_t *ent, gentity_t *other, trace_t *trace)
{
        return;
}

//----------------------------------------------------------------
void pas_fire( gentity_t *ent )
//----------------------------------------------------------------
{
        vec3_t fwd, myOrg, enOrg;

        VectorCopy(ent->r.currentOrigin, myOrg);
        myOrg[2] += 24;

        VectorCopy(ent->enemy->client->ps.origin, enOrg);
        enOrg[2] += 24;

        VectorSubtract(enOrg, myOrg, fwd);
        VectorNormalize(fwd);
        
        myOrg[0] += fwd[0]*16;
        myOrg[1] += fwd[1]*16;
        myOrg[2] += fwd[2]*16;

        WP_FireTurretMissile(&g_entities[ent->genericValue3], myOrg, fwd, qfalse, 10, 2300, MOD_SENTRY, ent );

        G_RunObject(ent);
}

#define TURRET_RADIUS 800

//-----------------------------------------------------
static qboolean pas_find_enemies( gentity_t *self )
//-----------------------------------------------------
{
        qboolean        found = qfalse;
        int                     count, i;
        float           bestDist = TURRET_RADIUS*TURRET_RADIUS;
        float           enemyDist;
        vec3_t          enemyDir, org, org2;
        gentity_t       *entity_list[MAX_GENTITIES], *target;
        trace_t         tr;

        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, CHAN_BODY, G_SoundIndex( "sound/chars/turret/ping.wav" ));
                        self->painDebounceTime = level.time + 1000;
                }
        }

        VectorCopy(self->s.pos.trBase, org2);

        count = G_RadiusList( org2, TURRET_RADIUS, self, qtrue, entity_list );

        for ( 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 ( self->alliedTeam && target->client->sess.sessionTeam == self->alliedTeam )
                { 
                        continue;
                }
                if (self->genericValue3 == target->s.number)
                {
                        continue;
                }
                if ( !trap_InPVS( org2, target->r.currentOrigin ))
                {
                        continue;
                }

                if (target->s.eType == ET_NPC &&
                        target->s.NPC_class == CLASS_VEHICLE)
                { //don't get mad at vehicles, silly.
                        continue;
                }

                if ( target->client )
                {
                        VectorCopy( target->client->ps.origin, org );
                }
                else
                {
                        VectorCopy( target->r.currentOrigin, org );
                }

                trap_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->r.currentOrigin, self->r.currentOrigin, enemyDir );
                        enemyDist = VectorLengthSquared( enemyDir );

                        if ( enemyDist < bestDist )// all things equal, keep current
                        {
                                if ( self->attackDebounceTime + 100 < level.time )
                                {
                                        // We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
                                        G_Sound( self, CHAN_BODY, 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;
                        }
                }
        }

        return found;
}

//---------------------------------
void pas_adjust_enemy( gentity_t *ent )
//---------------------------------
{
        trace_t tr;
        qboolean keep = qtrue;

        if ( ent->enemy->health <= 0 )
        {
                keep = qfalse;
        }
        else
        {
                vec3_t          org, org2;

                VectorCopy(ent->s.pos.trBase, org2);

                if ( ent->enemy->client )
                {
                        VectorCopy( ent->enemy->client->ps.origin, org );
                        org[2] -= 15;
                }
                else
                {
                        VectorCopy( ent->enemy->r.currentOrigin, org );
                }

                trap_Trace( &tr, org2, NULL, NULL, org, ent->s.number, MASK_SHOT );

                if ( tr.allsolid || tr.startsolid || tr.fraction < 0.9f || tr.entityNum == ent->s.number )
                {
                        if (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 && ent->enemy ) // don't ping pong on and off
        {
                ent->enemy = NULL;
                // shut-down sound
                G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
        
                ent->bounceCount = level.time + 500 + random() * 150;

                // make turret play ping sound for 5 seconds
                ent->aimDebounceTime = level.time + 5000;
        }
}

#define TURRET_DEATH_DELAY 2000
#define TURRET_LIFETIME 60000

void turret_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);

void sentryExpire(gentity_t *self)
{
        turret_die(self, self, self, 1000, MOD_UNKNOWN);        
}

//---------------------------------
void pas_think( gentity_t *ent )
//---------------------------------
{
        qboolean        moved;
        float           diffYaw, diffPitch;
        vec3_t          enemyDir, org;
        vec3_t          frontAngles, backAngles;
        vec3_t          desiredAngles;
        int                     iEntityList[MAX_GENTITIES];
        int                     numListedEntities;
        int                     i = 0;
        qboolean        clTrapped = qfalse;
        vec3_t          testMins, testMaxs;

        testMins[0] = ent->r.currentOrigin[0] + ent->r.mins[0]+4;
        testMins[1] = ent->r.currentOrigin[1] + ent->r.mins[1]+4;
        testMins[2] = ent->r.currentOrigin[2] + ent->r.mins[2]+4;

        testMaxs[0] = ent->r.currentOrigin[0] + ent->r.maxs[0]-4;
        testMaxs[1] = ent->r.currentOrigin[1] + ent->r.maxs[1]-4;
        testMaxs[2] = ent->r.currentOrigin[2] + ent->r.maxs[2]-4;

        numListedEntities = trap_EntitiesInBox( testMins, testMaxs, iEntityList, MAX_GENTITIES );

        while (i < numListedEntities)
        {
                if (iEntityList[i] < MAX_CLIENTS)
                { //client stuck inside me. go nonsolid.
                        int clNum = iEntityList[i];

                        numListedEntities = trap_EntitiesInBox( g_entities[clNum].r.absmin, g_entities[clNum].r.absmax, iEntityList, MAX_GENTITIES );

                        i = 0;
                        while (i < numListedEntities)
                        {
                                if (iEntityList[i] == ent->s.number)
                                {
                                        clTrapped = qtrue;
                                        break;
                                }
                                i++;
                        }
                        break;
                }

                i++;
        }

        if (clTrapped)
        {
                ent->r.contents = 0;
                ent->s.fireflag = 0;
                ent->nextthink = level.time + FRAMETIME;
                return;
        }
        else
        {
                ent->r.contents = CONTENTS_SOLID;
        }

        if (!g_entities[ent->genericValue3].inuse || !g_entities[ent->genericValue3].client ||
                g_entities[ent->genericValue3].client->sess.sessionTeam != ent->genericValue2)
        {
                ent->think = G_FreeEntity;
                ent->nextthink = level.time;
                return;
        }

//      G_RunObject(ent);

        if ( !ent->damage )
        {
                ent->damage = 1;
                ent->nextthink = level.time + FRAMETIME;
                return;
        }

        if ((ent->genericValue8+TURRET_LIFETIME) < level.time)
        {
                G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
                ent->s.bolt2 = ENTITYNUM_NONE;
                ent->s.fireflag = 2;

                ent->think = sentryExpire;
                ent->nextthink = level.time + TURRET_DEATH_DELAY;
                return;
        }

        ent->nextthink = level.time + FRAMETIME;

        if ( ent->enemy )
        {
                // make sure that the enemy is still valid
                pas_adjust_enemy( ent );
        }

        if (ent->enemy)
        {
                if (!ent->enemy->client)
                {
                        ent->enemy = NULL;
                }
                else if (ent->enemy->s.number == ent->s.number)
                {
                        ent->enemy = NULL;
                }
                else if (ent->enemy->health < 1)
                {
                        ent->enemy = NULL;
                }
        }

        if ( !ent->enemy )
        {
                pas_find_enemies( ent );
        }

        if (ent->enemy)
        {
                ent->s.bolt2 = ent->enemy->s.number;
        }
        else
        {
                ent->s.bolt2 = ENTITYNUM_NONE;
        }

        moved = qfalse;
        diffYaw = 0.0f; diffPitch = 0.0f;

        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->ps.origin, org );
                }
                else
                {
                        VectorCopy( ent->enemy->r.currentOrigin, org );
                }

                VectorSubtract( org, ent->r.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 );

        if ( moved )
        {
        //ent->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
        }
        else
        {
                ent->s.loopSound = 0;
                ent->s.loopIsSoundset = qfalse;
        }

        if ( ent->enemy && ent->attackDebounceTime < level.time )
        {
                ent->count--;

                if ( ent->count )
                {
                        pas_fire( ent );
                        ent->s.fireflag = 1;
                        ent->attackDebounceTime = level.time + 200;
                }
                else
                {
                        //ent->nextthink = 0;
                        G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
                        ent->s.bolt2 = ENTITYNUM_NONE;
                        ent->s.fireflag = 2;

                        ent->think = sentryExpire;
                        ent->nextthink = level.time + TURRET_DEATH_DELAY;
                }
        }
        else
        {
                ent->s.fireflag = 0;
        }
}

//------------------------------------------------------------------------------------------------------------
void turret_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
//------------------------------------------------------------------------------------------------------------
{
        // Turn off the thinking of the base & use it's targets
        self->think = 0;//NULL;
        self->use = 0;//NULL;

        if ( self->target )
        {
                G_UseTargets( self, attacker );
        }

        if (!g_entities[self->genericValue3].inuse || !g_entities[self->genericValue3].client)
        {
                G_FreeEntity(self);
                return;
        }

        // clear my data
        self->die  = 0;//NULL;
        self->takedamage = qfalse;
        self->health = 0;

        // hack the effect angle so that explode death can orient the effect properly
        VectorSet( self->s.angles, 0, 0, 1 );

        G_PlayEffect(EFFECT_EXPLOSION_PAS, self->s.pos.trBase, self->s.angles);
        G_RadiusDamage(self->s.pos.trBase, &g_entities[self->genericValue3], 30, 256, self, self, MOD_UNKNOWN);

        g_entities[self->genericValue3].client->ps.fd.sentryDeployed = qfalse;

        //ExplodeDeath( self );
        G_FreeEntity( self );
}

#define TURRET_AMMO_COUNT 40

//---------------------------------
void SP_PAS( gentity_t *base )
//---------------------------------
{
        if ( base->count == 0 )
        {
                // give ammo
                base->count = TURRET_AMMO_COUNT;
        }

        base->s.bolt1 = 1; //This is a sort of hack to indicate that this model needs special turret things done to it
        base->s.bolt2 = ENTITYNUM_NONE; //store our current enemy index

        base->damage = 0; // start animation flag

        VectorSet( base->r.mins, -8, -8, 0 );
        VectorSet( base->r.maxs, 8, 8, 24 );

        G_RunObject(base);

        base->think = pas_think;
        base->nextthink = level.time + FRAMETIME;

        if ( !base->health )
        {
                base->health = 50;
        }

        base->takedamage = qtrue;
        base->die  = turret_die;

        base->physicsObject = qtrue;

        G_Sound( base, CHAN_BODY, G_SoundIndex( "sound/chars/turret/startup.wav" ));
}

//------------------------------------------------------------------------
void ItemUse_Sentry( gentity_t *ent )
//------------------------------------------------------------------------
{
        vec3_t fwd, fwdorg;
        vec3_t yawonly;
        vec3_t mins, maxs;
        gentity_t *sentry;

        if (!ent || !ent->client)
        {
                return;
        }

        VectorSet( mins, -8, -8, 0 );
        VectorSet( maxs, 8, 8, 24 );


        yawonly[ROLL] = 0;
        yawonly[PITCH] = 0;
        yawonly[YAW] = ent->client->ps.viewangles[YAW];

        AngleVectors(yawonly, fwd, NULL, NULL);

        fwdorg[0] = ent->client->ps.origin[0] + fwd[0]*64;
        fwdorg[1] = ent->client->ps.origin[1] + fwd[1]*64;
        fwdorg[2] = ent->client->ps.origin[2] + fwd[2]*64;

        sentry = G_Spawn();

        sentry->classname = "sentryGun";
        sentry->s.modelindex = G_ModelIndex("models/items/psgun.glm"); //replace ASAP

        sentry->s.g2radius = 30.0f;
        sentry->s.modelGhoul2 = 1;

        G_SetOrigin(sentry, fwdorg);
        sentry->parent = ent;
        sentry->r.contents = CONTENTS_SOLID;
        sentry->s.solid = 2;
        sentry->clipmask = MASK_SOLID;
        VectorCopy(mins, sentry->r.mins);
        VectorCopy(maxs, sentry->r.maxs);
        sentry->genericValue3 = ent->s.number;
        sentry->genericValue2 = ent->client->sess.sessionTeam; //so we can remove ourself if our owner changes teams
        sentry->r.absmin[0] = sentry->s.pos.trBase[0] + sentry->r.mins[0];
        sentry->r.absmin[1] = sentry->s.pos.trBase[1] + sentry->r.mins[1];
        sentry->r.absmin[2] = sentry->s.pos.trBase[2] + sentry->r.mins[2];
        sentry->r.absmax[0] = sentry->s.pos.trBase[0] + sentry->r.maxs[0];
        sentry->r.absmax[1] = sentry->s.pos.trBase[1] + sentry->r.maxs[1];
        sentry->r.absmax[2] = sentry->s.pos.trBase[2] + sentry->r.maxs[2];
        sentry->s.eType = ET_GENERAL;
        sentry->s.pos.trType = TR_GRAVITY;//STATIONARY;
        sentry->s.pos.trTime = level.time;
        sentry->touch = SentryTouch;
        sentry->nextthink = level.time;
        sentry->genericValue4 = ENTITYNUM_NONE; //genericValue4 used as enemy index

        sentry->genericValue5 = 1000;

        sentry->genericValue8 = level.time;

        sentry->alliedTeam = ent->client->sess.sessionTeam;

        ent->client->ps.fd.sentryDeployed = qtrue;

        trap_LinkEntity(sentry);

        sentry->s.owner = ent->s.number;
        sentry->s.shouldtarget = qtrue;
        if (g_gametype.integer >= GT_TEAM)
        {
                sentry->s.teamowner = ent->client->sess.sessionTeam;
        }
        else
        {
                sentry->s.teamowner = 16;
        }

        SP_PAS( sentry );
}

extern gentity_t *NPC_SpawnType( gentity_t *ent, char *npc_type, char *targetname, qboolean isVehicle );
void ItemUse_Seeker(gentity_t *ent)
{
        if ( g_gametype.integer == GT_SIEGE && d_siegeSeekerNPC.integer )
        {//actualy spawn a remote NPC
                gentity_t *remote = NPC_SpawnType( ent, "remote", NULL, qfalse );
                if ( remote && remote->client )
                {//set it to my team
                        remote->s.owner = remote->r.ownerNum = ent->s.number;
                        remote->activator = ent;
                        if ( ent->client->sess.sessionTeam == TEAM_BLUE )
                        {
                                remote->client->playerTeam = NPCTEAM_PLAYER;
                        }
                        else if ( ent->client->sess.sessionTeam == TEAM_RED )
                        {
                                remote->client->playerTeam = NPCTEAM_ENEMY;
                        }
                        else
                        {
                                remote->client->playerTeam = NPCTEAM_NEUTRAL;
                        }
                }       
        }
        else
        {
                ent->client->ps.eFlags |= EF_SEEKERDRONE;
                ent->client->ps.droneExistTime = level.time + 30000;
                ent->client->ps.droneFireTime = level.time + 1500;
        }
}

static void MedPackGive(gentity_t *ent, int amount)
{
        if (!ent || !ent->client)
        {
                return;
        }

        if (ent->health <= 0 ||
                ent->client->ps.stats[STAT_HEALTH] <= 0 ||
                (ent->client->ps.eFlags & EF_DEAD))
        {
                return;
        }

        if (ent->health >= ent->client->ps.stats[STAT_MAX_HEALTH])
        {
                return;
        }

        ent->health += amount;

        if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH])
        {
                ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
        }
}

void ItemUse_MedPack_Big(gentity_t *ent)
{
        MedPackGive(ent, MAX_MEDPACK_BIG_HEAL_AMOUNT);
}

void ItemUse_MedPack(gentity_t *ent)
{
        MedPackGive(ent, MAX_MEDPACK_HEAL_AMOUNT);
}

#define JETPACK_TOGGLE_TIME                     1000
void Jetpack_Off(gentity_t *ent)
{ //create effects?
        assert(ent && ent->client);

        if (!ent->client->jetPackOn)
        { //aready off
                return;
        }

        ent->client->jetPackOn = qfalse;
}

void Jetpack_On(gentity_t *ent)
{ //create effects?
        assert(ent && ent->client);

        if (ent->client->jetPackOn)
        { //aready on
                return;
        }

        if (ent->client->ps.fd.forceGripBeingGripped >= level.time)
        { //can't turn on during grip interval
                return;
        }

        if (ent->client->ps.fallingToDeath)
        { //too late!
                return;
        }

        G_Sound(ent, CHAN_AUTO, G_SoundIndex("sound/boba/JETON"));

        ent->client->jetPackOn = qtrue;
}

void ItemUse_Jetpack( gentity_t *ent )
{
        assert(ent && ent->client);

        if (ent->client->jetPackToggleTime >= level.time)
        {
                return;
        }

        if (ent->health <= 0 ||
                ent->client->ps.stats[STAT_HEALTH] <= 0 ||
                (ent->client->