DOOM-3-BFG

Fx.cpp (23528B)

---

 /*
 ===========================================================================
 
 Doom 3 BFG Edition GPL Source Code
 Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. 
 
 This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").  
 
 Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.
 
 In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.
 
 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
 
 ===========================================================================
 */
 
 #include "../idlib/precompiled.h"
 #pragma hdrstop
 
 #include "Game_local.h"
 
 /*
 ===============================================================================
 
 	idEntityFx
 
 ===============================================================================
 */
 
 const idEventDef EV_Fx_KillFx( "_killfx" );
 const idEventDef EV_Fx_Action( "_fxAction", "e" );		// implemented by subclasses
 
 CLASS_DECLARATION( idEntity, idEntityFx )
 EVENT( EV_Activate,	   	idEntityFx::Event_Trigger )
 EVENT( EV_Fx_KillFx,	idEntityFx::Event_ClearFx )
 END_CLASS
 
 
 /*
 ================
 idEntityFx::Save
 ================
 */
 void idEntityFx::Save( idSaveGame *savefile ) const {
 	int i;
 
 	savefile->WriteInt( started );
 	savefile->WriteInt( nextTriggerTime );
 	savefile->WriteFX( fxEffect );
 	savefile->WriteString( systemName );
 
 	savefile->WriteInt( actions.Num() );
 
 	for ( i = 0; i < actions.Num(); i++ ) {
 
 		if ( actions[i].lightDefHandle >= 0 ) {
 			savefile->WriteBool( true );
 			savefile->WriteRenderLight( actions[i].renderLight );
 		} else {
 			savefile->WriteBool( false );
 		}
 
 		if ( actions[i].modelDefHandle >= 0 ) {
 			savefile->WriteBool( true );
 			savefile->WriteRenderEntity( actions[i].renderEntity );
 		} else {
 			savefile->WriteBool( false );
 		}
 
 		savefile->WriteFloat( actions[i].delay );
 		savefile->WriteInt( actions[i].start );
 		savefile->WriteBool( actions[i].soundStarted );
 		savefile->WriteBool( actions[i].shakeStarted );
 		savefile->WriteBool( actions[i].decalDropped );
 		savefile->WriteBool( actions[i].launched );
 	}
 }
 
 /*
 ================
 idEntityFx::Restore
 ================
 */
 void idEntityFx::Restore( idRestoreGame *savefile ) {
 	int i;
 	int num;
 	bool hasObject;
 
 	savefile->ReadInt( started );
 	savefile->ReadInt( nextTriggerTime );
 	savefile->ReadFX( fxEffect );
 	savefile->ReadString( systemName );
 
 	savefile->ReadInt( num );
 
 	actions.SetNum( num );
 	for ( i = 0; i < num; i++ ) {
 
 		savefile->ReadBool( hasObject );
 		if ( hasObject ) {
 			savefile->ReadRenderLight( actions[i].renderLight );
 			actions[i].lightDefHandle = gameRenderWorld->AddLightDef( &actions[i].renderLight );
 		} else {
 			memset( &actions[i].renderLight, 0, sizeof( renderLight_t ) );
 			actions[i].lightDefHandle = -1;
 		}
 
 		savefile->ReadBool( hasObject );
 		if ( hasObject ) {
 			savefile->ReadRenderEntity( actions[i].renderEntity );
 			actions[i].modelDefHandle = gameRenderWorld->AddEntityDef( &actions[i].renderEntity );
 		} else {
 			memset( &actions[i].renderEntity, 0, sizeof( renderEntity_t ) );
 			actions[i].modelDefHandle = -1;
 		}
 
 		savefile->ReadFloat( actions[i].delay );
 
 		// let the FX regenerate the particleSystem
 		actions[i].particleSystem = -1;
 
 		savefile->ReadInt( actions[i].start );
 		savefile->ReadBool( actions[i].soundStarted );
 		savefile->ReadBool( actions[i].shakeStarted );
 		savefile->ReadBool( actions[i].decalDropped );
 		savefile->ReadBool( actions[i].launched );
 	}
 }
 
 /*
 ================
 idEntityFx::Setup
 ================
 */
 void idEntityFx::Setup( const char *fx ) {
 
 	if ( started >= 0 ) {
 		return;					// already started
 	}
 
 	// early during MP Spawn() with no information. wait till we ReadFromSnapshot for more
 	if ( common->IsClient() && ( !fx || fx[0] == '\0' ) ) {
 		return;
 	}
 
 	systemName = fx;
 	started = 0;
 
 	fxEffect = static_cast<const idDeclFX *>( declManager->FindType( DECL_FX, systemName.c_str() ) );
 
 	if ( fxEffect ) {
 		idFXLocalAction localAction;
 
 		memset( &localAction, 0, sizeof( idFXLocalAction ) );
 
 		actions.AssureSize( fxEffect->events.Num(), localAction );
 
 		for( int i = 0; i<fxEffect->events.Num(); i++ ) {
 			const idFXSingleAction& fxaction = fxEffect->events[i];
 
 			idFXLocalAction& laction = actions[i];
 			if ( fxaction.random1 || fxaction.random2 ) {
 				laction.delay = fxaction.random1 + gameLocal.random.RandomFloat() * ( fxaction.random2 - fxaction.random1 );
 			} else {
 				laction.delay = fxaction.delay;
 			}
 			laction.start = -1;
 			laction.lightDefHandle = -1;
 			laction.modelDefHandle = -1;
 			laction.particleSystem = -1;
 			laction.shakeStarted = false;
 			laction.decalDropped = false;
 			laction.launched = false;
 		}
 	}
 }
 
 /*
 ================
 idEntityFx::EffectName
 ================
 */
 const char *idEntityFx::EffectName() {
 	return fxEffect ? fxEffect->GetName() : NULL;
 }
 
 /*
 ================
 idEntityFx::Joint
 ================
 */
 const char *idEntityFx::Joint() {
 	return fxEffect ? fxEffect->joint.c_str() : NULL;
 }
 
 /*
 ================
 idEntityFx::CleanUp
 ================
 */
 void idEntityFx::CleanUp() {
 	if ( !fxEffect ) {
 		return;
 	}
 	for( int i = 0; i < fxEffect->events.Num(); i++ ) {
 		const idFXSingleAction& fxaction = fxEffect->events[i];
 		idFXLocalAction& laction = actions[i];
 		CleanUpSingleAction( fxaction, laction );		
 	}
 }
 
 /*
 ================
 idEntityFx::CleanUpSingleAction
 ================
 */
 void idEntityFx::CleanUpSingleAction( const idFXSingleAction& fxaction, idFXLocalAction& laction ) {
 	if ( laction.lightDefHandle != -1 && fxaction.sibling == -1 && fxaction.type != FX_ATTACHLIGHT ) {
 		gameRenderWorld->FreeLightDef( laction.lightDefHandle );
 		laction.lightDefHandle = -1;
 	}
 	if ( laction.modelDefHandle != -1 && fxaction.sibling == -1 && fxaction.type != FX_ATTACHENTITY ) {
 		gameRenderWorld->FreeEntityDef( laction.modelDefHandle );
 		laction.modelDefHandle = -1;
 	}
 	laction.start = -1;
 }
 
 /*
 ================
 idEntityFx::Start
 ================
 */
 void idEntityFx::Start( int time ) {
 	if ( !fxEffect ) {
 		return;
 	}
 	started = time;
 	for( int i = 0; i < fxEffect->events.Num(); i++ ) {
 		idFXLocalAction& laction = actions[i];
 		laction.start = time;
 		laction.soundStarted = false;
 		laction.shakeStarted = false;
 		laction.particleSystem = -1;
 		laction.decalDropped = false;
 		laction.launched = false;
 	}
 }
 
 /*
 ================
 idEntityFx::Stop
 ================
 */
 void idEntityFx::Stop() {
 	CleanUp();
 	started = -1;
 }
 
 /*
 ================
 idEntityFx::Duration
 ================
 */
 const int idEntityFx::Duration() {
 	int max = 0;
 
 	if ( !fxEffect ) {
 		return max;
 	}
 	for( int i = 0; i < fxEffect->events.Num(); i++ ) {
 		const idFXSingleAction& fxaction = fxEffect->events[i];
 		int d = ( fxaction.delay + fxaction.duration ) * 1000.0f;
 		if ( d > max ) {
 			max = d;
 		}
 	}
 
 	return max;
 }
 
 
 /*
 ================
 idEntityFx::Done
 ================
 */
 const bool idEntityFx::Done() {
 	if (started > 0 && gameLocal.time > started + Duration()) {
 		return true;
 	}
 	return false;
 }
 
 /*
 ================
 idEntityFx::ApplyFade
 ================
 */
 void idEntityFx::ApplyFade( const idFXSingleAction& fxaction, idFXLocalAction& laction, const int time, const int actualStart ) {
 	if ( fxaction.fadeInTime || fxaction.fadeOutTime ) {
 		float fadePct = (float)( time - actualStart ) / ( 1000.0f * ( ( fxaction.fadeInTime != 0 ) ? fxaction.fadeInTime : fxaction.fadeOutTime ) );
 		if (fadePct > 1.0) {
 			fadePct = 1.0;
 		}
 		if ( laction.modelDefHandle != -1 ) {
 			laction.renderEntity.shaderParms[SHADERPARM_RED] = (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct;
 			laction.renderEntity.shaderParms[SHADERPARM_GREEN] = (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct;
 			laction.renderEntity.shaderParms[SHADERPARM_BLUE] = (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct;
 	
 			gameRenderWorld->UpdateEntityDef( laction.modelDefHandle, &laction.renderEntity );
 		}
 		if ( laction.lightDefHandle != -1 ) {
 			laction.renderLight.shaderParms[SHADERPARM_RED] = fxaction.lightColor.x * ( (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct );
 			laction.renderLight.shaderParms[SHADERPARM_GREEN] = fxaction.lightColor.y * ( (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct );
 			laction.renderLight.shaderParms[SHADERPARM_BLUE] = fxaction.lightColor.z * ( (fxaction.fadeInTime) ? fadePct : 1.0f - fadePct );
 
 			gameRenderWorld->UpdateLightDef( laction.lightDefHandle, &laction.renderLight );
 		}
 	}
 }
 
 /*
 ================
 idEntityFx::Run
 ================
 */
 void idEntityFx::Run( int time ) {
 	int ieff, j;
 	idEntity *ent = NULL;
 	const idDict *projectileDef = NULL;
 	idProjectile *projectile = NULL;
 
 	if ( !fxEffect ) {
 		return;
 	}
 
 	for( ieff = 0; ieff < fxEffect->events.Num(); ieff++ ) {
 		const idFXSingleAction& fxaction = fxEffect->events[ieff];
 		idFXLocalAction& laction = actions[ieff];
 
 		//
 		// if we're currently done with this one
 		//
 		if ( laction.start == -1 ) {
 			continue;
 		}
 
 		//
 		// see if it's delayed
 		//
 		if ( laction.delay ) {
 			if ( laction.start + (time - laction.start) < laction.start + (laction.delay * 1000) ) {
 				continue;
 			}
 		}
 
 		//
 		// each event can have it's own delay and restart
 		//
 		int actualStart = laction.delay ? laction.start + (int)( laction.delay * 1000 ) : laction.start;
 		float pct = (float)( time - actualStart ) / (1000 * fxaction.duration );
 		if ( pct >= 1.0f ) {
 			laction.start = -1;
 			float totalDelay = 0.0f;
 			if ( fxaction.restart ) {
 				if ( fxaction.random1 || fxaction.random2 ) {
 					totalDelay = fxaction.random1 + gameLocal.random.RandomFloat() * (fxaction.random2 - fxaction.random1);
 				} else {
 					totalDelay = fxaction.delay;
 				}
 				laction.delay = totalDelay;
 				laction.start = time;
 			} 
 			continue;
 		}
 
 		if ( fxaction.fire.Length() ) {
 			for( j = 0; j < fxEffect->events.Num(); j++ ) {
 				if ( fxEffect->events[j].name.Icmp( fxaction.fire ) == 0 ) {
 					actions[j].delay = 0;
 				}
 			}
 		}
 
 		idFXLocalAction *useAction;
 		if ( fxaction.sibling == -1 ) {
 			useAction = &laction;
 		} else {
 			useAction = &actions[fxaction.sibling];
 		}
 		assert( useAction );
 
 		switch( fxaction.type ) {
 			case FX_ATTACHLIGHT:
 			case FX_LIGHT: {
 				if ( useAction->lightDefHandle == -1 ) {
 					if ( fxaction.type == FX_LIGHT ) {
 						memset( &useAction->renderLight, 0, sizeof( renderLight_t ) );
 						useAction->renderLight.origin = GetPhysics()->GetOrigin() + fxaction.offset;
 						useAction->renderLight.axis = GetPhysics()->GetAxis();
 						useAction->renderLight.lightRadius[0] = fxaction.lightRadius;
 						useAction->renderLight.lightRadius[1] = fxaction.lightRadius;
 						useAction->renderLight.lightRadius[2] = fxaction.lightRadius;
 						useAction->renderLight.shader = declManager->FindMaterial( fxaction.data, false );
 						useAction->renderLight.shaderParms[ SHADERPARM_RED ]	= fxaction.lightColor.x;
 						useAction->renderLight.shaderParms[ SHADERPARM_GREEN ]	= fxaction.lightColor.y;
 						useAction->renderLight.shaderParms[ SHADERPARM_BLUE ]	= fxaction.lightColor.z;
 						useAction->renderLight.shaderParms[ SHADERPARM_TIMESCALE ]	= 1.0f;
 						useAction->renderLight.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( time );
 						useAction->renderLight.referenceSound = refSound.referenceSound;
 						useAction->renderLight.pointLight = true;
 						if ( fxaction.noshadows ) {
 							useAction->renderLight.noShadows = true;
 						}
 						useAction->lightDefHandle = gameRenderWorld->AddLightDef( &useAction->renderLight );
 					}
 					if ( fxaction.noshadows ) {
 						for( j = 0; j < fxEffect->events.Num(); j++ ) {
 							idFXLocalAction& laction2 = actions[j];
 							if ( laction2.modelDefHandle != -1 ) {
 								laction2.renderEntity.noShadow = true;
 							}
 						}
 					}
 				}
 				ApplyFade( fxaction, *useAction, time, actualStart );
 				break;
 			}
 			case FX_SOUND: {
 				if ( !useAction->soundStarted ) {
 					useAction->soundStarted = true;
 					const idSoundShader *shader = declManager->FindSound(fxaction.data);
 					StartSoundShader( shader, SND_CHANNEL_ANY, 0, false, NULL );
 					for( j = 0; j < fxEffect->events.Num(); j++ ) {
 						idFXLocalAction& laction2 = actions[j];
 						if ( laction2.lightDefHandle != -1 ) {
 							laction2.renderLight.referenceSound = refSound.referenceSound;
 							gameRenderWorld->UpdateLightDef( laction2.lightDefHandle, &laction2.renderLight );
 						}
 					}
 				}
 				break;
 			}
 			case FX_DECAL: {
 				if ( !useAction->decalDropped ) {
 					useAction->decalDropped = true;
 					gameLocal.ProjectDecal( GetPhysics()->GetOrigin(), GetPhysics()->GetGravity(), 8.0f, true, fxaction.size, fxaction.data ); 
 				}
 				break;
 			}
 			case FX_SHAKE: {
 				if ( !useAction->shakeStarted ) {
 					idDict args;
 					args.Clear();
 					args.SetFloat( "kick_time", fxaction.shakeTime );
 					args.SetFloat( "kick_amplitude", fxaction.shakeAmplitude );
 					for ( j = 0; j < gameLocal.numClients; j++ ) {
 						idPlayer *player = gameLocal.GetClientByNum( j );
 						if ( player && ( player->GetPhysics()->GetOrigin() - GetPhysics()->GetOrigin() ).LengthSqr() < Square( fxaction.shakeDistance ) ) {
 							if ( !common->IsMultiplayer() || !fxaction.shakeIgnoreMaster || GetBindMaster() != player ) {
 								player->playerView.DamageImpulse( fxaction.offset, &args );
 							}
 						}
 					}
 					if ( fxaction.shakeImpulse != 0.0f && fxaction.shakeDistance != 0.0f ) {
 						idEntity *ignore_ent = NULL;
 						if ( common->IsMultiplayer() ) {
 							ignore_ent = this;
 							if ( fxaction.shakeIgnoreMaster ) {
 								ignore_ent = GetBindMaster();
 							}
 						}
 						// lookup the ent we are bound to?
 						gameLocal.RadiusPush( GetPhysics()->GetOrigin(), fxaction.shakeDistance, fxaction.shakeImpulse, this, ignore_ent, 1.0f, true );
 					}
 					useAction->shakeStarted = true;
 				}
 				break;
 			}
 			case FX_ATTACHENTITY:
 			case FX_PARTICLE:
 			case FX_MODEL: {
 				if ( useAction->modelDefHandle == -1 ) {
 					memset( &useAction->renderEntity, 0, sizeof( renderEntity_t ) );
 					useAction->renderEntity.origin = GetPhysics()->GetOrigin() + fxaction.offset;
 					useAction->renderEntity.axis = (fxaction.explicitAxis) ? fxaction.axis : GetPhysics()->GetAxis();
 					useAction->renderEntity.hModel = renderModelManager->FindModel( fxaction.data );
 					useAction->renderEntity.shaderParms[ SHADERPARM_RED ]		= 1.0f;
 					useAction->renderEntity.shaderParms[ SHADERPARM_GREEN ]		= 1.0f;
 					useAction->renderEntity.shaderParms[ SHADERPARM_BLUE ]		= 1.0f;
 					useAction->renderEntity.shaderParms[ SHADERPARM_TIMEOFFSET ] = -MS2SEC( time );
 					useAction->renderEntity.shaderParms[3] = 1.0f;
 					useAction->renderEntity.shaderParms[5] = 0.0f;
 					if ( useAction->renderEntity.hModel ) {
 						useAction->renderEntity.bounds = useAction->renderEntity.hModel->Bounds( &useAction->renderEntity );
 					}
 					useAction->modelDefHandle = gameRenderWorld->AddEntityDef( &useAction->renderEntity );
 				} else if ( fxaction.trackOrigin ) {
 					useAction->renderEntity.origin = GetPhysics()->GetOrigin() + fxaction.offset;
 					useAction->renderEntity.axis = fxaction.explicitAxis ? fxaction.axis : GetPhysics()->GetAxis();
 					gameRenderWorld->UpdateEntityDef( useAction->modelDefHandle, &useAction->renderEntity );
 				}
 				ApplyFade( fxaction, *useAction, time, actualStart );
 				break;
 			}
 			case FX_LAUNCH: {
 				if ( common->IsClient() ) {
 					// client never spawns entities outside of ClientReadSnapshot
 					useAction->launched = true;
 					break;
 				}
 				if ( !useAction->launched ) {
 					useAction->launched = true;
 					projectile = NULL;
 					// FIXME: may need to cache this if it is slow
 					projectileDef = gameLocal.FindEntityDefDict( fxaction.data, false );
 					if ( !projectileDef ) {
 						gameLocal.Warning( "projectile \'%s\' not found", fxaction.data.c_str() );
 					} else {
 						gameLocal.SpawnEntityDef( *projectileDef, &ent, false );
 						if ( ent && ent->IsType( idProjectile::Type ) ) {
 							projectile = ( idProjectile * )ent;
 							projectile->Create( this, GetPhysics()->GetOrigin(), GetPhysics()->GetAxis()[0] );
 							projectile->Launch( GetPhysics()->GetOrigin(), GetPhysics()->GetAxis()[0], vec3_origin );
 						}
 					}
 				}
 				break;
 			}
 			case FX_SHOCKWAVE: {
 				if ( common->IsClient() ) {
 					useAction->shakeStarted = true;
 					break;
 				}
 				if ( !useAction->shakeStarted ) {
 					idStr	shockDefName;
 					useAction->shakeStarted = true;
 
 					shockDefName = fxaction.data;
 					if ( !shockDefName.Length() ) {
 						shockDefName = "func_shockwave";
 					}
 
 					projectileDef = gameLocal.FindEntityDefDict( shockDefName, false );
 					if ( !projectileDef ) {
 						gameLocal.Warning( "shockwave \'%s\' not found", shockDefName.c_str() );
 					} else {
 						gameLocal.SpawnEntityDef( *projectileDef, &ent );
 						ent->SetOrigin( GetPhysics()->GetOrigin() + fxaction.offset );
 						ent->PostEventMS( &EV_Remove, ent->spawnArgs.GetInt( "duration" ) );
 					}
 				}
 				break;
 			}
 		}
 	}
 }
 
 /*
 ================
 idEntityFx::idEntityFx
 ================
 */
 idEntityFx::idEntityFx() {
 	fxEffect = NULL;
 	started = -1;
 	nextTriggerTime = -1;
 	fl.networkSync = true;
 }
 
 /*
 ================
 idEntityFx::~idEntityFx
 ================
 */
 idEntityFx::~idEntityFx() {
 	CleanUp();
 	fxEffect = NULL;
 }
 
 /*
 ================
 idEntityFx::Spawn
 ================
 */
 void idEntityFx::Spawn() {
 
 	if ( g_skipFX.GetBool() ) {
 		return;
 	}
 
 	const char *fx;
 	nextTriggerTime = 0;
 	fxEffect = NULL;
 	if ( spawnArgs.GetString( "fx", "", &fx ) ) {
 		systemName = fx;
 	}
 	if ( !spawnArgs.GetBool( "triggered" ) ) {
 		Setup( fx );
 		if ( spawnArgs.GetBool( "test" ) || spawnArgs.GetBool( "start" ) || spawnArgs.GetFloat ( "restart" ) ) {
 			PostEventMS( &EV_Activate, 0, this );
 		}
 	}
 }
 
 /*
 ================
 idEntityFx::Think
 
   Clears any visual fx started when {item,mob,player} was spawned
 ================
 */
 void idEntityFx::Think() {
 	if ( g_skipFX.GetBool() ) {
 		return;
 	}
 
 	if ( thinkFlags & TH_THINK ) {
 		Run( gameLocal.time );
 	}
 
 	RunPhysics();
 	Present();
 }
 
 /*
 ================
 idEntityFx::Event_ClearFx
 
   Clears any visual fx started when item(mob) was spawned
 ================
 */
 void idEntityFx::Event_ClearFx() {
 
 	if ( g_skipFX.GetBool() ) {
 		return;
 	}
 
 	Stop();
 	CleanUp();
 	BecomeInactive( TH_THINK );
 
 	if ( spawnArgs.GetBool("test") ) {
 		PostEventMS( &EV_Activate, 0, this );
 	} else {
 		if ( spawnArgs.GetFloat( "restart" ) || !spawnArgs.GetBool( "triggered")) {
 			float rest = spawnArgs.GetFloat( "restart", "0" );
 			if ( rest == 0.0f ) {
 				PostEventSec( &EV_Remove, 0.1f );
 			} else {
 				rest *= gameLocal.random.RandomFloat();
 				PostEventSec( &EV_Activate, rest, this );
 			}
 		}
 	}
 }
 
 /*
 ================
 idEntityFx::Event_Trigger
 ================
 */
 void idEntityFx::Event_Trigger( idEntity *activator ) {
 
 	if ( g_skipFX.GetBool() ) {
 		return;
 	}
 
 	float		fxActionDelay;
 	const char *fx;
 
 	if ( gameLocal.time < nextTriggerTime ) {
 		return;
 	}
 
 	if ( spawnArgs.GetString( "fx", "", &fx) ) {
 		Setup( fx );
 		Start( gameLocal.time );
 		PostEventMS( &EV_Fx_KillFx, Duration() );
 		BecomeActive( TH_THINK );
 	}
 
 	fxActionDelay = spawnArgs.GetFloat( "fxActionDelay" );
 	if ( fxActionDelay != 0.0f ) {
 		nextTriggerTime = gameLocal.time + SEC2MS( fxActionDelay );
 	} else {
 		// prevent multiple triggers on same frame
 		nextTriggerTime = gameLocal.time + 1;
 	}
 	PostEventSec( &EV_Fx_Action, fxActionDelay, activator );
 }
 
 
 /*
 ================
 idEntityFx::StartFx
 ================
 */
 idEntityFx *idEntityFx::StartFx( const char *fx, const idVec3 *useOrigin, const idMat3 *useAxis, idEntity *ent, bool bind ) {
 
 	if ( g_skipFX.GetBool() || !fx || !*fx ) {
 		return NULL;
 	}
 
 	idDict args;
 	args.SetBool( "start", true );
 	args.Set( "fx", fx );
 	idEntityFx *nfx = static_cast<idEntityFx *>( gameLocal.SpawnEntityType( idEntityFx::Type, &args ) );
 	if ( nfx->Joint() && *nfx->Joint() ) {
 		nfx->BindToJoint( ent, nfx->Joint(), true );
 		nfx->SetOrigin( vec3_origin );
 	} else {
 		nfx->SetOrigin( (useOrigin) ? *useOrigin : ent->GetPhysics()->GetOrigin() );
 		nfx->SetAxis( (useAxis) ? *useAxis : ent->GetPhysics()->GetAxis() );
 	}
 
 	if ( bind ) {
 		// never bind to world spawn
 		if ( ent != gameLocal.world ) {
 			nfx->Bind( ent, true );
 		}
 	}
 	nfx->Show();
 	return nfx;
 }
 
 /*
 =================
 idEntityFx::WriteToSnapshot
 =================
 */
 void idEntityFx::WriteToSnapshot( idBitMsg &msg ) const {
 	GetPhysics()->WriteToSnapshot( msg );
 	WriteBindToSnapshot( msg );
 	msg.WriteLong( ( fxEffect != NULL ) ? gameLocal.ServerRemapDecl( -1, DECL_FX, fxEffect->Index() ) : -1 );
 	msg.WriteLong( started );
 }
 
 /*
 =================
 idEntityFx::ReadFromSnapshot
 =================
 */
 void idEntityFx::ReadFromSnapshot( const idBitMsg &msg ) {
 	int fx_index, start_time, max_lapse;
 
 	GetPhysics()->ReadFromSnapshot( msg );
 	ReadBindFromSnapshot( msg );
 	fx_index = gameLocal.ClientRemapDecl( DECL_FX, msg.ReadLong() );
 	start_time = msg.ReadLong();
 
 	if ( fx_index != -1 && start_time > 0 && !fxEffect && started < 0 ) {
 		spawnArgs.GetInt( "effect_lapse", "1000", max_lapse );
 		if ( gameLocal.time - start_time > max_lapse ) {
 			// too late, skip the effect completely
 			started = 0;
 			return;
 		}
 		const idDeclFX *fx = static_cast<const idDeclFX *>( declManager->DeclByIndex( DECL_FX, fx_index ) );
 		if ( !fx ) {
 			gameLocal.Error( "FX at index %d not found", fx_index );
 		}
 		fxEffect = fx;
 		Setup( fx->GetName() );
 		Start( start_time );
 	}
 }
 
 /*
 =================
 idEntityFx::ClientThink
 =================
 */
 void idEntityFx::ClientThink( const int curTime, const float fraction, const bool predict ) {
 
 	if ( gameLocal.isNewFrame ) { 
 		Run( gameLocal.serverTime ); 
 	}
 
 	InterpolatePhysics( fraction );
 	Present();
 }
 
 /*
 =================
 idEntityFx::ClientPredictionThink
 =================
 */
 void idEntityFx::ClientPredictionThink() {
 	if ( gameLocal.isNewFrame ) { 
 		Run( gameLocal.time ); 
 	}
 	RunPhysics();
 	Present();
 }
 
 /*
 ===============================================================================
 
   idTeleporter
 	
 ===============================================================================
 */
 
 CLASS_DECLARATION( idEntityFx, idTeleporter )
 	EVENT( EV_Fx_Action,	idTeleporter::Event_DoAction )
 END_CLASS
 
 /*
 ================
 idTeleporter::Event_DoAction
 ================
 */
 void idTeleporter::Event_DoAction( idEntity *activator ) {
 	float angle;
 
 	angle = spawnArgs.GetFloat( "angle" );
 	idAngles a( 0, spawnArgs.GetFloat( "angle" ), 0 );
 	activator->Teleport( GetPhysics()->GetOrigin(), a, NULL );
 }