etqw-sdk/base/script/vehicles/violator.script

object vehicle_violator {
	void			preinit();
	void			init();
	void			destroy();
	void			syncFields();

	void			vBomberAttack( vector target, vector attackDir, float attackHeight, entity attacker );
	void			Update();

	void			CreateFiringMarker();
	void			ClearFiringMarker();

	void			BeamSounds();

	void			Idle();

	vector			startPos;
	vector			beamDir;

	float			beamStartTime;
	float			beamDuration;
	float			beamStartupDuration;
	float			beamCoreStartupDuration;
	float			beamFizzleDuration;
	float			beamEffectFizzleDuration;
	
	float			lastGroundEffectsTime;

	float			beamRotationSpeed;

	entity			owner;
	
	float			movementTableIndex;

	boolean			beamSoundsThread;

	object			beamStartEffect;
	boolean			beamStartEffectPlaying;

	object			beamEffect;
	boolean			beamEffectPlaying;
	
	vector			targetBase;

	entity			firingMarker;
	
	float			splashDamage;

	float			beamAreaLength;
	
	// marker models
	void			CreateDirectionMarkers( vector startPosition, vector endPosition );
	void			FadeDirectionMarkers( float duration, float start, float end );
	void			RemoveDirectionMarkers();
	void			PulseDirectionMarkers( float currentTime );
	void			DirectionMarkerThread();
	
	boolean				directionMarkerDrawn;
	boolean				directionMarkerFaded;
	float				directionMarkerStartTime;
	direction_marker	directionMarker0;
	direction_marker	directionMarker1;
	direction_marker	directionMarker2;
	direction_marker	directionMarker3;
	direction_marker	directionMarker4;
	direction_marker	directionMarker5;
	direction_marker	directionMarker6;
	direction_marker	directionMarker7;
	direction_marker	directionMarker8;
	direction_marker	directionMarker9;
	direction_marker	directionMarker10;
	direction_marker	directionMarker11;
	direction_marker	directionMarker12;
	direction_marker	directionMarker13;
	direction_marker	directionMarker14;
	direction_marker	directionMarker15;
	direction_marker	directionMarker16;
	direction_marker	directionMarker17;
	direction_marker	directionMarker18;
	direction_marker	directionMarker19;
}

void vehicle_violator::syncFields() {
	syncBroadcast( "startPos" );
	syncBroadcast( "beamDir" );
	syncBroadcast( "beamStartTime" );
	syncBroadcast( "owner" );
}

void vehicle_violator::preinit() {
	beamStartTime		= -1;
	
	lastGroundEffectsTime = -1.f;

	beamStartupDuration			= getFloatKey( "beam_startup_duration" );
	beamCoreStartupDuration		= getFloatKey( "beam_core_startup_duration" );
	beamDuration				= getFloatKey( "beam_duration" );
	beamFizzleDuration			= getFloatKey( "beam_fizzle_duration" );
	beamEffectFizzleDuration	= getFloatKey( "beam_effect_fizzle_duration" );
	
	beamRotationSpeed			= getFloatKey( "beam_rotation_speed" );
	
	splashDamage				= GetDamage( "damage_violator_splash" );

	beamStartEffectPlaying		= false;
	beamEffectPlaying			= false;

	beamAreaLength				= getFloatKey( "beam_area_length" );

	movementTableIndex	= GetTable( "exp_x2" );
}

void vehicle_violator::init() {
	hide();
	setState( "Idle" );
}

void vehicle_violator::Idle() {
	while( true ) {
		sys.waitFrame();

		Update();
	}
}

