Wizz at 10:16, 5 November 2007

2007-11-05T10:16:13Z

New page

object [[ScriptClass:scud_trigger|scud_trigger]] : [[ScriptClass:hackable_objective|hackable_objective]] {
void syncFields();

void OnHacked( entity p );

void vSetActive( boolean value );

boolean TryFire( entity firer );
void FireThread( entity firer );
void FireThreadFake();
void TrackScud();

void vSetTargetEntity( entity ent );
void vSetOwner( entity ent );
void vStartObjective();

void OnActiveChanged();
void OnPostMapSpawn();
void OnObjectiveIndexChanged();
void OnScudChanged();

void DestroyTarget( entity targetEnt );
void SpawnDestroyEffect( vector position );

entity targetEnt;
entity owner;
entity trackingScud;

boolean active;

boolean AllowHack() { return active; }
}

void [[ScriptClass:scud_trigger|scud_trigger]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "objectiveIndex" );
[[ScriptEvent:syncCallback|syncCallback]]( "objectiveIndex", "OnObjectiveIndexChanged" );

[[ScriptEvent:syncBroadcast|syncBroadcast]]( "trackingScud" );
[[ScriptEvent:syncCallback|syncCallback]]( "trackingScud", "OnScudChanged" );

[[ScriptEvent:syncBroadcast|syncBroadcast]]( "active" );
[[ScriptEvent:syncCallback|syncCallback]]( "active", "OnActiveChanged" );

[[ScriptEvent:syncBroadcast|syncBroadcast]]( "owner" );
}

void [[ScriptClass:scud_trigger|scud_trigger]]::OnObjectiveIndexChanged() {
SetObjectiveIndex( objectiveIndex );
}

void [[ScriptClass:scud_trigger|scud_trigger]]::OnScudChanged() {
if ( trackingScud != $null_entity ) {
thread TrackScud();
}
}

void [[ScriptClass:scud_trigger|scud_trigger]]::OnPostMapSpawn() {
// TEMP: for old style shields
targetEnt = [[ScriptEvent:getEntityKey|getEntityKey]]( "target" );
}

void [[ScriptClass:scud_trigger|scud_trigger]]::OnActiveChanged() {
if ( active ) {
[[ScriptEvent:setShaderParm|setShaderParm]]( 7, 1 );
} else {
[[ScriptEvent:setShaderParm|setShaderParm]]( 7, 0 );
}
}

void [[ScriptClass:scud_trigger|scud_trigger]]::vSetActive( boolean value ) {
if ( active == value ) {
return;
}
active = value;
OnActiveChanged();
}

void [[ScriptClass:scud_trigger|scud_trigger]]::OnHacked( entity p ) {
owner.vSetActive( true );
vSetActive( false );

object oldTeam = [[ScriptEvent:getGameTeam|getGameTeam]]();
object newTeam = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
[[ScriptEvent:setGameTeam|setGameTeam]]( newTeam );

objManager.OnHackComplete( self );

if ( p != $null_entity ) {
string statName = newTeam.[[ScriptEvent:getName|getName]]() + "_primary_objective_hacked";
sys.[[ScriptEvent:increaseStatInt|increaseStatInt]]( sys.[[ScriptEvent:allocStatInt|allocStatInt]]( statName ), p.[[ScriptEvent:getEntityNumber|getEntityNumber]](), 1 );
statName = newTeam.[[ScriptEvent:getName|getName]]() + "_hack_uses";
sys.[[ScriptEvent:increaseStatInt|increaseStatInt]]( sys.[[ScriptEvent:allocStatInt|allocStatInt]]( statName ), p.[[ScriptEvent:getEntityNumber|getEntityNumber]](), 1 );
}

objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_hacked_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_hacked_gdf" ), gdfTeam );

thread FireThread( p );
}

boolean [[ScriptClass:scud_trigger|scud_trigger]]::TryFire( entity firer ) {
// set any MCP up to fire
if ( G_TryFireScud( firer, targetEnt ) ) {
return true;
}

return false;
}

void [[ScriptClass:scud_trigger|scud_trigger]]::FireThread( entity firer ) {
sys.[[ScriptEvent:wait|wait]]( 5.f );

if ( !TryFire( firer ) ) {
objManager.CPrintEvent( sys.[[ScriptEvent:localizeString|localizeString]]( "game/misc/shield_generator_hacked_reenable" ), gdfTeam );
objManager.CPrintEvent( sys.[[ScriptEvent:localizeString|localizeString]]( "game/misc/shield_generator_hacked_attack" ), stroggTeam );

while ( true ) {
if ( TryFire( firer ) ) {
break;
}
sys.[[ScriptEvent:wait|wait]]( 0.2f );
}
}

objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_launched_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_launched_gdf" ), gdfTeam );
}

