codemp/game/g_mover.c

Go to the documentation of this file.

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

#include "g_local.h"



/*
===============================================================================

PUSHMOVE

===============================================================================
*/

void MatchTeam( gentity_t *teamLeader, int moverState, int time );

typedef struct {
        gentity_t       *ent;
        vec3_t  origin;
        vec3_t  angles;
        float   deltayaw;
} pushed_t;
pushed_t        pushed[MAX_GENTITIES], *pushed_p;

#define MOVER_START_ON          1
#define MOVER_FORCE_ACTIVATE    2
#define MOVER_CRUSHER           4
#define MOVER_TOGGLE            8
#define MOVER_LOCKED            16
#define MOVER_GOODIE            32
#define MOVER_PLAYER_USE        64
#define MOVER_INACTIVE          128

int     BMS_START = 0;
int     BMS_MID = 1;
int     BMS_END = 2;

/*
-------------------------
G_PlayDoorLoopSound
-------------------------
*/

void G_PlayDoorLoopSound( gentity_t *ent )
{
        if (!ent->soundSet || !ent->soundSet[0])
        {
                return;
        }

        ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
        ent->s.loopIsSoundset = qtrue;
        ent->s.loopSound = BMS_MID;
        /*
        ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
        ent->loopingOnClient = qtrue;
        G_AddEvent(ent, EV_PLAYDOORLOOPSOUND, 0);
        */
}

/*
-------------------------
G_PlayDoorSound
-------------------------
*/

void G_PlayDoorSound( gentity_t *ent, int type )
{
        if (!ent->soundSet || !ent->soundSet[0])
        {
                return;
        }

        ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);

        G_AddEvent(ent, EV_PLAYDOORSOUND, type);
}

/*
============
G_TestEntityPosition

============
*/
gentity_t       *G_TestEntityPosition( gentity_t *ent ) {
        trace_t tr;
        int             mask;

        if ( ent->clipmask ) {
                mask = ent->clipmask;
        } else {
                mask = MASK_SOLID;
        }
        if ( ent->client ) {
                vec3_t vMax;
                VectorCopy(ent->r.maxs, vMax);
                if (vMax[2] < 1)
                {
                        vMax[2] = 1;
                }
                trap_Trace( &tr, ent->client->ps.origin, ent->r.mins, vMax, ent->client->ps.origin, ent->s.number, mask );
        } else {
                trap_Trace( &tr, ent->s.pos.trBase, ent->r.mins, ent->r.maxs, ent->s.pos.trBase, ent->s.number, mask );
        }
        
        if (tr.startsolid)
                return &g_entities[ tr.entityNum ];
                
        return NULL;
}

/*
================
G_CreateRotationMatrix
================
*/
void G_CreateRotationMatrix(vec3_t angles, vec3_t matrix[3]) {
        AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
        VectorInverse(matrix[1]);
}

/*
================
G_TransposeMatrix
================
*/
void G_TransposeMatrix(vec3_t matrix[3], vec3_t transpose[3]) {
        int i, j;
        for (i = 0; i < 3; i++) {
                for (j = 0; j < 3; j++) {
                        transpose[i][j] = matrix[j][i];
                }
        }
}

/*
================
G_RotatePoint
================
*/
void G_RotatePoint(vec3_t point, vec3_t matrix[3]) {
        vec3_t tvec;

        VectorCopy(point, tvec);
        point[0] = DotProduct(matrix[0], tvec);
        point[1] = DotProduct(matrix[1], tvec);
        point[2] = DotProduct(matrix[2], tvec);
}