void vehicle_violator::vBomberAttack( vector target, vector attackDir, float attackHeight, entity attacker ) {
	float	arrivalDelay;
	float	arrivalDelayRandom;
	vector	dir;
	vector	endPos;
	
	targetBase				= target;
	targetBase_z			= attackHeight;

	owner					= attacker;
	setGameTeam( attacker.getGameTeam() );

	arrivalDelay			= getFloatKey( "arrivaldelay" );
	arrivalDelayRandom		= getFloatKey( "arrivaldelay_random" );

	if( arrivalDelayRandom < arrivalDelay ) {
		arrivalDelayRandom	= arrivalDelay;
	}
	arrivalDelay			= arrivalDelay + sys.random( arrivalDelayRandom );

	beamDuration			= getFloatKey( "beam_duration" );

	dir = sys.vecNormalize( attackDir );

	startPos = target - dir * 0.5f * beamAreaLength;
	sys.tracePoint( target, startPos, MASK_SOLID | MASK_OPAQUE, $null_entity );
	startPos = sys.getTraceEndPos();

	endPos = target + dir * beamAreaLength;
	sys.tracePoint( target, endPos, MASK_SOLID | MASK_OPAQUE, $null_entity );
	endPos = sys.getTraceEndPos();

	// set proper flight height
	endPos_z	= attackHeight + 3072.f;
	startPos_z	= attackHeight + 3072.f;

	beamDir = endPos - startPos;

	beamStartTime = sys.getTime() + arrivalDelay + beamStartupDuration;

	// initalise position
	setOrigin( startPos );
	
	CreateFiringMarker();
}

void vehicle_violator::Update() {
	float	currentTime = sys.getTime();
	float	frac;
	vector	currentPos;
	vector	angles;
	object	traceObject;
	vector	traceEndPos;
	vector	traceNormal;
	entity	collisionEnt;

	if ( beamStartTime < 0 || currentTime < beamStartTime - beamStartupDuration ) {
		return;
	}

	if ( currentTime < beamStartTime ) {
		frac = 0.0f;
	} else {
		frac = ( currentTime - beamStartTime ) / beamDuration;
		
		if ( !directionMarkerFaded ) {
			if ( frac > 0.6f ) {
				directionMarkerFaded = true;
				FadeDirectionMarkers( 0.5f, 1.0f, 0.0f );
			}
		}
		
		if ( frac >= 1.0f ) {
			if ( currentTime - beamStartTime - beamDuration > 6 ) {
				// give it some time for the particles to die
				if ( beamStartEffect != $null_entity ) {
					beamStartEffect.remove();
					beamStartEffect = $null_entity;
				}
				if ( beamEffect != $null_entity ) {
					beamEffect.remove();
					beamEffect = $null_entity;
				}

				if ( !sys.isClient() ) {
					remove();
				}

				return;
			}
		}
	}
	
	if ( frac < 1.0f ) {
		CreateDirectionMarkers( startPos, startPos + beamDir );
		
		frac = sys.getTableValueExact( movementTableIndex, frac );
	}

	currentPos = startPos + ( beamDir * frac );

	setOrigin( currentPos );

	sys.tracePoint( currentPos, currentPos + ( vec3_down * MAX_WORLD_SIZE ), MASK_SHOT_RENDERMODEL, $null_entity );
	string surfaceTypeName = sys.getTraceSurfaceType();
	traceEndPos = sys.getTraceEndPos();
	traceNormal = sys.getTraceNormal();
	collisionEnt = sys.getTraceEntity();

	if( !beamSoundsThread ) {
		beamSoundsThread = true;
		thread BeamSounds();
	}

	// beam visualisation

	if ( currentTime < beamStartTime ) {
		// beam start effect
		if ( beamStartEffect == $null_entity ) {
			beamStartEffect = spawnClientEffect( "fx_beam_start" );
			if ( beamStartEffect != $null_entity ) {
				beamStartEffectPlaying = true;
			}
		}

		if ( currentTime > ( beamStartTime - beamCoreStartupDuration ) ) {
			if ( beamEffect == $null_entity ) {
				beamEffect = spawnClientEffect( "fx_beam" );
				if ( beamEffect != $null_entity ) {
					beamEffectPlaying = true;

					beamEffect.setEffectLooping( 1 );
				}
			}
		}
	} else {
		if ( currentTime > ( beamStartTime + beamDuration - beamEffectFizzleDuration ) ) {			// Xian Hack
			if ( beamEffectPlaying ) {
				beamEffect.endEffect( false );
				beamEffectPlaying = false;
			}
		} else {
			if ( beamStartEffectPlaying ) {
				beamStartEffect.endEffect( false );
				beamStartEffectPlaying = false;
			}

		/*	if ( beamEffect == $null_entity ) {
				beamEffect = spawnClientEffect( "fx_beam" );
				beamEffect.setEffectLooping( 1 );
				beamEffect.setAngles( sys.vecToAngles( vec3_up ) );
			}*/
		}
	}
	
	if ( beamStartEffect != $null_entity ) {
		beamStartEffect.setOrigin( traceEndPos );
		
		float acceleration = beamRotationSpeed / beamStartupDuration;
		float time = currentTime - ( beamStartTime - beamStartupDuration );
		
		angles_x = -90;
		angles_y = 0.5 * acceleration * time * time;
		angles_z = 0;
		
		beamStartEffect.setAngles( angles );
	}
	
	if ( beamEffect != $null_entity ) {
		beamEffect.setOrigin( traceEndPos );
		
		angles_x = -90;
		angles_y = beamRotationSpeed * currentTime;
		angles_z = 0;

		beamEffect.setAngles( angles );
		
		if ( sys.getTime() >= ( lastGroundEffectsTime + 0.3f ) ) {
			sys.tracePoint( currentPos, currentPos + ( vec3_down * MAX_WORLD_SIZE ), MASK_SHOT_RENDERMODEL|CONTENTS_WATER, $null_entity );
			string fxsurfaceTypeName = sys.getTraceSurfaceType();
			vector fxtraceEndPos = sys.getTraceEndPos();
			vector fxtraceNormal = sys.getTraceNormal();
			
			float beamTime = beamStartTime + ( beamDuration + 3.5 ) - beamFizzleDuration;		// Xian Hack
			if ( currentTime < beamTime ) {
				playOriginEffect( "fx_groundeffect", fxsurfaceTypeName, fxtraceEndPos, fxtraceNormal, 0 );
				lastGroundEffectsTime = sys.getTime();
			}
		}
		
	}

	if ( !sys.isClient() ) {
		float damageScale;

		float fizzleStartTime = beamStartTime + beamDuration - beamFizzleDuration;

		if ( currentTime < beamStartTime ) {
			damageScale = 0.0f;
		} else if ( currentTime > fizzleStartTime ) {
			damageScale = 1.0f - ( ( currentTime - fizzleStartTime ) / beamFizzleDuration );
		} else {
			damageScale = 1.0f;
		}

		if ( damageScale > 0.0f ) {
			if ( collisionEnt != $null_entity ) {
				collisionEnt.applyDamage( self, owner, vec3_down, GetDamage( "damage_violator" ), damageScale, traceObject );
			}
			sys.applyRadiusDamage( traceEndPos + ( vec3_up * 64.0f ), self, owner, $null_entity, self, splashDamage, damageScale, 1.f );
		}
	}
}

