void sensor_support_think( gentity_t *self )
{
if(!self->enabled)
{
self->nextthink = level.time + SENSOR_POLL_PERIOD * 5;
return;
}
switch (self->conditions.team) {
case TEAM_HUMANS:
self->powered = G_FindPower( self, qfalse );
break;
case TEAM_ALIENS:
self->powered = G_FindCreep( self );
break;
case TEAM_ALL:
self->powered = G_FindPower( self, qfalse );
if(!self->powered)
self->powered = G_FindCreep( self );
break;
default:
G_Printf(S_ERROR "missing team field for %s\n", etos( self ));
G_FreeEntity( self );
break;
}
if(self->powered)
G_FireEntity( self, self->powerSource );
self->nextthink = level.time + SENSOR_POLL_PERIOD;
}
void target_relay_act( gentity_t *self, gentity_t*, gentity_t *activator )
{
if (!self->enabled)
return;
if ( ( self->spawnflags & 1 ) && activator && activator->client &&
activator->client->pers.team != TEAM_HUMANS )
{
return;
}
if ( ( self->spawnflags & 2 ) && activator && activator->client &&
activator->client->pers.team != TEAM_ALIENS )
{
return;
}
if ( self->spawnflags & 4 )
{
G_FireEntityRandomly( self, activator );
return;
}
if ( !self->config.wait.time )
{
G_FireEntity( self, activator );
}
else
{
self->nextthink = VariatedLevelTime( self->config.wait );
self->think = think_fireDelayed;
self->activator = activator;
}
}
//some old sensors/triggers used to propagate use-events, this is deprecated behavior
void trigger_compat_propagation_act( gentity_t *self, gentity_t *other, gentity_t *activator )
{
G_FireEntity( self, self );
if ( g_debugEntities.integer >= -1 ) //dont't warn about anything with -1 or lower
{
G_Printf( S_ERROR "It appears as if %s is targeted by %s to enforce firing, which is undefined behavior — stop doing that! This WILL break in future releases and toggle the sensor instead.\n", etos( self ), etos( activator ) );
}
}
void ctrl_limited_act(gentity_t *self, gentity_t*, gentity_t *activator)
{
if (!self->enabled)
return;
G_FireEntity( self, activator );
if ( self->count <= 1 )
{
G_FreeEntity( self );
return;
}
self->count--;
}
void G_notify_sensor_end( team_t winningTeam )
{
gentity_t *entity = NULL;
if( g_debugEntities.integer >= 2 )
G_Printf( S_DEBUG "Notification of game end. Winning team %i.\n", winningTeam );
while ((entity = G_IterateEntitiesOfClass(entity, S_SENSOR_END)) != NULL )
{
if ((winningTeam == entity->conditions.team) == !entity->conditions.negated)
G_FireEntity(entity, entity);
}
}
// 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 trigger_multiple_act( gentity_t *self, gentity_t *caller, gentity_t *activator )
{
self->activator = activator;
if ( self->nextthink )
return; // can't retrigger until the wait is over
if ( activator && activator->client && self->conditions.team &&
( activator->client->ps.stats[ STAT_TEAM ] != self->conditions.team ) )
return;
G_FireEntity( self, self->activator );
trigger_checkWaitForReactivation( self );
}
void sensor_creep_think( gentity_t *self )
{
if(!self->enabled)
{
self->nextthink = level.time + SENSOR_POLL_PERIOD * 5;
return;
}
self->powered = G_FindCreep( self );
if(self->powered)
G_FireEntity( self, self->powerSource );
self->nextthink = level.time + SENSOR_POLL_PERIOD;
}
void sensor_power_think( gentity_t *self )
{
if(!self->enabled)
{
self->nextthink = level.time + SENSOR_POLL_PERIOD * 5;
return;
}
self->powered = G_FindPower( self, qfalse ); //TODO spawnflag setting
if(self->powered)
G_FireEntity( self, self->powerSource );
self->nextthink = level.time + SENSOR_POLL_PERIOD;
}
/*
===============
G_notify_sensor_stage
Called when stages change
===============
*/
void G_notify_sensor_stage( team_t team, stage_t previousStage, stage_t newStage )
{
gentity_t *entities = NULL;
if( g_debugEntities.integer >= 2 )
G_Printf( S_DEBUG "Notification of team %i changing stage from %i to %i (0-2).\n", team, previousStage, newStage );
if(newStage <= previousStage) //not supporting stage down yet, also no need to fire if stage didn't change at all
return;
while ((entities = G_IterateEntitiesOfClass(entities, S_SENSOR_STAGE)) != NULL )
{
if (((!entities->conditions.stage || newStage == entities->conditions.stage)
&& (!entities->conditions.team || team == entities->conditions.team))
== !entities->conditions.negated)
{
G_FireEntity(entities, entities);
}
}
}
void sensor_buildable_touch( gentity_t *self, gentity_t *activator, trace_t *trace )
{
//sanity check
if ( !activator || !(activator->s.eType == ET_BUILDABLE) )
{
return;
}
self->activator = activator;
if ( self->nextthink )
{
return; // can't retrigger until the wait is over
}
if( sensor_buildable_match( self, activator ) == !self->conditions.negated )
{
G_FireEntity( self, activator );
trigger_checkWaitForReactivation( self );
}
}
void sensor_player_touch( gentity_t *self, gentity_t *activator, trace_t *trace )
{
qboolean shouldFire;
//sanity check
if ( !activator || !activator->client )
{
return;
}
self->activator = activator;
if ( self->nextthink )
{
return; // can't retrigger until the wait is over
}
if ( self->conditions.team && ( activator->client->ps.stats[ STAT_TEAM ] != self->conditions.team ) )
return;
if ( ( self->conditions.upgrades[0] || self->conditions.weapons[0] ) && activator->client->ps.stats[ STAT_TEAM ] == TEAM_HUMANS )
{
shouldFire = sensor_equipment_match( self, activator );
}
else if ( self->conditions.classes[0] && activator->client->ps.stats[ STAT_TEAM ] == TEAM_ALIENS )
{
shouldFire = sensor_class_match( self, activator );
}
else
{
shouldFire = qfalse;
}
if( shouldFire == !self->conditions.negated )
{
G_FireEntity( self, activator );
trigger_checkWaitForReactivation( self );
}
}
void G_CallEntity(gentity_t *targetedEntity, gentityCall_t *call)
{
if ( g_debugEntities.integer > 1 )
{
G_Printf(S_DEBUG "[%s] %s calling %s %s:%s\n",
etos( call->activator ),
etos( call->caller ),
call->definition ? call->definition->event : "onUnknown",
etos( targetedEntity ),
call->definition && call->definition->action ? call->definition->action : "default");
}
targetedEntity->callIn = *call;
if((!targetedEntity->handleCall || !targetedEntity->handleCall(targetedEntity, call)) && call->definition)
{
switch (call->definition->actionType)
{
case ECA_NOP:
break;
case ECA_CUSTOM:
if ( g_debugEntities.integer > -1 )
{
G_Printf(S_WARNING "Unknown action \"%s\" for %s\n",
call->definition->action, etos(targetedEntity));
}
break;
case ECA_FREE:
G_FreeEntity(targetedEntity);
return; //we have to handle notification differently in the free-case
case ECA_PROPAGATE:
G_FireEntity( targetedEntity, call->activator);
break;
case ECA_ENABLE:
if(!targetedEntity->enabled) //only fire an event if we weren't already enabled
{
targetedEntity->enabled = true;
G_EventFireEntity( targetedEntity, call->activator, ON_ENABLE );
}
break;
case ECA_DISABLE:
if(targetedEntity->enabled) //only fire an event if we weren't already disabled
{
targetedEntity->enabled = false;
G_EventFireEntity( targetedEntity, call->activator, ON_DISABLE );
}
break;
case ECA_TOGGLE:
targetedEntity->enabled = !targetedEntity->enabled;
G_EventFireEntity( targetedEntity, call->activator, targetedEntity->enabled ? ON_ENABLE : ON_DISABLE );
break;
case ECA_USE:
if (!targetedEntity->use)
{
if(g_debugEntities.integer >= 0)
G_Printf(S_WARNING "calling :use on %s, which has no use function!\n", etos(targetedEntity));
break;
}
if(!call->activator || !call->activator->client)
{
if(g_debugEntities.integer >= 0)
G_Printf(S_WARNING "calling %s:use, without a client as activator.\n", etos(targetedEntity));
break;
}
targetedEntity->use(targetedEntity, call->caller, call->activator);
break;
case ECA_RESET:
if (targetedEntity->reset)
{
targetedEntity->reset(targetedEntity);
G_EventFireEntity( targetedEntity, call->activator, ON_RESET );
}
break;
case ECA_ACT:
G_HandleActCall( targetedEntity, call );
break;
default:
if (targetedEntity->act)
targetedEntity->act(targetedEntity, call->caller, call->activator);
break;
}
}
if(targetedEntity->notifyHandler)
targetedEntity->notifyHandler( targetedEntity, call );
targetedEntity->callIn = NULL_CALL; /**< not called anymore */
}
void think_fireDelayed( gentity_t *self )
{
G_FireEntity( self, self->activator );
}
void sensor_timer_think( gentity_t *self )
{
G_FireEntity( self, self->activator );
// set time before next firing
G_SetNextthink( self );
}
void sensor_start_fireAndForget( gentity_t *self )
{
G_FireEntity(self, self);
G_FreeEntity( self );
}