/*
==================
G_TryPushingEntity

Returns qfalse if the move is blocked
==================
*/
qboolean        G_TryPushingEntity( gentity_t *check, gentity_t *pusher, vec3_t move, vec3_t amove ) {
        vec3_t          matrix[3], transpose[3];
        vec3_t          org, org2, move2;
        gentity_t       *block;

        //This was only serverside not to mention it was never set.
        /*
        // EF_MOVER_STOP will just stop when contacting another entity
        // instead of pushing it, but entities can still ride on top of it
        if ( ( pusher->s.eFlags & EF_MOVER_STOP ) && 
                check->s.groundEntityNum != pusher->s.number ) {
                return qfalse;
        }
        */
        if ( pusher->s.apos.trType != TR_STATIONARY//rotating
                && (pusher->spawnflags&16) //IMPACT
                && Q_stricmp( "func_rotating", pusher->classname ) == 0 )
        {//just blow the fuck out of them
                G_Damage( check, pusher, pusher, NULL, NULL, pusher->damage, DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
                return qtrue;
        }

        // save off the old position
        if (pushed_p > &pushed[MAX_GENTITIES]) {
                G_Error( "pushed_p > &pushed[MAX_GENTITIES]" );
        }
        pushed_p->ent = check;
        VectorCopy (check->s.pos.trBase, pushed_p->origin);
        VectorCopy (check->s.apos.trBase, pushed_p->angles);
        if ( check->client ) {
                pushed_p->deltayaw = check->client->ps.delta_angles[YAW];
                VectorCopy (check->client->ps.origin, pushed_p->origin);
        }
        pushed_p++;

        // try moving the contacted entity 
        // figure movement due to the pusher's amove
        G_CreateRotationMatrix( amove, transpose );
        G_TransposeMatrix( transpose, matrix );
        if ( check->client ) {
                VectorSubtract (check->client->ps.origin, pusher->r.currentOrigin, org);
        }
        else {
                VectorSubtract (check->s.pos.trBase, pusher->r.currentOrigin, org);
        }
        VectorCopy( org, org2 );
        G_RotatePoint( org2, matrix );
        VectorSubtract (org2, org, move2);
        // add movement
        VectorAdd (check->s.pos.trBase, move, check->s.pos.trBase);
        VectorAdd (check->s.pos.trBase, move2, check->s.pos.trBase);
        if ( check->client ) {
                VectorAdd (check->client->ps.origin, move, check->client->ps.origin);
                VectorAdd (check->client->ps.origin, move2, check->client->ps.origin);
                // make sure the client's view rotates when on a rotating mover
                check->client->ps.delta_angles[YAW] += ANGLE2SHORT(amove[YAW]);
        }

        // may have pushed them off an edge
        if ( check->s.groundEntityNum != pusher->s.number ) {
                check->s.groundEntityNum = ENTITYNUM_NONE;//-1;
        }

        block = G_TestEntityPosition( check );
        if (!block) {
                // pushed ok
                if ( check->client ) {
                        VectorCopy( check->client->ps.origin, check->r.currentOrigin );
                } else {
                        VectorCopy( check->s.pos.trBase, check->r.currentOrigin );
                }
                trap_LinkEntity (check);
                return qtrue;
        }

        if (check->takedamage && !check->client && check->s.weapon && check->r.ownerNum < MAX_CLIENTS &&
                check->health < 500)
        {
                if (check->health > 0)
                {
                        G_Damage(check, pusher, pusher, vec3_origin, check->r.currentOrigin, 999, 0, MOD_UNKNOWN);
                }
                return qfalse;
        }
        // if it is ok to leave in the old position, do it
        // this is only relevent for riding entities, not pushed
        // Sliding trapdoors can cause this.
        VectorCopy( (pushed_p-1)->origin, check->s.pos.trBase);
        if ( check->client ) {
                VectorCopy( (pushed_p-1)->origin, check->client->ps.origin);
        }
        VectorCopy( (pushed_p-1)->angles, check->s.apos.trBase );
        block = G_TestEntityPosition (check);
        if ( !block ) {
                check->s.groundEntityNum = -1;
                pushed_p--;
                return qtrue;
        }

        // blocked
        return qfalse;
}


void G_ExplodeMissile( gentity_t *ent );

/*
============
G_MoverPush

Objects need to be moved back on a failed push,
otherwise riders would continue to slide.
If qfalse is returned, *obstacle will be the blocking entity
============
*/
qboolean G_MoverPush( gentity_t *pusher, vec3_t move, vec3_t amove, gentity_t **obstacle ) {
        int                     i, e;
        gentity_t       *check;
        vec3_t          mins, maxs;
        pushed_t        *p;
        int                     entityList[MAX_GENTITIES];
        int                     listedEntities;
        vec3_t          totalMins, totalMaxs;

        *obstacle = NULL;


        // mins/maxs are the bounds at the destination
        // totalMins / totalMaxs are the bounds for the entire move
        if ( pusher->r.currentAngles[0] || pusher->r.currentAngles[1] || pusher->r.currentAngles[2]
                || amove[0] || amove[1] || amove[2] ) {
                float           radius;

                radius = RadiusFromBounds( pusher->r.mins, pusher->r.maxs );
                for ( i = 0 ; i < 3 ; i++ ) {
                        mins[i] = pusher->r.currentOrigin[i] + move[i] - radius;
                        maxs[i] = pusher->r.currentOrigin[i] + move[i] + radius;
                        totalMins[i] = mins[i] - move[i];
                        totalMaxs[i] = maxs[i] - move[i];
                }
        } else {
                for (i=0 ; i<3 ; i++) {
                        mins[i] = pusher->r.absmin[i] + move[i];
                        maxs[i] = pusher->r.absmax[i] + move[i];
                }

                VectorCopy( pusher->r.absmin, totalMins );
                VectorCopy( pusher->r.absmax, totalMaxs );
                for (i=0 ; i<3 ; i++) {
                        if ( move[i] > 0 ) {
                                totalMaxs[i] += move[i];
                        } else {
                                totalMins[i] += move[i];
                        }
                }
        }

        // unlink the pusher so we don't get it in the entityList
        trap_UnlinkEntity( pusher );

        listedEntities = trap_EntitiesInBox( totalMins, totalMaxs, entityList, MAX_GENTITIES );

        // move the pusher to it's final position
        VectorAdd( pusher->r.currentOrigin, move, pusher->r.currentOrigin );
        VectorAdd( pusher->r.currentAngles, amove, pusher->r.currentAngles );
        trap_LinkEntity( pusher );

        // see if any solid entities are inside the final position
        for ( e = 0 ; e < listedEntities ; e++ ) {
                check = &g_entities[ entityList[ e ] ];

                // only push items and players
                if ( /*check->s.eType != ET_ITEM &&*/ check->s.eType != ET_PLAYER && check->s.eType != ET_NPC && !check->physicsObject ) {
                        continue;
                }

                // if the entity is standing on the pusher, it will definitely be moved
                if ( check->s.groundEntityNum != pusher->s.number ) {
                        // see if the ent needs to be tested
                        if ( check->r.absmin[0] >= maxs[0]
                        || check->r.absmin[1] >= maxs[1]
                        || check->r.absmin[2] >= maxs[2]
                        || check->r.absmax[0] <= mins[0]
                        || check->r.absmax[1] <= mins[1]
                        || check->r.absmax[2] <= mins[2] ) {
                                continue;
                        }
                        // see if the ent's bbox is inside the pusher's final position
                        // this does allow a fast moving object to pass through a thin entity...
                        if (!G_TestEntityPosition (check)) {
                                continue;
                        }
                }

                // the entity needs to be pushed
                if ( G_TryPushingEntity( check, pusher, move, amove ) ) {
                        continue;
                }

                if (pusher->damage && check->client && (pusher->spawnflags & 32))
                {
                        G_Damage( check, pusher, pusher, NULL, NULL, pusher->damage, 0, MOD_CRUSH );
                        continue;
                }

                if (check->s.eType == ET_BODY ||
                        (check->s.eType == ET_PLAYER && check->health < 1))
                { //whatever, just crush it
                        G_Damage( check, pusher, pusher, NULL, NULL, 999, 0, MOD_CRUSH );
                        continue;
                }

                // the move was blocked an entity

                // bobbing entities are instant-kill and never get blocked
                if ( pusher->s.pos.trType == TR_SINE || pusher->s.apos.trType == TR_SINE ) {
                        G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
                        continue;
                }

                
                // save off the obstacle so we can call the block function (crush, etc)
                *obstacle = check;

                // move back any entities we already moved
                // go backwards, so if the same entity was pushed
                // twice, it goes back to the original position
                for ( p=pushed_p-1 ; p>=pushed ; p-- ) {
                        VectorCopy (p->origin, p->ent->s.pos.trBase);
                        VectorCopy (p->angles, p->ent->s.apos.trBase);
                        if ( p->ent->client ) {
                                p->ent->client->ps.delta_angles[YAW] = p->deltayaw;
                                VectorCopy (p->origin, p->ent->client->ps.origin);
                        }
                        trap_LinkEntity (p->ent);
                }
                return qfalse;
        }

        return qtrue;
}


/*
=================
G_MoverTeam
=================
*/
void G_MoverTeam( gentity_t *ent ) {
        vec3_t          move, amove;
        gentity_t       *part, *obstacle;
        vec3_t          origin, angles;

        obstacle = NULL;

        // make sure all team slaves can move before commiting
        // any moves or calling any think functions
        // if the move is blocked, all moved objects will be backed out
        pushed_p = pushed;
        for (part = ent ; part ; part=part->teamchain) {
                // get current position
                BG_EvaluateTrajectory( &part->s.pos, level.time, origin );
                BG_EvaluateTrajectory( &part->s.apos, level.time, angles );
                VectorSubtract( origin, part->r.currentOrigin, move );
                VectorSubtract( angles, part->r.currentAngles, amove );
                if ( !VectorCompare( move, vec3_origin )
                        || !VectorCompare( amove, vec3_origin ) )
                {//actually moved
                        if ( !G_MoverPush( part, move, amove, &obstacle ) ) {
                                break;  // move was blocked
                        }
                }
        }

        if (part) {
                // go back to the previous position
                for ( part = ent ; part ; part = part->teamchain ) {
                        part->s.pos.trTime += level.time - level.previousTime;
                        part->s.apos.trTime += level.time - level.previousTime;
                        BG_EvaluateTrajectory( &part->s.pos, level.time, part->r.currentOrigin );
                        BG_EvaluateTrajectory( &part->s.apos, level.time, part->r.currentAngles );
                        trap_LinkEntity( part );
                }

                // if the pusher has a "blocked" function, call it
                if (ent->blocked) {
                        ent->blocked( ent, obstacle );
                }
                return;
        }

        // the move succeeded
        for ( part = ent ; part ; part = part->teamchain ) {
                // call the reached function if time is at or past end point
                if ( part->s.pos.trType == TR_LINEAR_STOP ||
                        part->s.pos.trType == TR_NONLINEAR_STOP) {
                        if ( level.time >= part->s.pos.trTime + part->s.pos.trDuration ) {
                                if ( part->reached ) {
                                        part->reached( part );
                                }
                        }
                }
        }
}

/*
================
G_RunMover

================
*/
void G_RunMover( gentity_t *ent ) {
        // if not a team captain, don't do anything, because
        // the captain will handle everything
        if ( ent->flags & FL_TEAMSLAVE ) {
                return;
        }

        // if stationary at one of the positions, don't move anything
        if ( ent->s.pos.trType != TR_STATIONARY || ent->s.apos.trType != TR_STATIONARY ) {
                G_MoverTeam( ent );
        }

        // check think function
        G_RunThink( ent );
}

/*
============================================================================

GENERAL MOVERS

Doors, plats, and buttons are all binary (two position) movers
Pos1 is "at rest", pos2 is "activated"
============================================================================
*/

/*
CalcTeamDoorCenter

Finds all the doors of a team and returns their center position
*/

void CalcTeamDoorCenter ( gentity_t *ent, vec3_t center ) 
{
        vec3_t          slavecenter;
        gentity_t       *slave;

        //Start with our center
        VectorAdd(ent->r.mins, ent->r.maxs, center);
        VectorScale(center, 0.5, center);
        for ( slave = ent->teamchain ; slave ; slave = slave->teamchain ) 
        {
                //Find slave's center
                VectorAdd(slave->r.mins, slave->r.maxs, slavecenter);
                VectorScale(slavecenter, 0.5, slavecenter);
                //Add that to our own, find middle
                VectorAdd(center, slavecenter, center);
                VectorScale(center, 0.5, center);
        }
}

/*
===============
SetMoverState
===============
*/
void SetMoverState( gentity_t *ent, moverState_t moverState, int time ) {
        vec3_t                  delta;
        float                   f;

        ent->moverState = moverState;

        ent->s.pos.trTime = time;

        if ( ent->s.pos.trDuration <= 0 )
        {//Don't allow divide by zero!
                ent->s.pos.trDuration = 1;
        }

        switch( moverState ) {
        case MOVER_POS1:
                VectorCopy( ent->pos1, ent->s.pos.trBase );
                ent->s.pos.trType = TR_STATIONARY;
                break;
        case MOVER_POS2:
                VectorCopy( ent->pos2, ent->s.pos.trBase );
                ent->s.pos.trType = TR_STATIONARY;
                break;
        case MOVER_1TO2:
                VectorCopy( ent->pos1, ent->s.pos.trBase );
                VectorSubtract( ent->pos2, ent->pos1, delta );
                f = 1000.0 / ent->s.pos.trDuration;
                VectorScale( delta, f, ent->s.pos.trDelta );
                if ( ent->alt_fire )
                {
                        ent->s.pos.trType = TR_LINEAR_STOP;
                }
                else
                {
                        ent->s.pos.trType = TR_NONLINEAR_STOP;
                }
                //ent->s.eFlags &= ~EF_BLOCKED_MOVER;
                break;
        case MOVER_2TO1:
                VectorCopy( ent->pos2, ent->s.pos.trBase );
                VectorSubtract( ent->pos1, ent->pos2, delta );
                f = 1000.0 / ent->s.pos.trDuration;
                VectorScale( delta, f, ent->s.pos.trDelta );
                if ( ent->alt_fire )
                {
                        ent->s.pos.trType = TR_LINEAR_STOP;
                }
                else
                {
                        ent->s.pos.trType = TR_NONLINEAR_STOP;
                }
                //ent->s.eFlags &= ~EF_BLOCKED_MOVER;
                break;
        }
        BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->r.currentOrigin ); 
        trap_LinkEntity( ent );
}

