codemp/game/g_active.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//

#include "g_local.h"
#include "bg_saga.h"

extern void Jedi_Cloak( gentity_t *self );
extern void Jedi_Decloak( gentity_t *self );

#include "../namespace_begin.h"
qboolean PM_SaberInTransition( int move );
qboolean PM_SaberInStart( int move );
qboolean PM_SaberInReturn( int move );
qboolean WP_SaberStyleValidForSaber( saberInfo_t *saber1, saberInfo_t *saber2, int saberHolstered, int saberAnimLevel );
#include "../namespace_end.h"
qboolean saberCheckKnockdown_DuelLoss(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other);

extern vmCvar_t g_saberLockRandomNess;

void P_SetTwitchInfo(gclient_t  *client)
{
        client->ps.painTime = level.time;
        client->ps.painDirection ^= 1;
}

/*
===============
G_DamageFeedback

Called just before a snapshot is sent to the given player.
Totals up all damage and generates both the player_state_t
damage values to that client for pain blends and kicks, and
global pain sound events for all clients.
===============
*/
void P_DamageFeedback( gentity_t *player ) {
        gclient_t       *client;
        float   count;
        vec3_t  angles;

        client = player->client;
        if ( client->ps.pm_type == PM_DEAD ) {
                return;
        }

        // total points of damage shot at the player this frame
        count = client->damage_blood + client->damage_armor;
        if ( count == 0 ) {
                return;         // didn't take any damage
        }

        if ( count > 255 ) {
                count = 255;
        }

        // send the information to the client

        // world damage (falling, slime, etc) uses a special code
        // to make the blend blob centered instead of positional
        if ( client->damage_fromWorld ) {
                client->ps.damagePitch = 255;
                client->ps.damageYaw = 255;

                client->damage_fromWorld = qfalse;
        } else {
                vectoangles( client->damage_from, angles );
                client->ps.damagePitch = angles[PITCH]/360.0 * 256;
                client->ps.damageYaw = angles[YAW]/360.0 * 256;

                //cap them since we can't send negative values in here across the net
                if (client->ps.damagePitch < 0)
                {
                        client->ps.damagePitch = 0;
                }
                if (client->ps.damageYaw < 0)
                {
                        client->ps.damageYaw = 0;
                }
        }

        // play an apropriate pain sound
        if ( (level.time > player->pain_debounce_time) && !(player->flags & FL_GODMODE) && !(player->s.eFlags & EF_DEAD) ) {

                // don't do more than two pain sounds a second
                // nmckenzie: also don't make him loud and whiny if he's only getting nicked.
                if ( level.time - client->ps.painTime < 500 || count < 10) {
                        return;
                }
                P_SetTwitchInfo(client);
                player->pain_debounce_time = level.time + 700;
                
                G_AddEvent( player, EV_PAIN, player->health );
                client->ps.damageEvent++;

                if (client->damage_armor && !client->damage_blood)
                {
                        client->ps.damageType = 1; //pure shields
                }
                else if (client->damage_armor)
                {
                        client->ps.damageType = 2; //shields and health
                }
                else
                {
                        client->ps.damageType = 0; //pure health
                }
        }


        client->ps.damageCount = count;

        //
        // clear totals
        //
        client->damage_blood = 0;
        client->damage_armor = 0;
        client->damage_knockback = 0;
}



