codemp/game/g_trigger.c

Go to the documentation of this file.

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

int gTrigFallSound;

void InitTrigger( gentity_t *self ) {
        if (!VectorCompare (self->s.angles, vec3_origin))
                G_SetMovedir (self->s.angles, self->movedir);

        trap_SetBrushModel( self, self->model );
        self->r.contents = CONTENTS_TRIGGER;            // replaces the -1 from trap_SetBrushModel
        self->r.svFlags = SVF_NOCLIENT;

        if(self->spawnflags & 128)
        {
                self->flags |= FL_INACTIVE;
        }
}

// the wait time has passed, so set back up for another activation
void multi_wait( gentity_t *ent ) {
        ent->nextthink = 0;
}

void trigger_cleared_fire (gentity_t *self);

// the trigger was just activated
// ent->activator should be set to the activator so it can be held through a delay
// so wait for the delay time before firing
void multi_trigger_run( gentity_t *ent ) 
{
        ent->think = 0;

        G_ActivateBehavior( ent, BSET_USE );

        if ( ent->soundSet && ent->soundSet[0] )
        {
                trap_SetConfigstring( CS_GLOBAL_AMBIENT_SET, ent->soundSet );
        }

        if (ent->genericValue4)
        { //we want to activate target3 for team1 or target4 for team2
                if (ent->genericValue4 == SIEGETEAM_TEAM1 &&
                        ent->target3 && ent->target3[0])
                {
                        G_UseTargets2(ent, ent->activator, ent->target3);
                }
                else if (ent->genericValue4 == SIEGETEAM_TEAM2 &&
                        ent->target4 && ent->target4[0])
                {
                        G_UseTargets2(ent, ent->activator, ent->target4);
                }

                ent->genericValue4 = 0;
        }

        G_UseTargets (ent, ent->activator);
        if ( ent->noise_index ) 
        {
                G_Sound( ent->activator, CHAN_AUTO, ent->noise_index );
        }

        if ( ent->target2 && ent->target2[0] && ent->wait >= 0 )
        {
                ent->think = trigger_cleared_fire;
                ent->nextthink = level.time + ent->speed;
        }
        else if ( ent->wait > 0 ) 
        {
                if ( ent->painDebounceTime != level.time )
                {//first ent to touch it this frame
                        //ent->e_ThinkFunc = thinkF_multi_wait;
                        ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000;
                        ent->painDebounceTime = level.time;
                }
        } 
        else if ( ent->wait < 0 )
        {
                // we can't just remove (self) here, because this is a touch function
                // called while looping through area links...
                ent->r.contents &= ~CONTENTS_TRIGGER;//so the EntityContact trace doesn't have to be done against me
                ent->think = 0;
                ent->use = 0;
                //Don't remove, Icarus may barf?
                //ent->nextthink = level.time + FRAMETIME;
                //ent->think = G_FreeEntity;
        }
        if( ent->activator && ent->activator->client )
        {       // mark the trigger as being touched by the player
                ent->aimDebounceTime = level.time;
        }
}

//determine if the class given is listed in the string using the | formatting
qboolean G_NameInTriggerClassList(char *list, char *str)
{
        char cmp[MAX_STRING_CHARS];
        int i = 0;
        int j;

        while (list[i])
        {
        j = 0;
        while (list[i] && list[i] != '|')
                {
                        cmp[j] = list[i];
                        i++;
                        j++;
                }
                cmp[j] = 0;

                if (!Q_stricmp(str, cmp))
                { //found it
                        return qtrue;
                }
                if (list[i] != '|')
                { //reached the end and never found it
                        return qfalse;
                }
                i++;
        }

        return qfalse;
}

