/*QUAKED target_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM x x x x INACTIVE This doesn't perform any actions except fire its targets. The activator can be forced to be from a certain team. if RANDOM is checked, only one of the targets will be fired, not all of them INACTIVE Can't be used until activated wait - set to -1 to use it only once */ void target_relay_use (gentity_t *self, gentity_t *other, gentity_t *activator) { qboolean ranscript = qfalse; if ( ( self->spawnflags & 1 ) && activator->client && activator->client->sess.sessionTeam != TEAM_RED ) { return; } if ( ( self->spawnflags & 2 ) && activator->client && activator->client->sess.sessionTeam != TEAM_BLUE ) { return; } if ( self->flags & FL_INACTIVE ) {//set by target_deactivate return; } ranscript = G_ActivateBehavior( self, BSET_USE ); if ( self->wait == -1 ) {//never use again if ( ranscript ) {//crap, can't remove! self->use = NULL; } else {//remove self->think = G_FreeEntity; self->nextthink = level.time + FRAMETIME; } } if ( self->spawnflags & 4 ) { gentity_t *ent; ent = G_PickTarget( self->target ); if ( ent && ent->use ) { GlobalUse( ent, self, activator ); } return; } G_UseTargets (self, activator); }
/* ================ Reached_BinaryMover ================ */ void Reached_BinaryMover( gentity_t *ent ) { // stop the looping sound ent->s.loopSound = ent->soundLoop; if ( ent->moverState == MOVER_1TO2 ) { // reached pos2 SetMoverState( ent, MOVER_POS2, level.time ); // play sound if ( ent->soundPos2 ) { G_AddEvent( ent, EV_GENERAL_SOUND, ent->soundPos2 ); } // return to pos1 after a delay ent->think = ReturnToPos1; ent->nextthink = level.time + ent->wait; // fire targets if ( !ent->activator ) { ent->activator = ent; } G_UseTargets( ent, ent->activator ); } else if ( ent->moverState == MOVER_2TO1 ) { // reached pos1 SetMoverState( ent, MOVER_POS1, level.time ); // play sound if ( ent->soundPos1 ) { G_AddEvent( ent, EV_GENERAL_SOUND, ent->soundPos1 ); } // close areaportals if ( ent->teammaster == ent || !ent->teammaster ) { trap_AdjustAreaPortalState( ent, qfalse ); } } else { G_Error( "Reached_BinaryMover: bad moverState" ); } }
/*QUAKED target_explosion (1 0 0) (-8 -8 -8) (8 8 8) Spawns an explosion temporary entity when used. "delay" wait this long before going off "dmg" how much radius damage should be done, defaults to 0 */ void target_explosion_explode (edict_t *self) { float save; if (!self) { return; } gi.WriteByte(svc_temp_entity); gi.WriteByte(TE_EXPLOSION1); gi.WritePosition(self->s.origin); gi.multicast(self->s.origin, MULTICAST_PHS); T_RadiusDamage(self, self->activator, self->dmg, NULL, self->dmg + 40, MOD_EXPLOSIVE); save = self->delay; self->delay = 0; G_UseTargets(self, self->activator); self->delay = save; }
static void path_corner_touch( edict_t *self, edict_t *other, cplane_t *plane, int surfFlags ) { vec3_t v; edict_t *next; if( other->movetarget != self ) return; if( other->enemy ) return; if( self->pathtarget ) { const char *savetarget; savetarget = self->target; self->target = self->pathtarget; G_UseTargets( self, other ); self->target = savetarget; } if( self->target ) next = G_PickTarget( self->target ); else next = NULL; if( next && ( next->spawnflags & 1 ) ) { VectorCopy( next->s.origin, v ); v[2] += next->r.mins[2]; v[2] -= other->r.mins[2]; VectorCopy( v, other->s.origin ); next = G_PickTarget( next->target ); other->s.teleported = qtrue; } other->goalentity = other->movetarget = next; VectorSubtract( other->goalentity->s.origin, other->s.origin, v ); }
// 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( gentity_t *ent, gentity_t *activator ) { ent->activator = activator; G_Script_ScriptEvent( ent, "activate", NULL ); if ( ent->nextthink ) { return; // can't retrigger until the wait is over } G_UseTargets (ent, ent->activator); if ( ent->wait > 0 ) { ent->think = multi_wait; ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000; } else { // we can't just remove (self) here, because this is a touch function // called while looping through area links... ent->touch = 0; ent->nextthink = level.time + FRAMETIME; ent->think = G_FreeEntity; } }
// 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(gentity_t *ent, gentity_t *activator) { ent->activator = activator; if (ent->nextthink) { return; // can't retrigger until the wait is over } if (activator->client) { if ((ent->spawnflags & 1) && activator->client->sess.sessionTeam != TEAM_RED) { return; } if ((ent->spawnflags & 2) && activator->client->sess.sessionTeam != TEAM_BLUE) { return; } } G_UseTargets (ent, ent->activator); if (ent->wait > 0) { ent->think = multi_wait; ent->nextthink = level.time + (ent->wait + ent->random * crandom()) * 1000; } else { // we can't just remove (self) here, because this is a touch function // called while looping through area links... ent->touch = 0; ent->nextthink = level.time + FRAMETIME; ent->think = G_FreeEntity; } }
/*QUAKED target_explosion (1 0 0) (-8 -8 -8) (8 8 8) Spawns an explosion temporary entity when used. "delay" wait this long before going off "dmg" how much radius damage should be done, defaults to 0 "fxdensity" size of explosion 1 - 100 (default is 10) */ void target_explosion_explode (edict_t *self) { float save; vec3_t vec; VectorClear(vec); vec[2] = 1; gi.WriteByte (svc_temp_entity); gi.WriteByte (TE_EXPLOSION1B); gi.WritePosition (self->s.origin); gi.WriteDir( vec ); gi.WriteByte( (int)(self->dmg / 2) ); gi.WriteByte (self->fxdensity); gi.multicast (self->s.origin, MULTICAST_PVS); { edict_t *breakit; breakit = G_Spawn(); if (breakit) { VectorCopy (self->s.origin, breakit->s.origin); gi.linkentity(breakit); gi.sound (breakit, CHAN_VOICE, gi.soundindex("world/explosion1.wav"), 1, ATTN_NORM, 0); breakit->think = G_FreeEdict; breakit->nextthink = level.time + 5.0; } } T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE); save = self->delay; self->delay = 0; G_UseTargets (self, self->activator); self->delay = save; }
void target_lock_use(edict_t *self, edict_t *other, edict_t *activator) { char current[16]; memset(current, 0, 16); for (edict_t *e = self->teammaster; e; e = e->teamchain) { if (!e->count) continue; const int n = e->count - 1; current[n] = '0' + e->s.frame; } if (strcmp(current, self->key_message) == 0) { char *copy_message = self->message; self->message = NULL; G_UseTargets(self, activator); self->message = copy_message; } else { if (self->message) safe_centerprintf(activator, self->message); if (self->pathtarget) { edict_t *e = G_Find(NULL, FOFS(targetname), self->pathtarget); if (e) e->use(e, other, activator); } else { BeepBeep(activator); } } }
/*QUAKED target_script_trigger (1 .7 .2) (-8 -8 -8) (8 8 8) must have an aiName must have a target when used it will fire its targets */ void target_script_trigger_use(gentity_t *ent, gentity_t *other, gentity_t *activator) { gentity_t *player; if(ent->aiName) { player = AICast_FindEntityForName("player"); if(player) { AICast_ScriptEvent(AICast_GetCastState(player->s.number), "trigger", ent->target); } } // DHM - Nerve :: In multiplayer, we use the brush scripting only if(g_gametype.integer == GT_WOLF && ent->scriptName) { G_Script_ScriptEvent(ent, "trigger", ent->target); } G_UseTargets(ent, other); }
/*QUAKED target_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM This doesn't perform any actions except fire its targets. The activator can be forced to be from a certain team. if RANDOM is checked, only one of the targets will be fired, not all of them */ void target_relay_use( gentity_t *self, gentity_t *other, gentity_t *activator ) { if( ( self->spawnflags & 1 ) && activator && activator->client && activator->client->ps.stats[ STAT_TEAM ] != TEAM_HUMANS ) return; if( ( self->spawnflags & 2 ) && activator && activator->client && activator->client->ps.stats[ STAT_TEAM ] != TEAM_ALIENS ) return; if( self->spawnflags & 4 ) { gentity_t *ent; ent = G_PickTarget( self->target ); if( ent && ent->use ) ent->use( ent, self, activator ); return; } G_UseTargets( self, activator ); }
//----------------------------------------------------- void funcGlassDie( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc ) { vec3_t verts[4], normal; // if a missile is stuck to us, blow it up so we don't look dumb....we could, alternately, just let the missile drop off?? for ( int i = 0; i < MAX_GENTITIES; i++ ) { if ( g_entities[i].s.groundEntityNum == self->s.number && ( g_entities[i].s.eFlags & EF_MISSILE_STICK )) { G_Damage( &g_entities[i], self, self, NULL, NULL, 99999, 0, MOD_CRUSH ); //?? MOD? } } // Really naughty cheating. Put in an EVENT at some point... cgi_R_GetBModelVerts( cgs.inlineDrawModel[self->s.modelindex], verts, normal ); CG_DoGlass( verts, normal, self->pos1, self->pos2, self->splashRadius ); self->takedamage = qfalse;//stop chain reaction runaway loops G_SetEnemy( self, self->enemy ); //NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!! gi.AdjustAreaPortalState( self, qtrue ); //So chunks don't get stuck inside me self->s.solid = 0; self->contents = 0; self->clipmask = 0; gi.linkentity(self); if ( self->target && attacker != NULL ) { G_UseTargets( self, attacker ); } G_FreeEntity( self ); }
/* * ================ * monster_death_use * * When a monster dies, it fires all of its targets with the current * enemy as activator. * ================ */ void monster_death_use(edict_t *self) { edict_t *player; int i; self->flags &= ~(FL_FLY | FL_SWIM); self->monsterinfo.aiflags &= AI_GOOD_GUY; // Lazarus: If actor/monster is being used as a camera by a player, // turn camera off for that player for (i = 0, player = g_edicts + 1; i < maxclients->value; i++, player++) { if (player->client && (player->client->spycam == self)) { camera_off(player); } } if (self->item) { Drop_Item(self, self->item); self->item = NULL; } if (self->deathtarget) { self->target = self->deathtarget; } if (!self->target) { return; } G_UseTargets(self, self->enemy); }
/*QUAKED target_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM This doesn't perform any actions except fire its targets. The activator can be forced to be from a certain team. if RANDOM is checked, only one of the targets will be fired, not all of them */ void target_relay_use (gentity_t *self, gentity_t *other, gentity_t *activator) { /* LQ3A */ UNREFERENCED_PARAMETER(other); if ( ( self->spawnflags & 1 ) && activator->client && activator->client->sess.sessionTeam != TEAM_RED ) { return; } if ( ( self->spawnflags & 2 ) && activator->client && activator->client->sess.sessionTeam != TEAM_BLUE ) { return; } if ( self->spawnflags & 4 ) { gentity_t *ent; ent = G_PickTarget( self->target ); if ( ent && ent->use ) { ent->use( ent, self, activator ); } return; } G_UseTargets (self, activator); }
/* QUAKED target_script_trigger (1 .7 .2) (-8 -8 -8) (8 8 8) must have an aiName must have a target when used it will fire its targets */ void target_script_trigger_use(gentity_t *ent, gentity_t *other, gentity_t *activator) { qboolean found = qfalse; // for all entities/bots with this ainame gentity_t *trent = NULL; // Are we using ainame to find another ent instead of using scriptname for this one? if (ent->aiName) { // Find the first entity with this name trent = G_Find(trent, FOFS(scriptName), ent->aiName); // Was there one? if (trent) { // We found it found = qtrue; // Play the script G_Script_ScriptEvent(trent, "trigger", ent->target); } // if (trent)... } // if (ent->aiName)... // Use the old method if we didn't find an entity with the ainame if (!found) { if (ent->scriptName) { G_Script_ScriptEvent(ent, "trigger", ent->target); } } G_UseTargets(ent, other); }
/* =============== trigger_win =============== */ void trigger_win( gentity_t *self, gentity_t *other, gentity_t *activator ) { G_UseTargets( self, self ); }
/*QUAKED func_timer (0.3 0.1 0.6) (-8 -8 -8) (8 8 8) START_ON This should be renamed trigger_timer... Repeatedly fires its targets. Can be turned on or off by using. "wait" base time between triggering all targets, default is 1 "random" wait variance, default is 0 so, the basic time between firing is a random time between (wait - random) and (wait + random) */ void func_timer_think( gentity_t *self ) { G_UseTargets( self, self->activator ); // set time before next firing self->nextthink = level.time + 1000 * ( self->wait + crandom( ) * self->random ); }
void trigger_always_think( gentity_t *ent ) { G_UseTargets( ent, ent ); G_FreeEntity( ent ); }
void target_actor_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf) { vec3_t v; if (other->movetarget != self) return; if (other->enemy) return; other->goalentity = other->movetarget = NULL; if (self->message) { int n; edict_t *ent; for (n = 1; n <= game.maxclients; n++) { ent = &g_edicts[n]; if (!ent->inuse) continue; gi.cprintf (ent, PRINT_CHAT, "%s: %s\n", actor_names[(other - g_edicts)%MAX_ACTOR_NAMES], self->message); } } if (self->spawnflags & 1) //jump { other->velocity[0] = self->movedir[0] * self->speed; other->velocity[1] = self->movedir[1] * self->speed; if (other->groundentity) { other->groundentity = NULL; other->velocity[2] = self->movedir[2]; gi.sound(other, CHAN_VOICE, gi.soundindex("player/male/jump1.wav"), 1, ATTN_NORM, 0); } } if (self->spawnflags & 2) //shoot { } else if (self->spawnflags & 4) //attack { other->enemy = G_PickTargetIgnore(self->pathtarget,self->owner); if (other->enemy) { other->goalentity = other->enemy; if (self->spawnflags & 32) other->monsterinfo.aiflags |= AI_BRUTAL; if (self->spawnflags & 16) { other->monsterinfo.aiflags |= AI_STAND_GROUND; actor_stand (other); } else { actor_run (other); } } } if (!(self->spawnflags & 6) && (self->pathtarget)) { char *savetarget; savetarget = self->target; self->target = self->pathtarget; G_UseTargets (self, other); self->target = savetarget; } other->movetarget = G_PickTargetIgnore(self->target,self->owner); if (!other->goalentity) other->goalentity = other->movetarget; if (!other->movetarget && !other->enemy) { other->monsterinfo.pausetime = level.time + 100000000; other->monsterinfo.stand (other); } else if (other->movetarget == other->goalentity) { VectorSubtract (other->movetarget->s.origin, other->s.origin, v); other->ideal_yaw = vectoyaw (v); } }
void Use_Target_Alarm( gentity_t *ent, gentity_t *other, gentity_t *activator ) { G_UseTargets(ent, other); }
/*QUAKED target_relay (1 1 0) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM NOKEY_ONLY TAKE_KEY NO_LOCKED_NOISE This doesn't perform any actions except fire its targets. The activator can be forced to be from a certain team. if RANDOM is checked, only one of the targets will be fired, not all of them "key" specifies an item you can be carrying that affects the operation of this relay this key is currently an int (1-16) which matches the id of a key entity (key_key1 = 1, etc) NOKEY_ONLY means "fire only if I do /not/ have the specified key" TAKE_KEY removes the key from the players inventory "lockednoise" specifies a .wav file to play if the relay is used and the player doesn't have the necessary key. By default this sound is "sound/movers/doors/default_door_locked.wav" NO_LOCKED_NOISE specifies that it will be silent if activated without proper key */ void target_relay_use (gentity_t *self, gentity_t *other, gentity_t *activator) { if ( ( self->spawnflags & 1 ) && activator && activator->client && activator->client->sess.sessionTeam != TEAM_RED ) { return; } if ( ( self->spawnflags & 2 ) && activator && activator->client && activator->client->sess.sessionTeam != TEAM_BLUE ) { return; } if ( self->spawnflags & 4 ) { gentity_t *ent; ent = G_PickTarget( self->target ); if ( ent && ent->use ) { ent->use( ent, self, activator ); } return; } if(activator) { // activator can be NULL if called from script if(self->key) { gitem_t *item; if(self->key == -1) // relay permanently locked { if (self->soundPos1) G_Sound( self, self->soundPos1); //----(SA) added return; } item = BG_FindItemForKey(self->key, 0); if(item) { if(activator->client->ps.stats[STAT_KEYS] & (1<<item->giTag)) // user has key { if (self->spawnflags & 8 ) { // relay is NOKEY_ONLY and player has key if (self->soundPos1) G_Sound( self, self->soundPos1); //----(SA) added return; } } else // user does not have key { if (!(self->spawnflags & 8) ) { if (self->soundPos1) G_Sound( self, self->soundPos1); //----(SA) added return; } } } if(self->spawnflags & 16) { // (SA) take key activator->client->ps.stats[STAT_KEYS] &= ~(1<<item->giTag); // (SA) TODO: "took inventory item" sound } } } G_UseTargets (self, activator); }
void Use_Target_Alarm(gentity_t *ent, gentity_t *other, gentity_t *activator) { // Nico, silent GCC (void)activator; G_UseTargets(ent, other); }
/*QUAKED trigger_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) This fixed size trigger cannot be touched, it can only be fired by other events. */ void trigger_relay_use (edict_t *self, edict_t *other, edict_t *activator) { G_UseTargets (self, activator); }
void func_clock_think (edict_t *self) { if (!self->enemy) { self->enemy = G_Find (NULL, FOFS(targetname), self->target); if (!self->enemy) return; } if (self->spawnflags & 1) { func_clock_format_countdown (self); self->health++; } else if (self->spawnflags & 2) { func_clock_format_countdown (self); self->health--; } else { struct tm *ltime; time_t gmtime; time(&gmtime); ltime = localtime(&gmtime); Com_sprintf (self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i:%2i", ltime->tm_hour, ltime->tm_min, ltime->tm_sec); if (self->message[3] == ' ') self->message[3] = '0'; if (self->message[6] == ' ') self->message[6] = '0'; } self->enemy->message = self->message; self->enemy->use (self->enemy, self, self); if (((self->spawnflags & 1) && (self->health > self->wait)) || ((self->spawnflags & 2) && (self->health < self->wait))) { if (self->pathtarget) { char *savetarget; char *savemessage; savetarget = self->target; savemessage = self->message; self->target = self->pathtarget; self->message = NULL; G_UseTargets (self, self->activator); self->target = savetarget; self->message = savemessage; } if (!(self->spawnflags & 8)) return; func_clock_reset (self); if (self->spawnflags & 4) return; } self->nextthink = level.time + 1; }
/*QUAKED target_delay (1 0 0) (-8 -8 -8) (8 8 8) "wait" seconds to pause before firing targets. "random" delay variance, total delay = delay +/- random seconds */ void Think_Target_Delay( gentity_t *ent ) { G_UseTargets( ent, ent->activator ); }
void func_usable_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {//Toggle on and off if ( other == activator ) {//directly used by use button trace if ( (self->spawnflags&32) ) {//only usable by NPCs if ( activator->NPC == NULL ) {//Not an NPC return; } } } G_ActivateBehavior( self, BSET_USE ); if ( self->s.eFlags & EF_SHADER_ANIM ) {//animate shader when used self->s.frame++;//inc frame if ( self->s.frame > self->endFrame ) {//wrap around self->s.frame = 0; } if ( self->target && self->target[0] ) { G_UseTargets( self, activator ); } } else if ( self->spawnflags & 8 ) {//ALWAYS_ON //Remove the ability to use the entity directly self->svFlags &= ~SVF_PLAYER_USABLE; //also remove ability to call any use func at all! self->e_UseFunc = useF_NULL; if(self->target && self->target[0]) { G_UseTargets(self, activator); } if ( self->wait ) { self->e_ThinkFunc = thinkF_func_usable_think; self->nextthink = level.time + ( self->wait * 1000 ); } return; } else if ( !self->count ) {//become solid again self->count = 1; self->activator = activator; func_wait_return_solid( self ); } else { //NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!! if ( !(self->spawnflags&1) ) {//START_OFF doesn't effect area portals gi.AdjustAreaPortalState( self, qtrue ); } self->s.solid = 0; self->contents = 0; self->clipmask = 0; self->svFlags |= SVF_NOCLIENT; self->s.eFlags |= EF_NODRAW; self->count = 0; if(self->target && self->target[0]) { G_UseTargets(self, activator); } self->e_ThinkFunc = thinkF_NULL; self->nextthink = -1; } }
/* =============== Touch_Item =============== */ void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) { int respawn; qboolean predict; if (!other->client) return; if (other->health < 1) return; // dead people can't pickup // the same pickup rules are used for client side and server side if ( !BG_CanItemBeGrabbed( g_gametype.integer, &ent->s, &other->client->ps ) ) { return; } G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname ); predict = other->client->pers.predictItemPickup; // call the item-specific pickup function switch( ent->item->giType ) { case IT_WEAPON: respawn = Pickup_Weapon(ent, other); // predict = qfalse; break; case IT_AMMO: respawn = Pickup_Ammo(ent, other); // predict = qfalse; break; case IT_ARMOR: respawn = Pickup_Armor(ent, other); break; case IT_HEALTH: respawn = Pickup_Health(ent, other); break; case IT_POWERUP: respawn = Pickup_Powerup(ent, other); predict = qfalse; break; #ifdef MISSIONPACK case IT_PERSISTANT_POWERUP: respawn = Pickup_PersistantPowerup(ent, other); break; #endif case IT_TEAM: respawn = Pickup_Team(ent, other); break; case IT_HOLDABLE: respawn = Pickup_Holdable(ent, other); break; default: return; } if ( !respawn ) { return; } // play the normal pickup sound if (predict) { G_AddPredictableEvent( other, EV_ITEM_PICKUP, ent->s.modelindex ); } else { G_AddEvent( other, EV_ITEM_PICKUP, ent->s.modelindex ); } // powerup pickups are global broadcasts if ( ent->item->giType == IT_POWERUP || ent->item->giType == IT_TEAM) { // if we want the global sound to play if (!ent->speed) { gentity_t *te; te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP ); te->s.eventParm = ent->s.modelindex; te->r.svFlags |= SVF_BROADCAST; } else { gentity_t *te; te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP ); te->s.eventParm = ent->s.modelindex; // only send this temp entity to a single client te->r.svFlags |= SVF_SINGLECLIENT; te->r.singleClient = other->s.number; } } // fire item targets G_UseTargets (ent, other); // wait of -1 will not respawn if ( ent->wait == -1 ) { ent->r.svFlags |= SVF_NOCLIENT; ent->s.eFlags |= EF_NODRAW; ent->r.contents = 0; ent->unlinkAfterEvent = qtrue; return; } // non zero wait overrides respawn time if ( ent->wait ) { respawn = ent->wait; } // random can be used to vary the respawn time if ( ent->random ) { respawn += crandom() * ent->random; if ( respawn < 1 ) { respawn = 1; } } // dropped items will not respawn if ( ent->flags & FL_DROPPED_ITEM ) { ent->freeAfterEvent = qtrue; } // picked up items still stay around, they just don't // draw anything. This allows respawnable items // to be placed on movers. ent->r.svFlags |= SVF_NOCLIENT; ent->s.eFlags |= EF_NODRAW; ent->r.contents = 0; // ZOID // A negative respawn times means to never respawn this item (but don't // delete it). This is used by items that are respawned by third party // events such as ctf flags if ( respawn <= 0 ) { ent->nextthink = 0; ent->think = 0; } else { ent->nextthink = level.time + respawn * 1000; ent->think = RespawnItem; } trap_LinkEntity( ent ); }
/*QUAKED func_explosive (0 .5 .8) ? Trigger_Spawn ANIMATED ANIMATED_FAST Any brush that you want to explode or break apart. If you want an ex0plosion, set dmg and it will do a radius explosion of that amount at the center of the bursh. If targeted it will not be shootable. health defaults to 100. mass defaults to 75. This determines how much debris is emitted when it explodes. You get one large chunk per 100 of mass (up to 8) and one small chunk per 25 of mass (up to 16). So 800 gives the most. */ void func_explosive_explode (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point) { vec3_t origin; vec3_t chunkorigin; vec3_t size; int count; int mass; // bmodel origins are (0 0 0), we need to adjust that here VectorScale (self->size, 0.5, size); VectorAdd (self->absmin, size, origin); VectorCopy (origin, self->s.origin); self->takedamage = DAMAGE_NO; if (self->dmg) T_RadiusDamage (self, attacker, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE); VectorSubtract (self->s.origin, inflictor->s.origin, self->velocity); VectorNormalize (self->velocity); VectorScale (self->velocity, 150, self->velocity); // start chunks towards the center VectorScale (size, 0.5, size); mass = self->mass; if (!mass) mass = 75; // big chunks if (mass >= 100) { count = mass / 100; if (count > 8) count = 8; while(count--) { chunkorigin[0] = origin[0] + crandom() * size[0]; chunkorigin[1] = origin[1] + crandom() * size[1]; chunkorigin[2] = origin[2] + crandom() * size[2]; ThrowDebris (self, "models/objects/debris1/tris.md2", 1, chunkorigin); } } // small chunks count = mass / 25; if (count > 16) count = 16; while(count--) { chunkorigin[0] = origin[0] + crandom() * size[0]; chunkorigin[1] = origin[1] + crandom() * size[1]; chunkorigin[2] = origin[2] + crandom() * size[2]; ThrowDebris (self, "models/objects/debris2/tris.md2", 2, chunkorigin); } G_UseTargets (self, attacker); if (self->dmg) BecomeExplosion1 (self); else G_FreeEdict (self); }
/* =============== Reached_Train =============== */ void Reached_Train( gentity_t *ent ) { gentity_t *next; float speed; vec3_t move; float length; // copy the apropriate values next = ent->nextTrain; if ( !next || !next->nextTrain ) { return; // just stop } // fire all other targets G_UseTargets( next, NULL ); // set the new trajectory ent->nextTrain = next->nextTrain; VectorCopy( next->s.origin, ent->pos1 ); VectorCopy( next->nextTrain->s.origin, ent->pos2 ); // if the path_corner has a speed, use that if ( next->speed ) { speed = next->speed; } else { // otherwise use the train's speed speed = ent->speed; } if ( speed < 1 ) { speed = 1; } // calculate duration VectorSubtract( ent->pos2, ent->pos1, move ); length = VectorLength( move ); ent->s.pos.trDuration = length * 1000 / speed; // Tequila comment: Be sure to send to clients after any fast move case ent->r.svFlags &= ~SVF_NOCLIENT; // Tequila comment: Fast move case if(ent->s.pos.trDuration<1) { // Tequila comment: As trDuration is used later in a division, we need to avoid that case now // With null trDuration, // the calculated rocks bounding box becomes infinite and the engine think for a short time // any entity is riding that mover but not the world entity... In rare case, I found it // can also stuck every map entities after func_door are used. // The desired effect with very very big speed is to have instant move, so any not null duration // lower than a frame duration should be sufficient. // Afaik, the negative case don't have to be supported. ent->s.pos.trDuration=1; // Tequila comment: Don't send entity to clients so it becomes really invisible ent->r.svFlags |= SVF_NOCLIENT; } // looping sound ent->s.loopSound = next->soundLoop; // start it going SetMoverState( ent, MOVER_1TO2, level.time ); // if there is a "wait" value on the target, don't start moving yet if ( next->wait ) { ent->nextthink = level.time + next->wait * 1000; ent->think = Think_BeginMoving; ent->s.pos.trType = TR_STATIONARY; } }
/*QUAKED trigger_key (.5 .5 .5) (-8 -8 -8) (8 8 8) A relay trigger that only fires it's targets if player has the proper key. Use "item" to specify the required key, for example "key_data_cd" */ void trigger_key_use (edict_t *self, edict_t *other, edict_t *activator) { int index; if (!self->item) return; if (!activator->client) return; index = ITEM_INDEX(self->item); if (!activator->client->pers.inventory[index]) { if (level.time < self->touch_debounce_time) return; self->touch_debounce_time = level.time + 5.0; gi.centerprintf (activator, "You need the %s", self->item->pickup_name); gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/keytry.wav"), 1, ATTN_NORM, 0); return; } gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/keyuse.wav"), 1, ATTN_NORM, 0); if (coop->value) { int player; edict_t *ent; if (strcmp(self->item->classname, "key_power_cube") == 0) { int cube; for (cube = 0; cube < 8; cube++) if (activator->client->pers.power_cubes & (1 << cube)) break; for (player = 1; player <= game.maxclients; player++) { ent = &g_edicts[player]; if (!ent->inuse) continue; if (!ent->client) continue; if (ent->client->pers.power_cubes & (1 << cube)) { ent->client->pers.inventory[index]--; ent->client->pers.power_cubes &= ~(1 << cube); } } } else { for (player = 1; player <= game.maxclients; player++) { ent = &g_edicts[player]; if (!ent->inuse) continue; if (!ent->client) continue; ent->client->pers.inventory[index] = 0; } } } else { activator->client->pers.inventory[index]--; } G_UseTargets (self, activator); self->use = NULL; }
void target_random_use(gentity_t *self, gentity_t *other, gentity_t *activator) { int t_count = 0, pick; gentity_t *t = NULL; //gi.Printf("target_random %s used by %s (entnum %d)\n", self->targetname, activator->targetname, activator->s.number ); G_ActivateBehavior(self,BSET_USE); if(self->spawnflags & 1) { self->use = 0; } while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL ) { if (t != self) { t_count++; } } if(!t_count) { return; } if(t_count == 1) { G_UseTargets (self, activator); return; } //FIXME: need a seed // FIXME2: Proper numbers now pick = Q_irand(0, t_count-1); t_count = 0; while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL ) { if (t != self) { t_count++; } else { continue; } if (t == self) { // gi.Printf ("WARNING: Entity used itself.\n"); } else if(t_count == pick) { if (t->use != NULL) // check can be omitted { GlobalUse(t, self, activator); return; } } if (!self->inuse) { Com_Printf("entity was removed while using targets\n"); return; } } }