/*
=============
P_WorldEffects

Check for lava / slime contents and drowning
=============
*/
void P_WorldEffects( gentity_t *ent ) {
        qboolean        envirosuit;
        int                     waterlevel;

        if ( ent->client->noclip ) {
                ent->client->airOutTime = level.time + 12000;   // don't need air
                return;
        }

        waterlevel = ent->waterlevel;

        envirosuit = ent->client->ps.powerups[PW_BATTLESUIT] > level.time;

        //
        // check for drowning
        //
        if ( waterlevel == 3 ) {
                // envirosuit give air
                if ( envirosuit ) {
                        ent->client->airOutTime = level.time + 10000;
                }

                // if out of air, start drowning
                if ( ent->client->airOutTime < level.time) {
                        // drown!
                        ent->client->airOutTime += 1000;
                        if ( ent->health > 0 ) {
                                // take more damage the longer underwater
                                ent->damage += 2;
                                if (ent->damage > 15)
                                        ent->damage = 15;

                                // play a gurp sound instead of a normal pain sound
                                if (ent->health <= ent->damage) {
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex(/*"*drown.wav"*/"sound/player/gurp1.wav"));
                                } else if (rand()&1) {
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp1.wav"));
                                } else {
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp2.wav"));
                                }

                                // don't play a normal pain sound
                                ent->pain_debounce_time = level.time + 200;

                                G_Damage (ent, NULL, NULL, NULL, NULL, 
                                        ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
                        }
                }
        } else {
                ent->client->airOutTime = level.time + 12000;
                ent->damage = 2;
        }

        //
        // check for sizzle damage (move to pmove?)
        //
        if (waterlevel && 
                (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
                if (ent->health > 0
                        && ent->pain_debounce_time <= level.time        ) {

                        if ( envirosuit ) {
                                G_AddEvent( ent, EV_POWERUP_BATTLESUIT, 0 );
                        } else {
                                if (ent->watertype & CONTENTS_LAVA) {
                                        G_Damage (ent, NULL, NULL, NULL, NULL, 
                                                30*waterlevel, 0, MOD_LAVA);
                                }

                                if (ent->watertype & CONTENTS_SLIME) {
                                        G_Damage (ent, NULL, NULL, NULL, NULL, 
                                                10*waterlevel, 0, MOD_SLIME);
                                }
                        }
                }
        }
}





//==============================================================
extern void G_ApplyKnockback( gentity_t *targ, vec3_t newDir, float knockback );
void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf )
{
        float magnitude, my_mass;
        vec3_t  velocity;
        int cont;
        qboolean easyBreakBrush = qtrue;

        if( self->client )
        {
                VectorCopy( self->client->ps.velocity, velocity );
                if( !self->mass )
                {
                        my_mass = 10;
                }
                else
                {
                        my_mass = self->mass;
                }
        }
        else 
        {
                VectorCopy( self->s.pos.trDelta, velocity );
                if ( self->s.pos.trType == TR_GRAVITY )
                {
                        velocity[2] -= 0.25f * g_gravity.value;
                }
                if( !self->mass )
                {
                        my_mass = 1;
                }
                else if ( self->mass <= 10 )
                {
                        my_mass = 10;
                }
                else
                {
                        my_mass = self->mass;
                }
        }

        magnitude = VectorLength( velocity ) * my_mass / 10;

        /*
        if(pointcontents(self.absmax)==CONTENT_WATER)//FIXME: or other watertypes
                magnitude/=3;                                                   //water absorbs 2/3 velocity

        if(self.classname=="barrel"&&self.aflag)//rolling barrels are made for impacts!
                magnitude*=3;

        if(self.frozen>0&&magnitude<300&&self.flags&FL_ONGROUND&&loser==world&&self.velocity_z<-20&&self.last_onground+0.3<time)
                magnitude=300;
        */
        if ( other->material == MAT_GLASS 
                || other->material == MAT_GLASS_METAL 
                || other->material == MAT_GRATE1
                || ((other->flags&FL_BBRUSH)&&(other->spawnflags&8/*THIN*/))
                || (other->r.svFlags&SVF_GLASS_BRUSH) )
        {
                easyBreakBrush = qtrue;
        }

        if ( !self->client || self->client->ps.lastOnGround+300<level.time || ( self->client->ps.lastOnGround+100 < level.time && easyBreakBrush ) )
        {
                vec3_t dir1, dir2;
                float force = 0, dot;

                if ( easyBreakBrush )
                        magnitude *= 2;

                //damage them
                if ( magnitude >= 100 && other->s.number < ENTITYNUM_WORLD )
                {
                        VectorCopy( velocity, dir1 );
                        VectorNormalize( dir1 );
                        if( VectorCompare( other->r.currentOrigin, vec3_origin ) )
                        {//a brush with no origin
                                VectorCopy ( dir1, dir2 );
                        }
                        else
                        {
                                VectorSubtract( other->r.currentOrigin, self->r.currentOrigin, dir2 );
                                VectorNormalize( dir2 );
                        }

                        dot = DotProduct( dir1, dir2 );

                        if ( dot >= 0.2 )
                        {
                                force = dot;
                        }
                        else
                        {
                                force = 0;
                        }

                        force *= (magnitude/50);

                        cont = trap_PointContents( other->r.absmax, other->s.number );
                        if( (cont&CONTENTS_WATER) )//|| (self.classname=="barrel"&&self.aflag))//FIXME: or other watertypes
                        {
                                force /= 3;                                                     //water absorbs 2/3 velocity
                        }

                        /*
                        if(self.frozen>0&&force>10)
                                force=10;
                        */

                        if( ( force >= 1 && other->s.number != 0 ) || force >= 10)
                        {
        /*                      
                                dprint("Damage other (");
                                dprint(loser.classname);
                                dprint("): ");
                                dprint(ftos(force));
                                dprint("\n");
        */
                                if ( other->r.svFlags & SVF_GLASS_BRUSH )
                                {
                                        other->splashRadius = (float)(self->r.maxs[0] - self->r.mins[0])/4.0f;
                                }
                                if ( other->takedamage )
                                {
                                        G_Damage( other, self, self, velocity, self->r.currentOrigin, force, DAMAGE_NO_ARMOR, MOD_CRUSH);//FIXME: MOD_IMPACT
                                }
                                else
                                {
                                        G_ApplyKnockback( other, dir2, force );
                                }
                        }
                }

                if ( damageSelf && self->takedamage )
                {
                        //Now damage me
                        //FIXME: more lenient falling damage, especially for when driving a vehicle
                        if ( self->client && self->client->ps.fd.forceJumpZStart )
                        {//we were force-jumping
                                if ( self->r.currentOrigin[2] >= self->client->ps.fd.forceJumpZStart )
                                {//we landed at same height or higher than we landed
                                        magnitude = 0;
                                }
                                else
                                {//FIXME: take off some of it, at least?
                                        magnitude = (self->client->ps.fd.forceJumpZStart-self->r.currentOrigin[2])/3;
                                }
                        }
                        //if(self.classname!="monster_mezzoman"&&self.netname!="spider")//Cats always land on their feet
                                if( ( magnitude >= 100 + self->health && self->s.number != 0 && self->s.weapon != WP_SABER ) || ( magnitude >= 700 ) )//&& self.safe_time < level.time ))//health here is used to simulate structural integrity
                                {
                                        if ( (self->s.weapon == WP_SABER || self->s.number == 0) && self->client && self->client->ps.groundEntityNum < ENTITYNUM_NONE && magnitude < 1000 )
                                        {//players and jedi take less impact damage
                                                //allow for some lenience on high falls
                                                magnitude /= 2;
                                                /*
                                                if ( self.absorb_time >= time )//crouching on impact absorbs 1/2 the damage
                                                {
                                                        magnitude/=2;
                                                }
                                                */
                                        }
                                        magnitude /= 40;
                                        magnitude = magnitude - force/2;//If damage other, subtract half of that damage off of own injury
                                        if ( magnitude >= 1 )
                                        {
                //FIXME: Put in a thingtype impact sound function
                /*                                      
                                                dprint("Damage self (");
                                                dprint(self.classname);
                                                dprint("): ");
                                                dprint(ftos(magnitude));
                                                dprint("\n");
                */
                                                /*
                                                if ( self.classname=="player_sheep "&& self.flags&FL_ONGROUND && self.velocity_z > -50 )
                                                        return;
                                                */
                                                G_Damage( self, NULL, NULL, NULL, self->r.currentOrigin, magnitude/2, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
                                        }
                                }
                }

                //FIXME: slow my velocity some?

                // NOTENOTE We don't use lastimpact as of yet
//              self->lastImpact = level.time;

                /*
                if(self.flags&FL_ONGROUND)
                        self.last_onground=time;
                */
        }
}

void Client_CheckImpactBBrush( gentity_t *self, gentity_t *other )
{
        if ( !other || !other->inuse )
        {
                return;
        }
        if (!self || !self->inuse || !self->client ||
                self->client->tempSpectate >= level.time ||
                self->client->sess.sessionTeam == TEAM_SPECTATOR)
        { //hmm.. let's not let spectators ram into breakables.
                return;
        }

        /*
        if (BG_InSpecialJump(self->client->ps.legsAnim))
        { //don't do this either, qa says it creates "balance issues"
                return;
        }
        */

        if ( other->material == MAT_GLASS 
                || other->material == MAT_GLASS_METAL 
                || other->material == MAT_GRATE1
                || ((other->flags&FL_BBRUSH)&&(other->spawnflags&8/*THIN*/))
                || ((other->flags&FL_BBRUSH)&&(other->health<=10))
                || (other->r.svFlags&SVF_GLASS_BRUSH) )
        {//clients only do impact damage against easy-break breakables
                DoImpact( self, other, qfalse );
        }
}


/*
===============
G_SetClientSound
===============
*/
void G_SetClientSound( gentity_t *ent ) {
        if (ent->client && ent->client->isHacking)
        { //loop hacking sound
                ent->client->ps.loopSound = level.snd_hack;
                ent->s.loopIsSoundset = qfalse;
        }
        else if (ent->client && ent->client->isMedHealed > level.time)
        { //loop healing sound
                ent->client->ps.loopSound = level.snd_medHealed;
                ent->s.loopIsSoundset = qfalse;
        }
        else if (ent->client && ent->client->isMedSupplied > level.time)
        { //loop supplying sound
                ent->client->ps.loopSound = level.snd_medSupplied;
                ent->s.loopIsSoundset = qfalse;
        }
        else if (ent->waterlevel && (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
                ent->client->ps.loopSound = level.snd_fry;
                ent->s.loopIsSoundset = qfalse;
        } else {
                ent->client->ps.loopSound = 0;
                ent->s.loopIsSoundset = qfalse;
        }
}



//==============================================================

/*
==============
ClientImpacts
==============
*/
void ClientImpacts( gentity_t *ent, pmove_t *pm ) {
        int             i, j;
        trace_t trace;
        gentity_t       *other;

        memset( &trace, 0, sizeof( trace ) );
        for (i=0 ; i<pm->numtouch ; i++) {
                for (j=0 ; j<i ; j++) {
                        if (pm->touchents[j] == pm->touchents[i] ) {
                                break;
                        }
                }
                if (j != i) {
                        continue;       // duplicated
                }
                other = &g_entities[ pm->touchents[i] ];

                if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
                        ent->touch( ent, other, &trace );
                }

                if ( !other->touch ) {
                        continue;
                }

                other->touch( other, ent, &trace );
        }

}

/*
============
G_TouchTriggers

Find all trigger entities that ent's current position touches.
Spectators will only interact with teleporters.
============
*/
void    G_TouchTriggers( gentity_t *ent ) {
        int                     i, num;
        int                     touch[MAX_GENTITIES];
        gentity_t       *hit;
        trace_t         trace;
        vec3_t          mins, maxs;
        static vec3_t   range = { 40, 40, 52 };

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

        // dead clients don't activate triggers!
        if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {
                return;
        }

        VectorSubtract( ent->client->ps.origin, range, mins );
        VectorAdd( ent->client->ps.origin, range, maxs );

        num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

        // can't use ent->r.absmin, because that has a one unit pad
        VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
        VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );

        for ( i=0 ; i<num ; i++ ) {
                hit = &g_entities[touch[i]];

                if ( !hit->touch && !ent->touch ) {
                        continue;
                }
                if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) {
                        continue;
                }

                // ignore most entities if a spectator
                if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
                        if ( hit->s.eType != ET_TELEPORT_TRIGGER &&
                                // this is ugly but adding a new ET_? type will
                                // most likely cause network incompatibilities
                                hit->touch != Touch_DoorTrigger) {
                                continue;
                        }
                }

                // use seperate code for determining if an item is picked up
                // so you don't have to actually contact its bounding box
                if ( hit->s.eType == ET_ITEM ) {
                        if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
                                continue;
                        }
                } else {
                        if ( !trap_EntityContact( mins, maxs, hit ) ) {
                                continue;
                        }
                }

                memset( &trace, 0, sizeof(trace) );

                if ( hit->touch ) {
                        hit->touch (hit, ent, &trace);
                }

                if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
                        ent->touch( ent, hit, &trace );
                }
        }

        // if we didn't touch a jump pad this pmove frame
        if ( ent->client->ps.jumppad_frame != ent->client->ps.pmove_framecount ) {
                ent->client->ps.jumppad_frame = 0;
                ent->client->ps.jumppad_ent = 0;
        }
}