void vehicle_violator::destroy() {
	ClearFiringMarker();

	if ( beamStartEffect != $null_entity ) {
		beamStartEffect.remove();
	}
	if ( beamEffect != $null_entity ) {
		beamEffect.remove();
	}

	RemoveDirectionMarkers();
}

void vehicle_violator::BeamSounds() {
	boolean	playingBeamSound;

	float beamTime = sys.getTime() + ( beamDuration + 3.5 ) - beamFizzleDuration;		// Xian Hack

	while ( sys.getTime() < beamTime ) {
		sys.waitFrame();

		if( !playingBeamSound ) {
			playingBeamSound = true;
			startSound( "snd_beam_start", SND_VEHICLE );
		}
	}

	startSound( "snd_beam_stop", SND_VEHICLE );
}

void vehicle_violator::CreateFiringMarker() {
	if ( !sys.isClient() ) {
		firingMarker = G_CreateFiringMarker( self, firingMarker, targetBase );
	}
}

void vehicle_violator::ClearFiringMarker() {
	if ( firingMarker != $null_entity ) {
		thread G_DelayRemoveEntity( firingMarker, 5.f );
		firingMarker = $null_entity;
	}
}

void vehicle_violator::CreateDirectionMarkers( vector startPosition, vector endPosition ) {
	if ( directionMarkerDrawn ) {
		return;
	}
	
	directionMarkerDrawn = true;
	directionMarkerStartTime = sys.getTime();

	entity p = sys.getLocalViewPlayer();
	if ( p == $null_entity ) {
		return;
	}

	if ( getEntityAllegiance( p ) != TA_FRIEND ) {
		return;
	}

	string entityDef = getKey( "def_directionmarker" );
	if ( entityDef == "" ) {
		return;
	}

	vector targetDir = endPosition - startPosition;
	vector basePosition = startPosition + 0.5f * targetDir;
	targetDir = sys.vecNormalize( targetDir );

	vector half;
	float halfLength;

	basePosition_z = startPosition_z;

	// calculate marker start position
	half = basePosition - startPosition;
	halfLength = min( sys.vecLength( half ), 2048.0f );
	
	vector markerStart = basePosition - halfLength * targetDir;

	// calculate marker end position
	half = endPosition - basePosition;
	halfLength = min( sys.vecLength( half ), 2048.0f );
	
	vector markerEnd = basePosition + halfLength * targetDir;

	float markerLength = sys.vecLength( markerEnd - markerStart );
	float numMarkers = rint( markerLength / 256.0f ) + 1.0f;
	
	vector targetStep = targetDir * ( markerLength / numMarkers );
	vector targetPos = markerStart;


	// spawn direction markers
	if ( numMarkers > 0.0f ) {
		directionMarker0 = new direction_marker;
		directionMarker0.Create( 0, entityDef, targetPos, targetDir );
	}
	
#define CREATE_DIRECTION_MARKER( index )											\
	if ( numMarkers > (index) ) {													\
		targetPos += targetStep;													\
		directionMarker##index = new direction_marker;								\
		directionMarker##index.Create( (index), entityDef, targetPos, targetDir );	\
	}
	
	CREATE_DIRECTION_MARKER( 1 )
	CREATE_DIRECTION_MARKER( 2 )
	CREATE_DIRECTION_MARKER( 3 )
	CREATE_DIRECTION_MARKER( 4 )
	CREATE_DIRECTION_MARKER( 5 )
	CREATE_DIRECTION_MARKER( 6 )
	CREATE_DIRECTION_MARKER( 7 )
	CREATE_DIRECTION_MARKER( 8 )
	CREATE_DIRECTION_MARKER( 9 )
	CREATE_DIRECTION_MARKER( 10 )
	CREATE_DIRECTION_MARKER( 11 )
	CREATE_DIRECTION_MARKER( 12 )
	CREATE_DIRECTION_MARKER( 13 )
	CREATE_DIRECTION_MARKER( 14 )
	CREATE_DIRECTION_MARKER( 15 )
	CREATE_DIRECTION_MARKER( 16 )
	CREATE_DIRECTION_MARKER( 17 )
	CREATE_DIRECTION_MARKER( 18 )
	CREATE_DIRECTION_MARKER( 19 )
	
#undef CREATE_DIRECTION_MARKER

	FadeDirectionMarkers( 0.3f, 0.0f, 1.0f );
	PulseDirectionMarkers( 0.0f );	// force an update

	thread DirectionMarkerThread();
}