/*
================
MatchTeam

All entities in a mover team will move from pos1 to pos2
in the same amount of time
================
*/
void MatchTeam( gentity_t *teamLeader, int moverState, int time ) {
        gentity_t               *slave;

        for ( slave = teamLeader ; slave ; slave = slave->teamchain ) {
                SetMoverState( slave, (moverState_t) moverState, time );
        }
}



/*
================
ReturnToPos1
================
*/
void ReturnToPos1( gentity_t *ent ) {
        ent->think = 0;
        ent->nextthink = 0;
        ent->s.time = level.time;

        MatchTeam( ent, MOVER_2TO1, level.time );

        // starting sound
        G_PlayDoorLoopSound( ent );
        G_PlayDoorSound( ent, BMS_START );      //??
}


/*
================
Reached_BinaryMover
================
*/

void Reached_BinaryMover( gentity_t *ent ) 
{
        // stop the looping sound
        ent->s.loopSound = 0;
        ent->s.loopIsSoundset = qfalse;

        if ( ent->moverState == MOVER_1TO2 ) 
        {//reached open
                vec3_t  doorcenter;

                // reached pos2
                SetMoverState( ent, MOVER_POS2, level.time );

                CalcTeamDoorCenter( ent, doorcenter );

                // play sound
                G_PlayDoorSound( ent, BMS_END );

                if ( ent->wait < 0 )
                {//Done for good
                        ent->think = 0;
                        ent->nextthink = 0;
                        ent->use = 0;
                }
                else
                {
                        // return to pos1 after a delay
                        ent->think = ReturnToPos1;
                        if(ent->spawnflags & 8)
                        {//Toggle, keep think, wait for next use?
                                ent->nextthink = -1;
                        }
                        else
                        {
                                ent->nextthink = level.time + ent->wait;
                        }
                }

                // fire targets
                if ( !ent->activator ) 
                {
                        ent->activator = ent;
                }
                G_UseTargets2( ent, ent->activator, ent->opentarget );
        } 
        else if ( ent->moverState == MOVER_2TO1 ) 
        {//closed
                vec3_t  doorcenter;

                // reached pos1
                SetMoverState( ent, MOVER_POS1, level.time );

                CalcTeamDoorCenter( ent, doorcenter );

                // play sound
                G_PlayDoorSound( ent, BMS_END );

                // close areaportals
                if ( ent->teammaster == ent || !ent->teammaster ) 
                {
                        trap_AdjustAreaPortalState( ent, qfalse );
                }
                G_UseTargets2( ent, ent->activator, ent->closetarget );
        } 
        else 
        {
                G_Error( "Reached_BinaryMover: bad moverState" );
        }
}


