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 ); }