void vehicle_violator::FadeDirectionMarkers( float duration, float start, float end ) {
	if ( !directionMarkerDrawn ) {
		return;
	}
	
	float currentTime = sys.getTime() - directionMarkerStartTime;
	
#define FADE_DIRECTION_MARKER( index )										\
	if ( directionMarker##index != $null ) {								\
		directionMarker##index.Fade( currentTime, duration, start, end );	\
	}

	FADE_DIRECTION_MARKER( 0 )
	FADE_DIRECTION_MARKER( 1 )
	FADE_DIRECTION_MARKER( 2 )
	FADE_DIRECTION_MARKER( 3 )
	FADE_DIRECTION_MARKER( 4 )
	FADE_DIRECTION_MARKER( 5 )
	FADE_DIRECTION_MARKER( 6 )
	FADE_DIRECTION_MARKER( 7 )
	FADE_DIRECTION_MARKER( 8 )
	FADE_DIRECTION_MARKER( 9 )
	FADE_DIRECTION_MARKER( 10 )
	FADE_DIRECTION_MARKER( 11 )
	FADE_DIRECTION_MARKER( 12 )
	FADE_DIRECTION_MARKER( 13 )
	FADE_DIRECTION_MARKER( 14 )
	FADE_DIRECTION_MARKER( 15 )
	FADE_DIRECTION_MARKER( 16 )
	FADE_DIRECTION_MARKER( 17 )
	FADE_DIRECTION_MARKER( 18 )
	FADE_DIRECTION_MARKER( 19 )

#undef FADE_DIRECTION_MARKER
}

