Wizz at 09:59, 5 November 2007

2007-11-05T09:59:02Z

New page

object [[ScriptClass:vehicle_violator|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;
[[ScriptClass:direction_marker|direction_marker]] directionMarker0;
[[ScriptClass:direction_marker|direction_marker]] directionMarker1;
[[ScriptClass:direction_marker|direction_marker]] directionMarker2;
[[ScriptClass:direction_marker|direction_marker]] directionMarker3;
[[ScriptClass:direction_marker|direction_marker]] directionMarker4;
[[ScriptClass:direction_marker|direction_marker]] directionMarker5;
[[ScriptClass:direction_marker|direction_marker]] directionMarker6;
[[ScriptClass:direction_marker|direction_marker]] directionMarker7;
[[ScriptClass:direction_marker|direction_marker]] directionMarker8;
[[ScriptClass:direction_marker|direction_marker]] directionMarker9;
[[ScriptClass:direction_marker|direction_marker]] directionMarker10;
[[ScriptClass:direction_marker|direction_marker]] directionMarker11;
[[ScriptClass:direction_marker|direction_marker]] directionMarker12;
[[ScriptClass:direction_marker|direction_marker]] directionMarker13;
[[ScriptClass:direction_marker|direction_marker]] directionMarker14;
[[ScriptClass:direction_marker|direction_marker]] directionMarker15;
[[ScriptClass:direction_marker|direction_marker]] directionMarker16;
[[ScriptClass:direction_marker|direction_marker]] directionMarker17;
[[ScriptClass:direction_marker|direction_marker]] directionMarker18;
[[ScriptClass:direction_marker|direction_marker]] directionMarker19;
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "startPos" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "beamDir" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "beamStartTime" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "owner" );
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::preinit() {
beamStartTime = -1;

lastGroundEffectsTime = -1.f;

beamStartupDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_startup_duration" );
beamCoreStartupDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_core_startup_duration" );
beamDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_duration" );
beamFizzleDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_fizzle_duration" );
beamEffectFizzleDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_effect_fizzle_duration" );

beamRotationSpeed = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_rotation_speed" );

splashDamage = GetDamage( "damage_violator_splash" );

beamStartEffectPlaying = false;
beamEffectPlaying = false;

beamAreaLength = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_area_length" );

movementTableIndex = GetTable( "exp_x2" );
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::init() {
[[ScriptEvent:hide|hide]]();
[[ScriptEvent:setState|setState]]( "Idle" );
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::Idle() {
while( true ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();

Update();
}
}

void [[ScriptClass:vehicle_violator|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;
[[ScriptEvent:setGameTeam|setGameTeam]]( attacker.[[ScriptEvent:getGameTeam|getGameTeam]]() );

arrivalDelay = [[ScriptEvent:getFloatKey|getFloatKey]]( "arrivaldelay" );
arrivalDelayRandom = [[ScriptEvent:getFloatKey|getFloatKey]]( "arrivaldelay_random" );

if( arrivalDelayRandom < arrivalDelay ) {
arrivalDelayRandom = arrivalDelay;
}
arrivalDelay = arrivalDelay + sys.[[ScriptEvent:random|random]]( arrivalDelayRandom );

beamDuration = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_duration" );

dir = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( attackDir );

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

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

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

beamDir = endPos - startPos;

beamStartTime = sys.[[ScriptEvent:getTime|getTime]]() + arrivalDelay + beamStartupDuration;

// initalise position
[[ScriptEvent:setOrigin|setOrigin]]( startPos );

CreateFiringMarker();
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::Update() {
float currentTime = sys.[[ScriptEvent:getTime|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.[[ScriptEvent:remove|remove]]();
beamStartEffect = $null_entity;
}
if ( beamEffect != $null_entity ) {
beamEffect.[[ScriptEvent:remove|remove]]();
beamEffect = $null_entity;
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptEvent:remove|remove]]();
}

return;
}
}
}

if ( frac < 1.0f ) {
CreateDirectionMarkers( startPos, startPos + beamDir );

frac = sys.[[ScriptEvent:getTableValueExact|getTableValueExact]]( movementTableIndex, frac );
}

currentPos = startPos + ( beamDir * frac );

[[ScriptEvent:setOrigin|setOrigin]]( currentPos );

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

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

// beam visualisation

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

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

beamEffect.[[ScriptEvent:setEffectLooping|setEffectLooping]]( 1 );
}
}
}
} else {
if ( currentTime > ( beamStartTime + beamDuration - beamEffectFizzleDuration ) ) { // Xian Hack
if ( beamEffectPlaying ) {
beamEffect.[[ScriptEvent:endEffect|endEffect]]( false );
beamEffectPlaying = false;
}
} else {
if ( beamStartEffectPlaying ) {
beamStartEffect.[[ScriptEvent:endEffect|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.[[ScriptEvent:setOrigin|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.[[ScriptEvent:setAngles|setAngles]]( angles );
}

if ( beamEffect != $null_entity ) {
beamEffect.[[ScriptEvent:setOrigin|setOrigin]]( traceEndPos );

angles_x = -90;
angles_y = beamRotationSpeed * currentTime;
angles_z = 0;

beamEffect.[[ScriptEvent:setAngles|setAngles]]( angles );

if ( sys.[[ScriptEvent:getTime|getTime]]() >= ( lastGroundEffectsTime + 0.3f ) ) {
sys.[[ScriptEvent:tracePoint|tracePoint]]( currentPos, currentPos + ( vec3_down * MAX_WORLD_SIZE ), MASK_SHOT_RENDERMODEL|CONTENTS_WATER, $null_entity );
string fxsurfaceTypeName = sys.[[ScriptEvent:getTraceSurfaceType|getTraceSurfaceType]]();
vector fxtraceEndPos = sys.[[ScriptEvent:getTraceEndPos|getTraceEndPos]]();
vector fxtraceNormal = sys.[[ScriptEvent:getTraceNormal|getTraceNormal]]();

float beamTime = beamStartTime + ( beamDuration + 3.5 ) - beamFizzleDuration; // Xian Hack
if ( currentTime < beamTime ) {
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_groundeffect", fxsurfaceTypeName, fxtraceEndPos, fxtraceNormal, 0 );
lastGroundEffectsTime = sys.[[ScriptEvent:getTime|getTime]]();
}
}

}

if ( !sys.[[ScriptEvent:isClient|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.[[ScriptEvent:applyDamage|applyDamage]]( self, owner, vec3_down, GetDamage( "damage_violator" ), damageScale, traceObject );
}
sys.[[ScriptEvent:applyRadiusDamage|applyRadiusDamage]]( traceEndPos + ( vec3_up * 64.0f ), self, owner, $null_entity, self, splashDamage, damageScale, 1.f );
}
}
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::destroy() {
ClearFiringMarker();

if ( beamStartEffect != $null_entity ) {
beamStartEffect.[[ScriptEvent:remove|remove]]();
}
if ( beamEffect != $null_entity ) {
beamEffect.[[ScriptEvent:remove|remove]]();
}

RemoveDirectionMarkers();
}

void [[ScriptClass:vehicle_violator|vehicle_violator]]::BeamSounds() {
boolean playingBeamSound;

float beamTime = sys.[[ScriptEvent:getTime|getTime]]() + ( beamDuration + 3.5 ) - beamFizzleDuration; // Xian Hack

while ( sys.[[ScriptEvent:getTime|getTime]]() < beamTime ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();

if( !playingBeamSound ) {
playingBeamSound = true;
[[ScriptEvent:startSound|startSound]]( "snd_beam_start", SND_VEHICLE );
}
}

[[ScriptEvent:startSound|startSound]]( "snd_beam_stop", SND_VEHICLE );
}

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

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

void [[ScriptClass:vehicle_violator|vehicle_violator]]::CreateDirectionMarkers( vector startPosition, vector endPosition ) {
if ( directionMarkerDrawn ) {
return;
}

directionMarkerDrawn = true;
directionMarkerStartTime = sys.[[ScriptEvent:getTime|getTime]]();

entity p = sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]();
if ( p == $null_entity ) {
return;
}

if ( [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p ) != TA_FRIEND ) {
return;
}

string entityDef = [[ScriptEvent:getKey|getKey]]( "def_directionmarker" );
if ( entityDef == "" ) {
return;
}

vector targetDir = endPosition - startPosition;
vector basePosition = startPosition + 0.5f * targetDir;
targetDir = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( targetDir );

vector half;
float halfLength;

basePosition_z = startPosition_z;

// calculate marker start position
half = basePosition - startPosition;
halfLength = min( sys.[[ScriptEvent:vecLength|vecLength]]( half ), 2048.0f );

vector markerStart = basePosition - halfLength * targetDir;

// calculate marker end position
half = endPosition - basePosition;
halfLength = min( sys.[[ScriptEvent:vecLength|vecLength]]( half ), 2048.0f );

vector markerEnd = basePosition + halfLength * targetDir;

float markerLength = sys.[[ScriptEvent:vecLength|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 [[ScriptClass:direction_marker|direction_marker]];
directionMarker0.Create( 0, entityDef, targetPos, targetDir );
}

#define CREATE_DIRECTION_MARKER( index ) \
if ( numMarkers > (index) ) { \
targetPos += targetStep; \
directionMarker##index = new [[ScriptClass:direction_marker|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 [[ScriptClass:vehicle_violator|vehicle_violator]]::FadeDirectionMarkers( float duration, float start, float end ) {
if ( !directionMarkerDrawn ) {
return;
}

float currentTime = sys.[[ScriptEvent:getTime|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 [[ScriptClass:vehicle_violator|vehicle_violator]]::RemoveDirectionMarkers() {
sys.[[ScriptEvent:killThread|killThread]]( "DirectionMarkerThread_" + [[ScriptEvent:getName|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 [[ScriptClass:vehicle_violator|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 [[ScriptClass:vehicle_violator|vehicle_violator]]::DirectionMarkerThread() {
while ( true ) {
if ( directionMarkerDrawn ) {
float currentTime = sys.[[ScriptEvent:getTime|getTime]]();

PulseDirectionMarkers( currentTime );
}

sys.[[ScriptEvent:waitFrame|waitFrame]]();
}
}

Script:Files:script/vehicles/violator.script - Revision history

Wizz at 09:59, 5 November 2007