extern qboolean gSiegeRoundBegun;
void SiegeItemRemoveOwner(gentity_t *ent, gentity_t *carrier);
void multi_trigger( gentity_t *ent, gentity_t *activator ) 
{
        qboolean haltTrigger = qfalse;

        if ( ent->think == multi_trigger_run )
        {//already triggered, just waiting to run
                return;
        }

        if (g_gametype.integer == GT_SIEGE &&
                !gSiegeRoundBegun)
        { //nothing can be used til the round starts.
                return;
        }

        if (g_gametype.integer == GT_SIEGE &&
                activator && activator->client &&
                ent->alliedTeam &&
                activator->client->sess.sessionTeam != ent->alliedTeam)
        { //this team can't activate this trigger.
                return;
        }

        if (g_gametype.integer == GT_SIEGE &&
                ent->idealclass && ent->idealclass[0])
        { //only certain classes can activate it
                if (!activator ||
                        !activator->client ||
                        activator->client->siegeClass < 0)
                { //no class
                        return;
                }

                if (!G_NameInTriggerClassList(bgSiegeClasses[activator->client->siegeClass].name, ent->idealclass))
                { //wasn't in the list
                        return;
                }
        }

        if (g_gametype.integer == GT_SIEGE && ent->genericValue1)
        {
                haltTrigger = qtrue;

                if (activator && activator->client &&
                        activator->client->holdingObjectiveItem &&
                        ent->targetname && ent->targetname[0])
                {
                        gentity_t *objItem = &g_entities[activator->client->holdingObjectiveItem];

                        if (objItem && objItem->inuse)
                        {
                                if (objItem->goaltarget && objItem->goaltarget[0] &&
                                        !Q_stricmp(ent->targetname, objItem->goaltarget))
                                {
                                        if (objItem->genericValue7 != activator->client->sess.sessionTeam)
                                        { //The carrier of the item is not on the team which disallows objective scoring for it
                                                if (objItem->target3 && objItem->target3[0])
                                                { //if it has a target3, fire it off instead of using the trigger
                                                        G_UseTargets2(objItem, objItem, objItem->target3);

                            //3-24-03 - want to fire off the target too I guess, if we have one.
                                                        if (ent->targetname && ent->targetname[0])
                                                        {
                                                                haltTrigger = qfalse;
                                                        }
                                                }
                                                else
                                                {
                                                        haltTrigger = qfalse;
                                                }

                                                //now that the item has been delivered, it can go away.
                                                SiegeItemRemoveOwner(objItem, activator);
                                                objItem->nextthink = 0;
                                                objItem->neverFree = qfalse;
                                                G_FreeEntity(objItem);
                                        }
                                }
                        }
                }
        }
        else if (ent->genericValue1)
        { //Never activate in non-siege gametype I guess.
                return;
        }

        if (ent->genericValue2)
        { //has "teambalance" property
                int i = 0;
                int team1ClNum = 0;
                int team2ClNum = 0;
                int owningTeam = ent->genericValue3;
                int newOwningTeam = 0;
                int numEnts = 0;
                int entityList[MAX_GENTITIES];
                gentity_t *cl;

                if (g_gametype.integer != GT_SIEGE)
                {
                        return;
                }

                if (!activator->client ||
                        (activator->client->sess.sessionTeam != SIEGETEAM_TEAM1 && activator->client->sess.sessionTeam != SIEGETEAM_TEAM2))
                { //activator must be a valid client to begin with
                        return;
                }

                //Count up the number of clients standing within the bounds of the trigger and the number of them on each team
                numEnts = trap_EntitiesInBox( ent->r.absmin, ent->r.absmax, entityList, MAX_GENTITIES );
                while (i < numEnts)
                {
                        if (entityList[i] < MAX_CLIENTS)
                        { //only care about clients
                                cl = &g_entities[entityList[i]];

                                //the client is valid
                                if (cl->inuse && cl->client &&
                                        (cl->client->sess.sessionTeam == SIEGETEAM_TEAM1 || cl->client->sess.sessionTeam == SIEGETEAM_TEAM2) &&
                                        cl->health > 0 &&
                                        !(cl->client->ps.eFlags & EF_DEAD))
                                {
                                        //See which team he's on
                                        if (cl->client->sess.sessionTeam == SIEGETEAM_TEAM1)
                                        {
                                                team1ClNum++;
                                        }
                                        else
                                        {
                                                team2ClNum++;
                                        }
                                }
                        }
                        i++;
                }

                if (!team1ClNum && !team2ClNum)
                { //no one in the box? How did we get activated? Oh well.
                        return;
                }

                if (team1ClNum == team2ClNum)
                { //if equal numbers the ownership will remain the same as it is now
                        return;
                }

                //decide who owns it now
                if (team1ClNum > team2ClNum)
                {
                        newOwningTeam = SIEGETEAM_TEAM1;
                }
                else
                {
                        newOwningTeam = SIEGETEAM_TEAM2;
                }

                if (owningTeam == newOwningTeam)
                { //it's the same one it already was, don't care then.
                        return;
                }

                //Set the new owner and set the variable which will tell us to activate a team-specific target
                ent->genericValue3 = newOwningTeam;
                ent->genericValue4 = newOwningTeam;
        }

        if (haltTrigger)
        { //This is an objective trigger and the activator is not carrying an objective item that matches the targetname.
                return;
        }

        if ( ent->nextthink > level.time ) 
        {
                if( ent->spawnflags & 2048 ) // MULTIPLE - allow multiple entities to touch this trigger in a single frame
                {
                        if ( ent->painDebounceTime && ent->painDebounceTime != level.time )
                        {//this should still allow subsequent ents to fire this trigger in the current frame
                                return;         // can't retrigger until the wait is over
                        }
                }
                else
                {
                        return;
                }

        }

        // if the player has already activated this trigger this frame
        if( activator && !activator->s.number && ent->aimDebounceTime == level.time )
        {
                return; 
        }

        if ( ent->flags & FL_INACTIVE )
        {//Not active at this time
                return;
        }

        ent->activator = activator;

        if(ent->delay && ent->painDebounceTime < (level.time + ent->delay) )
        {//delay before firing trigger
                ent->think = multi_trigger_run;
                ent->nextthink = level.time + ent->delay;
                ent->painDebounceTime = level.time;
                
        }
        else
        {
                multi_trigger_run (ent);
        }
}