/*
============
G_MoverTouchTriggers

Find all trigger entities that ent's current position touches.
Spectators will only interact with teleporters.
============
*/
void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg ) 
{
        int                     i, num;
        float           step, stepSize, dist;
        int                     touch[MAX_GENTITIES];
        gentity_t       *hit;
        trace_t         trace;
        vec3_t          mins, maxs, dir, size, checkSpot;
        const vec3_t    range = { 40, 40, 52 };

        // non-moving movers don't hit triggers!
        if ( !VectorLengthSquared( ent->s.pos.trDelta ) ) 
        {
                return;
        }

        VectorSubtract( ent->r.mins, ent->r.maxs, size );
        stepSize = VectorLength( size );
        if ( stepSize < 1 )
        {
                stepSize = 1;
        }

        VectorSubtract( ent->r.currentOrigin, oldOrg, dir );
        dist = VectorNormalize( dir );
        for ( step = 0; step <= dist; step += stepSize )
        {
                VectorMA( ent->r.currentOrigin, step, dir, checkSpot );
                VectorSubtract( checkSpot, range, mins );
                VectorAdd( checkSpot, range, maxs );

                num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );

                // can't use ent->r.absmin, because that has a one unit pad
                VectorAdd( checkSpot, ent->r.mins, mins );
                VectorAdd( checkSpot, ent->r.maxs, maxs );

                for ( i=0 ; i<num ; i++ ) 
                {
                        hit = &g_entities[touch[i]];

                        if ( hit->s.eType != ET_PUSH_TRIGGER )
                        {
                                continue;
                        }

                        if ( hit->touch == NULL ) 
                        {
                                continue;
                        }

                        if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) 
                        {
                                continue;
                        }


                        if ( !trap_EntityContact( mins, maxs, hit ) ) 
                        {
                                continue;
                        }

                        memset( &trace, 0, sizeof(trace) );

                        if ( hit->touch != NULL ) 
                        {
                                hit->touch(hit, ent, &trace);
                        }
                }
        }
}