/*
================
Use_BinaryMover_Go
================
*/
void Use_BinaryMover_Go( gentity_t *ent ) 
{
        int             total;
        int             partial;
//      gentity_t       *other = ent->enemy;
        gentity_t       *activator = ent->activator; 

        ent->activator = activator;

        if ( ent->moverState == MOVER_POS1 ) 
        {
                vec3_t  doorcenter;

                // start moving 50 msec later, becase if this was player
                // triggered, level.time hasn't been advanced yet
                MatchTeam( ent, MOVER_1TO2, level.time + 50 );

                CalcTeamDoorCenter( ent, doorcenter );

                // starting sound
                G_PlayDoorLoopSound( ent );
                G_PlayDoorSound( ent, BMS_START );
                ent->s.time = level.time;

                // open areaportal
                if ( ent->teammaster == ent || !ent->teammaster ) {
                        trap_AdjustAreaPortalState( ent, qtrue );
                }
                G_UseTargets( ent, ent->activator );
                return;
        }

        // if all the way up, just delay before coming down
        if ( ent->moverState == MOVER_POS2 ) {
                //have to do this because the delay sets our think to Use_BinaryMover_Go
                ent->think = ReturnToPos1;
                if ( ent->spawnflags & 8 )
                {//TOGGLE doors don't use wait!
                        ent->nextthink = level.time + FRAMETIME;
                }
                else
                {
                        ent->nextthink = level.time + ent->wait;
                }
                G_UseTargets2( ent, ent->activator, ent->target2 );
                return;
        }

        // only partway down before reversing
        if ( ent->moverState == MOVER_2TO1 ) 
        {
                if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
                {
                        vec3_t curDelta;
                        float fPartial;
                        total = ent->s.pos.trDuration-50;
                        VectorSubtract( ent->r.currentOrigin, ent->pos1, curDelta );
                        fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
                        VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
                        fPartial /= ent->s.pos.trDuration;
                        fPartial /= 0.001f;
                        fPartial = acos( fPartial );
                        fPartial = RAD2DEG( fPartial );
                        fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
                        partial = total - floor( fPartial );
                }
                else
                {
                        total = ent->s.pos.trDuration;
                        partial = level.time - ent->s.pos.trTime;
                }

                if ( partial > total ) {
                        partial = total;
                }
                ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;

                MatchTeam( ent, MOVER_1TO2, ent->s.pos.trTime );

                G_PlayDoorSound( ent, BMS_START );

                return;
        }

        // only partway up before reversing
        if ( ent->moverState == MOVER_1TO2 ) 
        {
                if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
                {
                        vec3_t curDelta;
                        float fPartial;
                        total = ent->s.pos.trDuration-50;
                        VectorSubtract( ent->r.currentOrigin, ent->pos2, curDelta );
                        fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
                        VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
                        fPartial /= ent->s.pos.trDuration;
                        fPartial /= 0.001f;
                        fPartial = acos( fPartial );
                        fPartial = RAD2DEG( fPartial );
                        fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
                        partial = total - floor( fPartial );
                }
                else
                {
                        total = ent->s.pos.trDuration;
                        partial = level.time - ent->s.pos.trTime;
                }
                if ( partial > total ) {
                        partial = total;
                }

                ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;
                MatchTeam( ent, MOVER_2TO1, ent->s.pos.trTime );

                G_PlayDoorSound( ent, BMS_START );

                return;
        }
}