void Use_Multi( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
{
        multi_trigger( ent, activator );
}

qboolean G_PointInBounds( vec3_t point, vec3_t mins, vec3_t maxs );

void Touch_Multi( gentity_t *self, gentity_t *other, trace_t *trace ) 
{
        if( !other->client ) 
        {
                return;
        }

        if ( self->flags & FL_INACTIVE )
        {//set by target_deactivate
                return;
        }

        if( self->alliedTeam )
        {
                if ( other->client->sess.sessionTeam != self->alliedTeam )
                {
                        return;
                }
        }

// moved to just above multi_trigger because up here it just checks if the trigger is not being touched
// we want it to check any conditions set on the trigger, if one of those isn't met, the trigger is considered to be "cleared"
//      if ( self->e_ThinkFunc == thinkF_trigger_cleared_fire )
//      {//We're waiting to fire our target2 first
//              self->nextthink = level.time + self->speed;
//              return;
//      }

        if ( self->spawnflags & 1 )
        {
                if ( other->s.eType == ET_NPC )
                {
                        return;
                }
        }
        else
        {
                if ( self->spawnflags & 16 )
                {//NPCONLY
                        if ( other->NPC == NULL )
                        {
                                return;
                        }
                }

                if ( self->NPC_targetname && self->NPC_targetname[0] )
                {
                        if ( other->script_targetname && other->script_targetname[0] )
                        {
                                if ( Q_stricmp( self->NPC_targetname, other->script_targetname ) != 0 )
                                {//not the right guy to fire me off
                                        return;
                                }
                        }
                        else
                        {
                                return;
                        }
                }
        }

        if ( self->spawnflags & 2 )
        {//FACING
                vec3_t  forward;

                AngleVectors( other->client->ps.viewangles, forward, NULL, NULL );

                if ( DotProduct( self->movedir, forward ) < 0.5 )
                {//Not Within 45 degrees
                        return;
                }
        }

        if ( self->spawnflags & 4 )
        {//USE_BUTTON
                if( !( other->client->pers.cmd.buttons & BUTTON_USE ) )
                {//not pressing use button
                        return;
                }

                if ((other->client->ps.weaponTime > 0 && other->client->ps.torsoAnim != BOTH_BUTTON_HOLD && other->client->ps.torsoAnim != BOTH_CONSOLE1) || other->health < 1 ||
                        (other->client->ps.pm_flags & PMF_FOLLOW) || other->client->sess.sessionTeam == TEAM_SPECTATOR ||
                        other->client->ps.forceHandExtend != HANDEXTEND_NONE)
                { //player has to be free of other things to use.
                        return;
                }

                if (self->genericValue7)
                { //we have to be holding the use key in this trigger for x milliseconds before firing
                        if (g_gametype.integer == GT_SIEGE &&
                                self->idealclass && self->idealclass[0])
                        { //only certain classes can activate it
                                if (!other ||
                                        !other->client ||
                                        other->client->siegeClass < 0)
                                { //no class
                                        return;
                                }

                                if (!G_NameInTriggerClassList(bgSiegeClasses[other->client->siegeClass].name, self->idealclass))
                                { //wasn't in the list
                                        return;
                                }
                        }

                        if (!G_PointInBounds( other->client->ps.origin, self->r.absmin, self->r.absmax ))
                        {
                                return;
                        }
                        else if (other->client->isHacking != self->s.number && other->s.number < MAX_CLIENTS )
                        { //start the hack
                                other->client->isHacking = self->s.number;
                                VectorCopy(other->client->ps.viewangles, other->client->hackingAngles);
                                other->client->ps.hackingTime = level.time + self->genericValue7;
                                other->client->ps.hackingBaseTime = self->genericValue7;
                                if (other->client->ps.hackingBaseTime > 60000)
                                { //don't allow a bit overflow
                                        other->client->ps.hackingTime = level.time + 60000;
                                        other->client->ps.hackingBaseTime = 60000;
                                }
                                return;
                        }
                        else if (other->client->ps.hackingTime < level.time)
                        { //finished with the hack, reset the hacking values and let it fall through
                                other->client->isHacking = 0; //can't hack a client
                                other->client->ps.hackingTime = 0;
                        }
                        else
                        { //hack in progress
                                return;
                        }
                }
        }

        if ( self->spawnflags & 8 )
        {//FIRE_BUTTON
                if( !( other->client->pers.cmd.buttons & BUTTON_ATTACK ) &&
                        !( other->client->pers.cmd.buttons & BUTTON_ALT_ATTACK ) )
                {//not pressing fire button or altfire button
                        return;
                }
        }

        if ( self->radius )
        {
                vec3_t  eyeSpot;

                //Only works if your head is in it, but we allow leaning out
                //NOTE: We don't use CalcEntitySpot SPOT_HEAD because we don't want this
                //to be reliant on the physical model the player uses.
                VectorCopy(other->client->ps.origin, eyeSpot);
                eyeSpot[2] += other->client->ps.viewheight;

                if ( G_PointInBounds( eyeSpot, self->r.absmin, self->r.absmax ) )
                {
                        if( !( other->client->pers.cmd.buttons & BUTTON_ATTACK ) &&
                                !( other->client->pers.cmd.buttons & BUTTON_ALT_ATTACK ) )
                        {//not attacking, so hiding bonus
                                /*
                                //FIXME:  should really have sound events clear the hiddenDist
                                other->client->hiddenDist = self->radius;
                                //NOTE: movedir HAS to be normalized!
                                if ( VectorLength( self->movedir ) )
                                {//They can only be hidden from enemies looking in this direction
                                        VectorCopy( self->movedir, other->client->hiddenDir );
                                }
                                else
                                {
                                        VectorClear( other->client->hiddenDir );
                                }
                                */
                                //Not using this, at least not yet.
                        }
                }
        }

        if ( self->spawnflags & 4 )
        {//USE_BUTTON
                if (other->client->ps.torsoAnim != BOTH_BUTTON_HOLD &&
                        other->client->ps.torsoAnim != BOTH_CONSOLE1)
                {
                        G_SetAnim( other, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
                }
                else
                {
                        other->client->ps.torsoTimer = 500;
                }
                other->client->ps.weaponTime = other->client->ps.torsoTimer;
        }
        
        if ( self->think == trigger_cleared_fire )
        {//We're waiting to fire our target2 first
                self->nextthink = level.time + self->speed;
                return;
        }

        multi_trigger( self, other );
}

void trigger_cleared_fire (gentity_t *self)
{
        G_UseTargets2( self, self->activator, self->target2 );
        self->think = 0;
        // should start the wait timer now, because the trigger's just been cleared, so we must "wait" from this point
        if ( self->wait > 0 ) 
        {
                self->nextthink = level.time + ( self->wait + self->random * crandom() ) * 1000;
        }
}

/*QUAKED trigger_multiple (.1 .5 .1) ? CLIENTONLY FACING USE_BUTTON FIRE_BUTTON NPCONLY x x INACTIVE MULTIPLE
CLIENTONLY - only a player can trigger this by touch
FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
NPCONLY - only non-player NPCs can trigger this by touch
INACTIVE - Start off, has to be activated to be touchable/usable
MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0

"wait"          Seconds between triggerings, 0 default, number < 0 means one time only.
"random"        wait variance, default is 0
"delay"         how many seconds to wait to fire targets after tripped
"hiderange" As long as NPC's head is in this trigger, NPCs out of this hiderange cannot see him.  If you set an angle on the trigger, they're only hidden from enemies looking in that direction.  the player's crouch viewheight is 36, his standing viewheight is 54.  So a trigger thast should hide you when crouched but not standing should be 48 tall.
"target2"       The trigger will fire this only when the trigger has been activated and subsequently 'cleared'( once any of the conditions on the trigger have not been satisfied).  This will not fire the "target" more than once until the "target2" is fired (trigger field is 'cleared')
"speed"         How many seconds to wait to fire the target2, default is 1
"noise"         Sound to play when the trigger fires (plays at activator's origin)
"NPC_targetname"  Only the NPC with this NPC_targetname fires this trigger

Variable sized repeatable trigger.  Must be targeted at one or more entities.
so, the basic time between firing is a random time between
(wait - random) and (wait + random)

"team" - If set, only this team can trip this trigger
        0 - any
        1 - red
        2 - blue

"soundSet"      Ambient sound set to play when this trigger is activated

usetime         -       If specified (in milliseconds) along with the USE_BUTTON flag, will
                                require a client to hold the use key for x amount of ms before firing.

Applicable only during Siege gametype:
teamuser        -       if 1, team 2 can't use this. If 2, team 1 can't use this.
siegetrig       -       if non-0, can only be activated by players carrying a misc_siege_item
                                which is associated with this trigger by the item's goaltarget value.
teambalance     -       if non-0, is "owned" by the last team that activated. Can only be activated
                                by the other team if the number of players on the other team inside     the
                                trigger outnumber the number of players on the owning team inside the
                                trigger.
target3         -       fire when activated by team1
target4         -       fire when activated by team2

idealclass      -       Can only be used by this class/these classes. You can specify use by
                                multiple classes with the use of |, e.g.:
                                "Imperial Medic|Imperial Assassin|Imperial Demolitionist"
*/
void SP_trigger_multiple( gentity_t *ent ) 
{
        char    *s;
        if ( G_SpawnString( "noise", "", &s ) ) 
        {
                if (s && s[0])
                {
                        ent->noise_index = G_SoundIndex(s);
                }
                else
                {
                        ent->noise_index = 0;
                }
        }

        G_SpawnInt("usetime", "0", &ent->genericValue7);

        //For siege gametype
        G_SpawnInt("siegetrig", "0", &ent->genericValue1);
    G_SpawnInt("teambalance", "0", &ent->genericValue2);

        G_SpawnInt("delay", "0", &ent->delay);

        if ( (ent->wait > 0) && (ent->random >= ent->wait) ) {
                ent->random = ent->wait - FRAMETIME;
                Com_Printf(S_COLOR_YELLOW"trigger_multiple has random >= wait\n");
        }

        ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
        if ( !ent->speed && ent->target2 && ent->target2[0] )
        {
                ent->speed = 1000;
        }
        else
        {
                ent->speed *= 1000;
        }

        ent->touch = Touch_Multi;
        ent->use   = Use_Multi;

        if ( ent->team && ent->team[0] )
        {
                ent->alliedTeam = atoi(ent->team);
                ent->team = NULL;
        }

        InitTrigger( ent );
        trap_LinkEntity (ent);
}


/*QUAKED trigger_once (.5 1 .5) ? CLIENTONLY FACING USE_BUTTON FIRE_BUTTON x x x INACTIVE MULTIPLE
CLIENTONLY - only a player can trigger this by touch
FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
INACTIVE - Start off, has to be activated to be touchable/usable
MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0

"random"        wait variance, default is 0
"delay"         how many seconds to wait to fire targets after tripped
Variable sized repeatable trigger.  Must be targeted at one or more entities.
so, the basic time between firing is a random time between
(wait - random) and (wait + random)
"noise"         Sound to play when the trigger fires (plays at activator's origin)
"NPC_targetname"  Only the NPC with this NPC_targetname fires this trigger

"team" - If set, only this team can trip this trigger
        0 - any
        1 - red
        2 - blue

"soundSet"      Ambient sound set to play when this trigger is activated

usetime         -       If specified (in milliseconds) along with the USE_BUTTON flag, will
                                require a client to hold the use key for x amount of ms before firing.

Applicable only during Siege gametype:
teamuser - if 1, team 2 can't use this. If 2, team 1 can't use this.
siegetrig - if non-0, can only be activated by players carrying a misc_siege_item
                        which is associated with this trigger by the item's goaltarget value.

idealclass      -       Can only be used by this class/these classes. You can specify use by
                                multiple classes with the use of |, e.g.:
                                "Imperial Medic|Imperial Assassin|Imperial Demolitionist"
*/
void SP_trigger_once( gentity_t *ent ) 
{
        char    *s;
        if ( G_SpawnString( "noise", "", &s ) ) 
        {
                if (s && s[0])
                {
                        ent->noise_index = G_SoundIndex(s);
                }
                else
                {
                        ent->noise_index = 0;
                }
        }

        G_SpawnInt("usetime", "0", &ent->genericValue7);

        //For siege gametype
        G_SpawnInt("siegetrig", "0", &ent->genericValue1);

        G_SpawnInt("delay", "0", &ent->delay);

        ent->wait = -1;

        ent->touch = Touch_Multi;
        ent->use   = Use_Multi;

        if ( ent->team && ent->team[0] )
        {
                ent->alliedTeam = atoi(ent->team);
                ent->team = NULL;
        }

        ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec

        InitTrigger( ent );
        trap_LinkEntity (ent);
}

/*
======================================================================
trigger_lightningstrike -rww
======================================================================
*/
//lightning strike trigger lightning strike event
void Do_Strike(gentity_t *ent)
{
        trace_t localTrace;
        vec3_t strikeFrom;
        vec3_t strikePoint;
        vec3_t fxAng;
        
        //maybe allow custom fx direction at some point?
        VectorSet(fxAng, 90.0f, 0.0f, 0.0f);

        //choose a random point to strike within the bounds of the trigger
        strikePoint[0] = flrand(ent->r.absmin[0], ent->r.absmax[0]);
        strikePoint[1] = flrand(ent->r.absmin[1], ent->r.absmax[1]);

        //consider the bottom mins the ground level
        strikePoint[2] = ent->r.absmin[2];

        //set the from point
        strikeFrom[0] = strikePoint[0];
        strikeFrom[1] = strikePoint[1];
        strikeFrom[2] = ent->r.absmax[2]-4.0f;

        //now trace for damaging stuff, and do the effect
        trap_Trace(&localTrace, strikeFrom, NULL, NULL, strikePoint, ent->s.number, MASK_PLAYERSOLID);
        VectorCopy(localTrace.endpos, strikePoint);

        if (localTrace.startsolid || localTrace.allsolid)
        { //got a bad spot, think again next frame to try another strike
                ent->nextthink = level.time;
                return;
        }

        if (ent->radius)
        { //do a radius damage at the end pos
                G_RadiusDamage(strikePoint, ent, ent->damage, ent->radius, ent, NULL, MOD_SUICIDE);
        }
        else
        { //only damage individuals
                gentity_t *trHit = &g_entities[localTrace.entityNum];

                if (trHit->inuse && trHit->takedamage)
                { //damage it then
                        G_Damage(trHit, ent, ent, NULL, trHit->r.currentOrigin, ent->damage, 0, MOD_SUICIDE);
                }
        }

        G_PlayEffectID(ent->genericValue2, strikeFrom, fxAng);
}

//lightning strike trigger think loop
void Think_Strike(gentity_t *ent)
{
        if (ent->genericValue1)
        { //turned off currently
                return;
        }

        ent->nextthink = level.time + ent->wait + Q_irand(0, ent->random);
        Do_Strike(ent);
}

//lightning strike trigger use event function
void Use_Strike( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
{
        ent->genericValue1 = !ent->genericValue1;

        if (!ent->genericValue1)
        { //turn it back on
                ent->nextthink = level.time;
        }
}

/*QUAKED trigger_lightningstrike (.1 .5 .1) ? START_OFF
START_OFF - start trigger disabled

"lightningfx"   effect to use for lightning, MUST be specified
"wait"                  Seconds between strikes, 1000 default
"random"                wait variance, default is 2000
"dmg"                   damage on strike (default 50)
"radius"                if non-0, does a radius damage at the lightning strike
                                impact point (using this value as the radius). otherwise
                                will only do line trace damage. default 0.

use to toggle on and off
*/
void SP_trigger_lightningstrike( gentity_t *ent ) 
{
        char *s;

        ent->use = Use_Strike;
        ent->think = Think_Strike;
        ent->nextthink = level.time + 500;

        G_SpawnString("lightningfx", "", &s);
        if (!s || !s[0])
        {
                Com_Error(ERR_DROP, "trigger_lightningstrike with no lightningfx");
        }

        //get a configstring index for it
        ent->genericValue2 = G_EffectIndex(s);

        if (ent->spawnflags & 1)
        { //START_OFF
                ent->genericValue1 = 1;
        }

        if (!ent->wait)
        { //default 1000
                ent->wait = 1000;
        }
        if (!ent->random)
        { //default 2000
                ent->random = 2000;
        }
        if (!ent->damage)
        { //default 50
                ent->damage = 50;
        }

        InitTrigger( ent );
        trap_LinkEntity (ent);
}


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

trigger_always

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

void trigger_always_think( gentity_t *ent ) {
        G_UseTargets(ent, ent);
        G_FreeEntity( ent );
}

/*QUAKED trigger_always (.5 .5 .5) (-8 -8 -8) (8 8 8)
This trigger will always fire.  It is activated by the world.
*/
void SP_trigger_always (gentity_t *ent) {
        // we must have some delay to make sure our use targets are present
        ent->nextthink = level.time + 300;
        ent->think = trigger_always_think;
}


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

trigger_push

==============================================================================
*/
//trigger_push
#define PUSH_LINEAR             4
#define PUSH_RELATIVE   16
#define PUSH_MULTIPLE   2048
//target_push
#define PUSH_CONSTANT   2

void trigger_push_touch (gentity_t *self, gentity_t *other, trace_t *trace ) {
        if ( self->flags & FL_INACTIVE )
        {//set by target_deactivate
                return;
        }

        if ( !(self->spawnflags&PUSH_LINEAR) )
        {//normal throw
                if ( !other->client ) {
                        return;
                }
                BG_TouchJumpPad( &other->client->ps, &self->s );
                return;
        }

        //linear
        if( level.time < self->painDebounceTime + self->wait  ) // normal 'wait' check
        {
                if( self->spawnflags & PUSH_MULTIPLE ) // MULTIPLE - allow multiple entities to touch this trigger in one frame
                {
                        if ( self->painDebounceTime && level.time > self->painDebounceTime ) // if we haven't reached the next frame continue to let ents touch the trigger
                        {
                                return;
                        }
                }
                else // only allowing one ent per frame to touch trigger
                {
                        return;
                }
        }

        /*
        //???
        // if the player has already activated this trigger this frame
        if( other && !other->s.number && self->aimDebounceTime == level.time )
        {
                return;         
        }
        */
        
        /*
        if( self->spawnflags & PUSH_CONVEYOR )
        {   // only push player if he's on the ground
                if( other->s.groundEntityNum == ENTITYNUM_NONE )
                {
                        return;
                }
        }
        */

        /*
        if ( self->spawnflags & 1 )
        {//PLAYERONLY
                if ( other->s.number >= MAX_CLIENTS )
                {
                        return;
                }
        }
        else
        {
                if ( self->spawnflags & 8 )
                {//NPCONLY
                        if ( other->NPC == NULL )
                        {
                                return;
                        }
                }
        }
        */

        if ( !other->client ) {
                if ( other->s.pos.trType != TR_STATIONARY && other->s.pos.trType != TR_LINEAR_STOP && other->s.pos.trType != TR_NONLINEAR_STOP && VectorLengthSquared( other->s.pos.trDelta ) )
                {//already moving
                        VectorCopy( other->r.currentOrigin, other->s.pos.trBase );
                        VectorCopy( self->s.origin2, other->s.pos.trDelta );
                        other->s.pos.trTime = level.time;
                }
                return;
        }

        if ( other->client->ps.pm_type != PM_NORMAL 
                && other->client->ps.pm_type != PM_DEAD 
                && other->client->ps.pm_type != PM_FREEZE ) 
        {
                return;
        }
        
        if ( (self->spawnflags&PUSH_RELATIVE) )
        {//relative, dir to it * speed
                vec3_t dir;
                VectorSubtract( self->s.origin2, other->r.currentOrigin, dir );
                if ( self->speed )
                {
                        VectorNormalize( dir );
                        VectorScale( dir, self->speed, dir );
                }
                VectorCopy( dir, other->client->ps.velocity );
        }
        else if ( (self->spawnflags&PUSH_LINEAR) )
        {//linear dir * speed
                VectorScale( self->s.origin2, self->speed, other->client->ps.velocity );
        }
        else
        {
                VectorCopy( self->s.origin2, other->client->ps.velocity );
        }
        //so we don't take damage unless we land lower than we start here...
        /*
        other->client->ps.forceJumpZStart = 0;
        other->client->ps.pm_flags |= PMF_TRIGGER_PUSHED;//pushed by a trigger
        other->client->ps.jumpZStart = other->client->ps.origin[2];
        */

        if ( self->wait == -1 )
        {
                self->touch = NULL;
        }
        else if ( self->wait > 0 )
        {
                self->painDebounceTime = level.time;
                
        }
        /*
        if( other && !other->s.number )
        {       // mark that the player has activated this trigger this frame
                self->aimDebounceTime =level.time;
        }
        */
}


/*
=================
AimAtTarget

Calculate origin2 so the target apogee will be hit
=================
*/
void AimAtTarget( gentity_t *self ) {
        gentity_t       *ent;
        vec3_t          origin;
        float           height, gravity, time, forward;
        float           dist;

        VectorAdd( self->r.absmin, self->r.absmax, origin );
        VectorScale ( origin, 0.5f, origin );

        ent = G_PickTarget( self->target );
        if ( !ent ) {
                G_FreeEntity( self );
                return;
        }

        if ( self->classname && !Q_stricmp( "trigger_push", self->classname ) )
        {
                if ( (self->spawnflags&PUSH_RELATIVE) )
                {//relative, not an arc or linear
                        VectorCopy( ent->r.currentOrigin, self->s.origin2 );
                        return;
                }
                else if ( (self->spawnflags&PUSH_LINEAR) )
                {//linear, not an arc
                        VectorSubtract( ent->r.currentOrigin, origin, self->s.origin2 );
                        VectorNormalize( self->s.origin2 );
                        return;
                }
        }

        if ( self->classname && !Q_stricmp( "target_push", self->classname ) )
        {
                if( self->spawnflags & PUSH_CONSTANT )
                {
                        VectorSubtract ( ent->s.origin, self->s.origin, self->s.origin2 );
                        VectorNormalize( self->s.origin2);
                        VectorScale (self->s.origin2, self->speed, self->s.origin2);
                        return;
                }
        }

        height = ent->s.origin[2] - origin[2];
        gravity = g_gravity.value;
        time = sqrt( height / ( .5 * gravity ) );
        if ( !time ) {
                G_FreeEntity( self );
                return;
        }

        // set s.origin2 to the push velocity
        VectorSubtract ( ent->s.origin, origin, self->s.origin2 );
        self->s.origin2[2] = 0;
        dist = VectorNormalize( self->s.origin2);

        forward = dist / time;
        VectorScale( self->s.origin2, forward, self->s.origin2 );

        self->s.origin2[2] = time * gravity;
}


/*QUAKED trigger_push (.5 .5 .5) ? x x LINEAR x RELATIVE x x INACTIVE MULTIPLE
Must point at a target_position, which will be the apex of the leap.
This will be client side predicted, unlike target_push

LINEAR - Instead of tossing the client at the target_position, it will push them towards it.  Must set a "speed" (see below)
RELATIVE - instead of pushing you in a direction that is always from the center of the trigger to the target_position, it pushes *you* toward the target position, relative to your current location (can use with "speed"... if don't set a speed, it will use the distance from you to the target_position)
INACTIVE - not active until targeted by a target_activate
MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0

wait - how long to wait between pushes: -1 = push only once
speed - when used with the LINEAR spawnflag, pushes the client toward the position at a constant speed (default is 1000)
*/
void SP_trigger_push( gentity_t *self ) {
        InitTrigger (self);

        // unlike other triggers, we need to send this one to the client
        self->r.svFlags &= ~SVF_NOCLIENT;

        // make sure the client precaches this sound
        G_SoundIndex("sound/weapons/force/jump.wav");

        self->s.eType = ET_PUSH_TRIGGER;
        
        if ( !(self->spawnflags&2) )
        {//start on
                self->touch = trigger_push_touch;
        }

        if ( self->spawnflags & 4 )
        {//linear
                self->speed = 1000;
        }

        self->think = AimAtTarget;
        self->nextthink = level.time + FRAMETIME;
        trap_LinkEntity (self);
}

void Use_target_push( gentity_t *self, gentity_t *other, gentity_t *activator ) {
        if ( !activator->client ) {
                return;
        }

        if ( activator->client->ps.pm_type != PM_NORMAL && activator->client->ps.pm_type != PM_FLOAT ) {
                return;
        }

        G_ActivateBehavior(self,BSET_USE);

        VectorCopy (self->s.origin2, activator->client->ps.velocity);

        // play fly sound every 1.5 seconds
        if ( activator->fly_sound_debounce_time < level.time ) {
                activator->fly_sound_debounce_time = level.time + 1500;
                if (self->noise_index)
                {
                        G_Sound( activator, CHAN_AUTO, self->noise_index );
                }
        }
}

/*QUAKED target_push (.5 .5 .5) (-8 -8 -8) (8 8 8) bouncepad CONSTANT
CONSTANT will push activator in direction of 'target' at constant 'speed'

Pushes the activator in the direction.of angle, or towards a target apex.
"speed"         defaults to 1000
if "bouncepad", play bounce noise instead of none
*/
void SP_target_push( gentity_t *self ) {
        if (!self->speed) {
                self->speed = 1000;
        }
        G_SetMovedir (self->s.angles, self->s.origin2);
        VectorScale (self->s.origin2, self->speed, self->s.origin2);

        if ( self->spawnflags & 1 ) {
                self->noise_index = G_SoundIndex("sound/weapons/force/jump.wav");
        } else {
                self->noise_index = 0;  //G_SoundIndex("sound/misc/windfly.wav");
        }
        if ( self->target ) {
                VectorCopy( self->s.origin, self->r.absmin );
                VectorCopy( self->s.origin, self->r.absmax );
                self->think = AimAtTarget;
                self->nextthink = level.time + FRAMETIME;
        }
        self->use = Use_target_push;
}

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

trigger_teleport

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

void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace ) {
        gentity_t       *dest;

        if ( self->flags & FL_INACTIVE )
        {//set by target_deactivate
                return;
        }

        if ( !other->client ) {
                return;
        }
        if ( other->client->ps.pm_type == PM_DEAD ) {
                return;
        }
        // Spectators only?
        if ( ( self->spawnflags & 1 ) && 
                other->client->sess.sessionTeam != TEAM_SPECTATOR ) {
                return;
        }


        dest =  G_PickTarget( self->target );
        if (!dest) {
                G_Printf ("Couldn't find teleporter destination\n");
                return;
        }

        TeleportPlayer( other, dest->s.origin, dest->s.angles );
}


/*QUAKED trigger_teleport (.5 .5 .5) ? SPECTATOR
Allows client side prediction of teleportation events.
Must point at a target_position, which will be the teleport destination.

If spectator is set, only spectators can use this teleport
Spectator teleporters are not normally placed in the editor, but are created
automatically near doors to allow spectators to move through them
*/
void SP_trigger_teleport( gentity_t *self ) {
        InitTrigger (self);

        // unlike other triggers, we need to send this one to the client
        // unless is a spectator trigger
        if ( self->spawnflags & 1 ) {
                self->r.svFlags |= SVF_NOCLIENT;
        } else {
                self->r.svFlags &= ~SVF_NOCLIENT;
        }

        // make sure the client precaches this sound
        G_SoundIndex("sound/weapons/force/speed.wav");

        self->s.eType = ET_TELEPORT_TRIGGER;
        self->touch = trigger_teleporter_touch;

        trap_LinkEntity (self);
}


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

trigger_hurt