/*
=================
SpectatorThink
=================
*/
void SpectatorThink( gentity_t *ent, usercmd_t *ucmd ) {
        pmove_t pm;
        gclient_t       *client;

        client = ent->client;

        if ( client->sess.spectatorState != SPECTATOR_FOLLOW ) {
                client->ps.pm_type = PM_SPECTATOR;
                client->ps.speed = 400; // faster than normal
                client->ps.basespeed = 400;

                //hmm, shouldn't have an anim if you're a spectator, make sure
                //it gets cleared.
                client->ps.legsAnim = 0;
                client->ps.legsTimer = 0;
                client->ps.torsoAnim = 0;
                client->ps.torsoTimer = 0;

                // set up for pmove
                memset (&pm, 0, sizeof(pm));
                pm.ps = &client->ps;
                pm.cmd = *ucmd;
                pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;       // spectators can fly through bodies
                pm.trace = trap_Trace;
                pm.pointcontents = trap_PointContents;

                pm.noSpecMove = g_noSpecMove.integer;

                pm.animations = NULL;
                pm.nonHumanoid = qfalse;

                //Set up bg entity data
                pm.baseEnt = (bgEntity_t *)g_entities;
                pm.entSize = sizeof(gentity_t);

                // perform a pmove
                Pmove (&pm);
                // save results of pmove
                VectorCopy( client->ps.origin, ent->s.origin );

                if (ent->client->tempSpectate < level.time)
                {
                        G_TouchTriggers( ent );
                }
                trap_UnlinkEntity( ent );
        }

        client->oldbuttons = client->buttons;
        client->buttons = ucmd->buttons;

        if (client->tempSpectate < level.time)
        {
                // attack button cycles through spectators
                if ( ( client->buttons & BUTTON_ATTACK ) && ! ( client->oldbuttons & BUTTON_ATTACK ) ) {
                        Cmd_FollowCycle_f( ent, 1 );
                }

                if (client->sess.spectatorState == SPECTATOR_FOLLOW && (ucmd->upmove > 0))
                { //jump now removes you from follow mode
                        StopFollowing(ent);
                }
        }
}