void [[ScriptClass:scud_trigger|scud_trigger]]::FireThreadFake() {
sys.[[ScriptEvent:wait|wait]]( 5.f );

while ( true ) {
if ( TryFire( $null_entity ) ) {
break;
}
sys.[[ScriptEvent:wait|wait]]( 0.2f );
}

objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_launched_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_launched_gdf" ), gdfTeam );

while ( true ) {
float count = [[ScriptEvent:entitiesOfCollection|entitiesOfCollection]]( "nuke" );
if ( count > 0 ) {
trackingScud = [[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( 0 );
break;
}

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

TrackScud();
}

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

if ( trackingScud == $null_entity ) {
return;
}

float range = sys.[[ScriptEvent:vecLength|vecLength]]( trackingScud.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() - [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );

if ( range > 6144.f ) {
continue;
}

DestroyTarget( trackingScud );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_stopped_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_stopped_gdf" ), gdfTeam );

objManager.OnShieldDestroyedScud( self );
}

break;
}
}

void [[ScriptClass:scud_trigger|scud_trigger]]::DestroyTarget( entity targetEnt ) {
if ( targetEnt.vGetDestroyed() ) {
return;
}

SpawnDestroyEffect( targetEnt.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
targetEnt.vSetDestroyed();
}

void [[ScriptClass:scud_trigger|scud_trigger]]::SpawnDestroyEffect( vector position ) {
vector startPos = owner.[[ScriptEvent:getJointPos|getJointPos]]( owner.[[ScriptEvent:getJointHandle|getJointHandle]]( "top_comprezzor_joint" ) ); // start at the roof of the deployable
vector diff = startPos - position;
vector forward = '1 0 0';
diff = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( diff );
vector angles = sys.[[ScriptEvent:vecToAngles|vecToAngles]]( diff );

// Charge up and cool down effect
owner.[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_charge", "", startPos, forward, false );

// The electrial beam and shockwave
object effect = owner.[[ScriptEvent:spawnClientEffect|spawnClientEffect]]( "fx_hit" );
if ( effect != $null_entity ) {
effect.[[ScriptEvent:setEffectLooping|setEffectLooping]]( 0 );
effect.[[ScriptEvent:setOrigin|setOrigin]]( position );
effect.[[ScriptEvent:setEffectEndOrigin|setEffectEndOrigin]]( startPos );
effect.[[ScriptEvent:setAngles|setAngles]]( angles );
}
}

void [[ScriptClass:scud_trigger|scud_trigger]]::vSetOwner( entity ent ) {
owner = ent;
}

void [[ScriptClass:scud_trigger|scud_trigger]]::vSetTargetEntity( entity ent ) {
targetEnt = ent;
}

void [[ScriptClass:scud_trigger|scud_trigger]]::vStartObjective() {
thread FireThreadFake();
}

object [[ScriptClass:scud_trigger_structure|scud_trigger_structure]] {
void preinit();
void syncFields();

void vOnDeploy();
void vSetOwner( entity ent );
void vSetActive( boolean value );

void OnDeadChanged();

void BoundsKillThread();

void InitEffectThread();

string vGetQuickChatString( entity p );

[[ScriptClass:scud_trigger|scud_trigger]] triggerEnt;
entity targetEnt;
float objectiveIndex;

boolean dead;

vector effectOffset;
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::preinit() {
effectOffset = [[ScriptEvent:getVectorKey|getVectorKey]]( "effect_offset" );

thread InitEffectThread();

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

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "dead" );
[[ScriptEvent:syncCallback|syncCallback]]( "dead", "OnDeadChanged" );
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::OnDeadChanged() {
if ( dead ) {
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "destroyed" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_active" );
} else {
[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "idle" );
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_active", "", [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + effectOffset, '1 0 0', true );
}
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::BoundsKillThread() {
float damageIndex = GetDamage( [[ScriptEvent:getKey|getKey]]( "dmg_crush" ) );

while ( true ) {
BoundsDamage( self, damageIndex );
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::vSetActive( boolean value ) {
if ( dead == value ) {
return;
}
dead = value;

OnDeadChanged();
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::vOnDeploy() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
triggerEnt = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( "def_trigger" ) );
triggerEnt.[[ScriptEvent:setOrigin|setOrigin]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
triggerEnt.[[ScriptEvent:setAngles|setAngles]]( [[ScriptEvent:getAngles|getAngles]]() );
triggerEnt.[[ScriptEvent:setGameTeam|setGameTeam]]( [[ScriptEvent:getGameTeam|getGameTeam]]() );
triggerEnt.vSetTargetEntity( targetEnt );
triggerEnt.vSetOwner( self );
triggerEnt.SetObjectiveIndex( objectiveIndex );

objManager.OnShieldDeployed( self, triggerEnt );

sys.[[ScriptEvent:killThread|killThread]]( "BoundsKillThread_" + [[ScriptEvent:getName|getName]]() );
}

sys.[[ScriptEvent:killThread|killThread]]( "InitEffectThread_" + [[ScriptEvent:getName|getName]]() );

if ( !dead ) {
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_active", "", [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + effectOffset, '1 0 0', true );
}
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::vSetOwner( entity ent ) {
targetEnt = ent.[[ScriptEvent:getEntityKey|getEntityKey]]( "target" );
objectiveIndex = ent.[[ScriptEvent:getIntKey|getIntKey]]( "objective_index" );
}

void [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::InitEffectThread() {
sys.[[ScriptEvent:wait|wait]]( 5 );
OnDeadChanged();
}

string [[ScriptClass:scud_trigger_structure|scud_trigger_structure]]::vGetQuickChatString( entity p ) {
return triggerEnt.vGetQuickChatString( p );
}

Script:Files:script/maps/generic/scud trigger.script - Revision history

Wizz at 10:16, 5 November 2007