void vehicle_violator::RemoveDirectionMarkers() {
	sys.killThread( "DirectionMarkerThread_" + getName() );

	directionMarkerDrawn = false;
	
#define DELETE_DIRECTION_MARKER( index )		\
	if ( directionMarker##index != $null ) {	\
		delete directionMarker##index;			\
		directionMarker##index = $null;			\
	}
	
	DELETE_DIRECTION_MARKER( 0 )
	DELETE_DIRECTION_MARKER( 1 )
	DELETE_DIRECTION_MARKER( 2 )
	DELETE_DIRECTION_MARKER( 3 )
	DELETE_DIRECTION_MARKER( 4 )
	DELETE_DIRECTION_MARKER( 5 )
	DELETE_DIRECTION_MARKER( 6 )
	DELETE_DIRECTION_MARKER( 7 )
	DELETE_DIRECTION_MARKER( 8 )
	DELETE_DIRECTION_MARKER( 9 )
	DELETE_DIRECTION_MARKER( 10 )
	DELETE_DIRECTION_MARKER( 11 )
	DELETE_DIRECTION_MARKER( 12 )
	DELETE_DIRECTION_MARKER( 13 )
	DELETE_DIRECTION_MARKER( 14 )
	DELETE_DIRECTION_MARKER( 15 )
	DELETE_DIRECTION_MARKER( 16 )
	DELETE_DIRECTION_MARKER( 17 )
	DELETE_DIRECTION_MARKER( 18 )
	DELETE_DIRECTION_MARKER( 19 )
	
#undef DELETE_DIRECTION_MARKER
}

void vehicle_violator::PulseDirectionMarkers( float currentTime ) {
	if ( !directionMarkerDrawn ) {
		return;
	}

	float pulseTime = currentTime - directionMarkerStartTime;

#define UPDATE_DIRECTION_MARKER( index )			\
	if ( directionMarker##index != $null ) {		\
		directionMarker##index.Update( pulseTime );	\
	}

	UPDATE_DIRECTION_MARKER( 0 )
	UPDATE_DIRECTION_MARKER( 1 )
	UPDATE_DIRECTION_MARKER( 2 )
	UPDATE_DIRECTION_MARKER( 3 )
	UPDATE_DIRECTION_MARKER( 4 )
	UPDATE_DIRECTION_MARKER( 5 )
	UPDATE_DIRECTION_MARKER( 6 )
	UPDATE_DIRECTION_MARKER( 7 )
	UPDATE_DIRECTION_MARKER( 8 )
	UPDATE_DIRECTION_MARKER( 9 )
	UPDATE_DIRECTION_MARKER( 10 )
	UPDATE_DIRECTION_MARKER( 11 )
	UPDATE_DIRECTION_MARKER( 12 )
	UPDATE_DIRECTION_MARKER( 13 )
	UPDATE_DIRECTION_MARKER( 14 )
	UPDATE_DIRECTION_MARKER( 15 )
	UPDATE_DIRECTION_MARKER( 16 )
	UPDATE_DIRECTION_MARKER( 17 )
	UPDATE_DIRECTION_MARKER( 18 )
	UPDATE_DIRECTION_MARKER( 19 )

#undef UPDATE_DIRECTION_MARKER
}

void vehicle_violator::DirectionMarkerThread() {
	while ( true ) {
		if ( directionMarkerDrawn ) {
			float currentTime = sys.getTime();

			PulseDirectionMarkers( currentTime );
		}
		
		sys.waitFrame();
	}
}