/*
=================
ClientInactivityTimer

Returns qfalse if the client is dropped
=================
*/
qboolean ClientInactivityTimer( gclient_t *client ) {
        if ( ! g_inactivity.integer ) {
                // give everyone some time, so if the operator sets g_inactivity during
                // gameplay, everyone isn't kicked
                client->inactivityTime = level.time + 60 * 1000;
                client->inactivityWarning = qfalse;
        } else if ( client->pers.cmd.forwardmove || 
                client->pers.cmd.rightmove || 
                client->pers.cmd.upmove ||
                (client->pers.cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) ) {
                client->inactivityTime = level.time + g_inactivity.integer * 1000;
                client->inactivityWarning = qfalse;
        } else if ( !client->pers.localClient ) {
                if ( level.time > client->inactivityTime ) {
                        trap_DropClient( client - level.clients, "Dropped due to inactivity" );
                        return qfalse;
                }
                if ( level.time > client->inactivityTime - 10000 && !client->inactivityWarning ) {
                        client->inactivityWarning = qtrue;
                        trap_SendServerCommand( client - level.clients, "cp \"Ten seconds until inactivity drop!\n\"" );
                }
        }
        return qtrue;
}

/*
==================
ClientTimerActions

Actions that happen once a second
==================
*/
void ClientTimerActions( gentity_t *ent, int msec ) {
        gclient_t       *client;

        client = ent->client;
        client->timeResidual += msec;

        while ( client->timeResidual >= 1000 ) 
        {
                client->timeResidual -= 1000;

                // count down health when over max
                if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] ) {
                        ent->health--;
                }

                // count down armor when over max
                if ( client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH] ) {
                        client->ps.stats[STAT_ARMOR]--;
                }
        }
}