void UnLockDoors(gentity_t *const ent)
{
        //noise?
        //go through and unlock the door and all the slaves
        gentity_t       *slave = ent;
        do 
        {       // want to allow locked toggle doors, so keep the targetname
                if( !(slave->spawnflags & MOVER_TOGGLE) )
                {
                        slave->targetname = NULL;//not usable ever again
                }
                slave->spawnflags &= ~MOVER_LOCKED;
                slave->s.frame = 1;//second stage of anim
                slave = slave->teamchain;
        } while  ( slave );
}
void LockDoors(gentity_t *const ent)
{
        //noise?
        //go through and lock the door and all the slaves
        gentity_t       *slave = ent;
        do 
        {
                slave->spawnflags |= MOVER_LOCKED;
                slave->s.frame = 0;//first stage of anim
                slave = slave->teamchain;
        } while  ( slave );
}
/*
================
Use_BinaryMover
================
*/
void Use_BinaryMover( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
{
        if ( !ent->use )
        {//I cannot be used anymore, must be a door with a wait of -1 that's opened.
                return;
        }

        // only the master should be used
        if ( ent->flags & FL_TEAMSLAVE ) 
        {
                Use_BinaryMover( ent->teammaster, other, activator );
                return;
        }

        if ( ent->flags & FL_INACTIVE )
        {
                return;
        }

        if ( ent->spawnflags & MOVER_LOCKED )
        {//a locked door, unlock it
                UnLockDoors(ent);
                return;
        }

        G_ActivateBehavior(ent,BSET_USE);

        ent->enemy = other;
        ent->activator = activator;
        if(ent->delay)
        {
                ent->think = Use_BinaryMover_Go;
                ent->nextthink = level.time + ent->delay;
        }
        else
        {
                Use_BinaryMover_Go(ent);
        }
}



/*
================
InitMover

"pos1", "pos2", and "speed" should be set before calling,
so the movement delta can be calculated
================
*/
void InitMoverTrData( gentity_t *ent )
{
        vec3_t          move;
        float           distance;

        ent->s.pos.trType = TR_STATIONARY;
        VectorCopy( ent->pos1, ent->s.pos.trBase );

        // calculate time to reach second position from speed
        VectorSubtract( ent->pos2, ent->pos1, move );
        distance = VectorLength( move );
        if ( ! ent->speed ) 
        {
                ent->speed = 100;
        }
        VectorScale( move, ent->speed, ent->s.pos.trDelta );
        ent->s.pos.trDuration = distance * 1000 / ent->speed;
        if ( ent->s.pos.trDuration <= 0 ) 
        {
                ent->s.pos.trDuration = 1;
        }
}

void InitMover( gentity_t *ent ) 
{
        float           light;
        vec3_t          color;
        qboolean        lightSet, colorSet;

        // if the "model2" key is set, use a seperate model
        // for drawing, but clip against the brushes
        if ( ent->model2 ) 
        {
                if ( strstr( ent->model2, ".glm" ))
                { //for now, not supported in MP.
                        ent->s.modelindex2 = 0;
                }
                else
                {
                        ent->s.modelindex2 = G_ModelIndex( ent->model2 );
                }
        }

        // if the "color" or "light" keys are set, setup constantLight
        lightSet = G_SpawnFloat( "light", "100", &light );
        colorSet = G_SpawnVector( "color", "1 1 1", color );
        if ( lightSet || colorSet ) {
                int             r, g, b, i;

                r = color[0] * 255;
                if ( r > 255 ) {
                        r = 255;
                }
                g = color[1] * 255;
                if ( g > 255 ) {
                        g = 255;
                }
                b = color[2] * 255;
                if ( b > 255 ) {
                        b = 255;
                }
                i = light / 4;
                if ( i > 255 ) {
                        i = 255;
                }
                ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
        }

        ent->use = Use_BinaryMover;
        ent->reached = Reached_BinaryMover;

        ent->moverState = MOVER_POS1;
        ent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
        if ( ent->spawnflags & MOVER_INACTIVE )
        {// Make it inactive
                ent->flags |= FL_INACTIVE;      
        }
        if(ent->spawnflags & MOVER_PLAYER_USE)
        {//Can be used by the player's BUTTON_USE
                ent->r.svFlags |= SVF_PLAYER_USABLE;
        }
        ent->s.eType = ET_MOVER;
        VectorCopy( ent->pos1, ent->r.currentOrigin );
        trap_LinkEntity( ent );

        InitMoverTrData( ent );
}


/*
===============================================================================

DOOR

A use can be triggered either by a touch function, by being shot, or by being
targeted by another entity.

===============================================================================
*/

/*
================
Blocked_Door
================
*/
void Blocked_Door( gentity_t *ent, gentity_t *other )
{
        if ( ent->damage ) {
                G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
        }
        if ( ent->spawnflags & MOVER_CRUSHER ) {
                return;         // crushers don't reverse
        }

        // reverse direction
        Use_BinaryMover( ent, ent, other );
}


/*
================
Touch_DoorTriggerSpectator
================
*/
static void Touch_DoorTriggerSpectator( gentity_t *ent, gentity_t *other, trace_t *trace ) {
        int i, axis;
        trace_t tr;
        vec3_t pMins, pMaxs;
        vec3_t origin, dir, angles;

        axis = ent->count;
        VectorClear(dir);
        if (fabs(other->s.origin[axis] - ent->r.absmax[axis]) <
                fabs(other->s.origin[axis] - ent->r.absmin[axis])) {
                origin[axis] = ent->r.absmin[axis] - 10;
                dir[axis] = -1;
        }
        else {
                origin[axis] = ent->r.absmax[axis] + 10;
                dir[axis] = 1;
        }
        for (i = 0; i < 3; i++) {
                if (i == axis) continue;
                origin[i] = (ent->r.absmin[i] + ent->r.absmax[i]) * 0.5;
        }

        vectoangles(dir, angles);

        VectorSet(pMins, -15.0f, -15.0f, DEFAULT_MINS_2);
        VectorSet(pMaxs, 15.0f, 15.0f, DEFAULT_MAXS_2);
        trap_Trace(&tr, origin, pMins, pMaxs, origin, other->s.number, other->clipmask);
        if (!tr.startsolid &&
                !tr.allsolid &&
                tr.fraction == 1.0f &&
                tr.entityNum == ENTITYNUM_NONE)
        {
                TeleportPlayer(other, origin, angles );
        }
}

/*
================
Touch_DoorTrigger
================
*/
void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace ) 
{
        gentity_t *relockEnt = NULL;

        if ( other->client && other->client->sess.sessionTeam == TEAM_SPECTATOR ) 
        {
                // if the door is not open and not opening
                if ( ent->parent->moverState != MOVER_1TO2 &&
                        ent->parent->moverState != MOVER_POS2 ) 
                {
                        Touch_DoorTriggerSpectator( ent, other, trace );
                }
                return;
        }

        if (!ent->genericValue14 &&
                (!ent->parent || !ent->parent->genericValue14))
        {
                if (other->client && other->s.number >= MAX_CLIENTS &&
                        other->s.eType == ET_NPC && other->s.NPC_class == CLASS_VEHICLE)
                { //doors don't open for vehicles
                        return;
                }

                if (other->client && other->s.number < MAX_CLIENTS &&
                        other->client->ps.m_iVehicleNum)
                { //can't open a door while on a vehicle
                        return;
                }
        }

        if ( ent->flags & FL_INACTIVE )
        {
                return;
        }

        if ( ent->parent->spawnflags & MOVER_LOCKED )
        {//don't even try to use the door if it's locked 
                if ( !ent->parent->alliedTeam //we don't have a "teamallow" team
                        || !other->client //we do have a "teamallow" team, but this isn't a client
                        || other->client->sess.sessionTeam != ent->parent->alliedTeam )//it is a client, but it's not on the right team
                {
                        return;
                }
                else
                {//temporarily unlock us while we call Use_BinaryMover (so it doesn't unlock all the doors in this team)
                        if ( ent->parent->flags & FL_TEAMSLAVE ) 
                        {
                                relockEnt = ent->parent->teammaster;
                        }
                        else
                        {
                                relockEnt = ent->parent;
                        }
                        if ( relockEnt != NULL )
                        {
                                relockEnt->spawnflags &= ~MOVER_LOCKED;
                        }
                }
        }

        if ( ent->parent->moverState != MOVER_1TO2 ) 
        {//Door is not already opening
                //if ( ent->parent->moverState == MOVER_POS1 || ent->parent->moverState == MOVER_2TO1 )
                //{//only check these if closed or closing

                //If door is closed, opening or open, check this
                Use_BinaryMover( ent->parent, ent, other );
        }
        if ( relockEnt != NULL )
        {//re-lock us
                relockEnt->spawnflags |= MOVER_LOCKED;
        }

        /*
        //Old style
        if ( ent->parent->moverState != MOVER_1TO2 ) {
                Use_BinaryMover( ent->parent, ent, other );
        }
        */
}