/*
====================
ClientIntermissionThink
====================
*/
void ClientIntermissionThink( gclient_t *client ) {
        client->ps.eFlags &= ~EF_TALK;
        client->ps.eFlags &= ~EF_FIRING;

        // the level will exit when everyone wants to or after timeouts

        // swap and latch button actions
        client->oldbuttons = client->buttons;
        client->buttons = client->pers.cmd.buttons;
        if ( client->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) & ( client->oldbuttons ^ client->buttons ) ) {
                // this used to be an ^1 but once a player says ready, it should stick
                client->readyToExit = 1;
        }
}

extern void NPC_SetAnim(gentity_t       *ent,int setAnimParts,int anim,int setAnimFlags);
void G_VehicleAttachDroidUnit( gentity_t *vehEnt )
{
        if ( vehEnt && vehEnt->m_pVehicle && vehEnt->m_pVehicle->m_pDroidUnit != NULL )
        {
                gentity_t *droidEnt = (gentity_t *)vehEnt->m_pVehicle->m_pDroidUnit;
                mdxaBone_t boltMatrix;
                vec3_t  fwd;

                trap_G2API_GetBoltMatrix(vehEnt->ghoul2, 0, vehEnt->m_pVehicle->m_iDroidUnitTag, &boltMatrix, vehEnt->r.currentAngles, vehEnt->r.currentOrigin, level.time,
                        NULL, vehEnt->modelScale);
                BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, droidEnt->r.currentOrigin);
                BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, fwd);
                vectoangles( fwd, droidEnt->r.currentAngles );
                
                if ( droidEnt->client )
                {
                        VectorCopy( droidEnt->r.currentAngles, droidEnt->client->ps.viewangles );
                        VectorCopy( droidEnt->r.currentOrigin, droidEnt->client->ps.origin );
                }

                G_SetOrigin( droidEnt, droidEnt->r.currentOrigin );
                trap_LinkEntity( droidEnt );
                
                if ( droidEnt->NPC )
                {
                        NPC_SetAnim( droidEnt, SETANIM_BOTH, BOTH_STAND2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
                }
        }
}

//called gameside only from pmove code (convenience)
void G_CheapWeaponFire(int entNum, int ev)
{
        gentity_t *ent = &g_entities[entNum];
        
        if (!ent->inuse || !ent->client)
        {
                return;
        }

        switch (ev)
        {
                case EV_FIRE_WEAPON:
                        if (ent->m_pVehicle && ent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER &&
                                ent->client && ent->client->ps.m_iVehicleNum)
                        { //a speeder with a pilot
                                gentity_t *rider = &g_entities[ent->client->ps.m_iVehicleNum-1];
                                if (rider->inuse && rider->client)
                                { //pilot is valid...
                    if (rider->client->ps.weapon != WP_MELEE &&
                                                (rider->client->ps.weapon != WP_SABER || !rider->client->ps.saberHolstered))
                                        { //can only attack on speeder when using melee or when saber is holstered
                                                break;
                                        }
                                }
                        }

                        FireWeapon( ent, qfalse );
                        ent->client->dangerTime = level.time;
                        ent->client->ps.eFlags &= ~EF_INVULNERABLE;
                        ent->client->invulnerableTimer = 0;
                        break;
                case EV_ALT_FIRE:
                        FireWeapon( ent, qtrue );
                        ent->client->dangerTime = level.time;
                        ent->client->ps.eFlags &= ~EF_INVULNERABLE;
                        ent->client->invulnerableTimer = 0;
                        break;
        }
}

/*
================
ClientEvents

Events will be passed on to the clients for presentation,
but any server game effects are handled here
================
*/
#include "../namespace_begin.h"
qboolean BG_InKnockDownOnly( int anim );
#include "../namespace_end.h"

void ClientEvents( gentity_t *ent, int oldEventSequence ) {
        int             i;//, j;
        int             event;
        gclient_t *client;
        int             damage;
        vec3_t  dir;
//      vec3_t  origin, angles;
//      qboolean        fired;
//      gitem_t *item;
//      gentity_t *drop;

        client = ent->client;

        if ( oldEventSequence < client->ps.eventSequence - MAX_PS_EVENTS ) {
                oldEventSequence = client->ps.eventSequence - MAX_PS_EVENTS;
        }
        for ( i = oldEventSequence ; i < client->ps.eventSequence ; i++ ) {
                event = client->ps.events[ i & (MAX_PS_EVENTS-1) ];

                switch ( event ) {
                case EV_FALL:
                case EV_ROLL:
                        {
                                int delta = client->ps.eventParms[ i & (MAX_PS_EVENTS-1) ];
                                qboolean knockDownage = qfalse;

                                if (ent->client && ent->client->ps.fallingToDeath)
                                {
                                        break;
                                }

                                if ( ent->s.eType != ET_PLAYER )
                                {
                                        break;          // not in the player model
                                }
                                
                                if ( g_dmflags.integer & DF_NO_FALLING )
                                {
                                        break;
                                }

                                if (BG_InKnockDownOnly(ent->client->ps.legsAnim))
                                {
                                        if (delta <= 14)
                                        {
                                                break;
                                        }
                                        knockDownage = qtrue;
                                }
                                else
                                {
                                        if (delta <= 44)
                                        {
                                                break;
                                        }
                                }

                                if (knockDownage)
                                {
                                        damage = delta*1; //you suffer for falling unprepared. A lot. Makes throws and things useful, and more realistic I suppose.
                                }
                                else
                                {
                                        if (g_gametype.integer == GT_SIEGE &&
                                                delta > 60)
                                        { //longer falls hurt more
                                                damage = delta*1; //good enough for now, I guess
                                        }
                                        else
                                        {
                                                damage = delta*0.16; //good enough for now, I guess
                                        }
                                }

                                VectorSet (dir, 0, 0, 1);
                                ent->pain_debounce_time = level.time + 200;     // no normal pain sound
                                G_Damage (ent, NULL, NULL, NULL, NULL, damage, DAMAGE_NO_ARMOR, MOD_FALLING);

                                if (ent->health < 1)
                                {
                                        G_Sound(ent, CHAN_AUTO, G_SoundIndex( "sound/player/fallsplat.wav" ));
                                }
                        }
                        break;
                case EV_FIRE_WEAPON:
                        FireWeapon( ent, qfalse );
                        ent->client->dangerTime = level.time;
                        ent->client->ps.eFlags &= ~EF_INVULNERABLE;
                        ent->client->invulnerableTimer = 0;
                        break;

                case EV_ALT_FIRE:
                        FireWeapon( ent, qtrue );
                        ent->client->dangerTime = level.time;
                        ent->client->ps.eFlags &= ~EF_INVULNERABLE;
                        ent->client->invulnerableTimer = 0;
                        break;

                case EV_SABER_ATTACK:
                        ent->client->dangerTime = level.time;
                        ent->client->ps.eFlags &= ~EF_INVULNERABLE;
                        ent->client->invulnerableTimer = 0;
                        break;

                //rww - Note that these must be in the same order (ITEM#-wise) as they are in holdable_t
                case EV_USE_ITEM1: //seeker droid
                        ItemUse_Seeker(ent);
                        break;
                case EV_USE_ITEM2: //shield
                        ItemUse_Shield(ent);
                        break;
                case EV_USE_ITEM3: //medpack
                        ItemUse_MedPack(ent);
                        break;
                case EV_USE_ITEM4: //big medpack
                        ItemUse_MedPack_Big(ent);
                        break;
                case EV_USE_ITEM5: //binoculars
                        ItemUse_Binoculars(ent);
                        break;
                case EV_USE_ITEM6: //sentry gun
                        ItemUse_Sentry(ent);
                        break;
                case EV_USE_ITEM7: //jetpack
                        ItemUse_Jetpack(ent);
                        break;
                case EV_USE_ITEM8: //health disp
                        //ItemUse_UseDisp(ent, HI_HEALTHDISP);
                        break;
                case EV_USE_ITEM9: //ammo disp
                        //ItemUse_UseDisp(ent, HI_AMMODISP);
                        break;
                case EV_USE_ITEM10: //eweb
                        ItemUse_UseEWeb(ent);
                        break;
                case EV_USE_ITEM11: //cloak
                        ItemUse_UseCloak(ent);
                        break;
                default:
                        break;
                }
        }

}