/*
======================
Think_SpawnNewDoorTrigger

All of the parts of a door have been spawned, so create
a trigger that encloses all of them
======================
*/
void Think_SpawnNewDoorTrigger( gentity_t *ent ) 
{
        gentity_t               *other;
        vec3_t          mins, maxs;
        int                     i, best;

        // set all of the slaves as shootable
        if ( ent->takedamage ) 
        {
                for ( other = ent ; other ; other = other->teamchain ) 
                {
                        other->takedamage = qtrue;
                }
        }

        // find the bounds of everything on the team
        VectorCopy (ent->r.absmin, mins);
        VectorCopy (ent->r.absmax, maxs);

        for (other = ent->teamchain ; other ; other=other->teamchain) {
                AddPointToBounds (other->r.absmin, mins, maxs);
                AddPointToBounds (other->r.absmax, mins, maxs);
        }

        // find the thinnest axis, which will be the one we expand
        best = 0;
        for ( i = 1 ; i < 3 ; i++ ) {
                if ( maxs[i] - mins[i] < maxs[best] - mins[best] ) {
                        best = i;
                }
        }
        maxs[best] += 120;
        mins[best] -= 120;

        // create a trigger with this size
        other = G_Spawn ();
        VectorCopy (mins, other->r.mins);
        VectorCopy (maxs, other->r.maxs);
        other->parent = ent;
        other->r.contents = CONTENTS_TRIGGER;
        other->touch = Touch_DoorTrigger;
        trap_LinkEntity (other);
        other->classname = "trigger_door";
        // remember the thinnest axis
        other->count = best;

        MatchTeam( ent, ent->moverState, level.time );
}

void Think_MatchTeam( gentity_t *ent ) 
{
        MatchTeam( ent, ent->moverState, level.time );
}

qboolean G_EntIsDoor( int entityNum )
{
        gentity_t *ent;

        if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
        {
                return qfalse;
        }

        ent = &g_entities[entityNum];
        if ( ent && !Q_stricmp( "func_door", ent->classname ) )
        {//blocked by a door
                return qtrue;
        }
        return qfalse;
}

gentity_t *G_FindDoorTrigger( gentity_t *ent )
{
        gentity_t *owner = NULL;
        gentity_t *door = ent;
        if ( door->flags & FL_TEAMSLAVE )
        {//not the master door, get the master door
                while ( door->teammaster && (door->flags&FL_TEAMSLAVE))
                {
                        door = door->teammaster;
                }
        }
        if ( door->targetname )
        {//find out what is targeting it
                //FIXME: if ent->targetname, check what kind of trigger/ent is targetting it?  If a normal trigger (active, etc), then it's okay?
                while ( (owner = G_Find( owner, FOFS( target ), door->targetname )) != NULL )
                {
                        if ( owner && (owner->r.contents&CONTENTS_TRIGGER</