/*
==============
SendPendingPredictableEvents
==============
*/
void SendPendingPredictableEvents( playerState_t *ps ) {
        gentity_t *t;
        int event, seq;
        int extEvent, number;

        // if there are still events pending
        if ( ps->entityEventSequence < ps->eventSequence ) {
                // create a temporary entity for this event which is sent to everyone
                // except the client who generated the event
                seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
                event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
                // set external event to zero before calling BG_PlayerStateToEntityState
                extEvent = ps->externalEvent;
                ps->externalEvent = 0;
                // create temporary entity for event
                t = G_TempEntity( ps->origin, event );
                number = t->s.number;
                BG_PlayerStateToEntityState( ps, &t->s, qtrue );
                t->s.number = number;
                t->s.eType = ET_EVENTS + event;
                t->s.eFlags |= EF_PLAYER_EVENT;
                t->s.otherEntityNum = ps->clientNum;
                // send to everyone except the client who generated the event
                t->r.svFlags |= SVF_NOTSINGLECLIENT;
                t->r.singleClient = ps->clientNum;
                // set back external event
                ps->externalEvent = extEvent;
        }
}

/*
==================
G_UpdateClientBroadcasts

Determines whether this client should be broadcast to any other clients.  
A client is broadcast when another client is using force sight or is
==================
*/
#define MAX_JEDIMASTER_DISTANCE 2500
#define MAX_JEDIMASTER_FOV              100

#define MAX_SIGHT_DISTANCE              1500
#define MAX_SIGHT_FOV                   100

static void G_UpdateForceSightBroadcasts ( gentity_t *self )
{
        int i;

        // Any clients with force sight on should see this client
        for ( i = 0; i < level.numConnectedClients; i ++ )
        {
                gentity_t *ent = &g_entities[level.sortedClients[i]];
                float     dist;
                vec3_t    angles;
        
                if ( ent == self )
                {
                        continue;
                }

                // Not using force sight so we shouldnt broadcast to this one
                if ( !(ent->client->ps.fd.forcePowersActive & (1<<FP_SEE) ) )
                {
                        continue;
                }

                VectorSubtract( self->client->ps.origin, ent->client->ps.origin, angles );
                dist = VectorLengthSquared ( angles );
                vectoangles ( angles, angles );

                // Too far away then just forget it
                if ( dist > MAX_SIGHT_DISTANCE * MAX_SIGHT_DISTANCE )
                {
                        continue;
                }
                
                // If not within the field of view then forget it
                if ( !InFieldOfVision ( ent->client->ps.viewangles, MAX_SIGHT_FOV, angles ) )
                {
                        break;
                }

                // Turn on the broadcast bit for the master and since there is only one
                // master we are done
                self->r.broadcastClients[ent->s.clientNum/32] |= (1 << (ent->