Wizz at 10:16, 5 November 2007

2007-11-05T10:16:01Z

New page

// Zappor: Strogg thing that calls down a giant airstrike

#define ZA_DEPLOY 1
#define ZA_IDLE_DAMAGED 2
#define ZA_STARTFIRE 3
#define ZA_FIRING 4
#define ZA_FIRED 5

object [[ScriptClass:mining_laser_beacon|mining_laser_beacon]] {
void SetEntities( entity o, entity l );
}

object [[ScriptClass:mining_laser_objective|mining_laser_objective]] : [[ScriptClass:constructible_materials|constructible_materials]] {
void preinit();

void SetupConstruction();

void OnConstructionFinished( entity p );
void DoZap( entity p );
void SetEntities( entity o, entity l );

float OnUpdateCrosshairInfo( entity p );

entity deployer;
entity laser;
boolean hasZapped;

handle constructedMessage;

handle objectName;
}

void [[ScriptClass:mining_laser_objective|mining_laser_objective]]::preinit() {
forceShowProgress = true;
constructedMessage = sys.[[ScriptEvent:localizeString|localizeString]]( "maps/generic/zappor/constructed" );
objectName = sys.[[ScriptEvent:localizeString|localizeString]]( [[ScriptEvent:getKey|getKey]]( "object_name" ) );
}

void [[ScriptClass:mining_laser_objective|mining_laser_objective]]::SetupConstruction() {
multipleStages = false;

if ( sys.[[ScriptEvent:isClient|isClient]]() ) {
OnStateChanged();
return;
}

firstStage = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( "def_construction" ) );
firstStage.[[ScriptEvent:setOrigin|setOrigin]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
firstStage.[[ScriptEvent:setAngles|setAngles]]( [[ScriptEvent:getAngles|getAngles]]() );
firstStage.[[ScriptEvent:setGameTeam|setGameTeam]]( [[ScriptEvent:getGameTeam|getGameTeam]]() );
firstStage.vSetOwner( self );

SetConstructionState( CSTATE_NONE );
}

void [[ScriptClass:mining_laser_objective|mining_laser_objective]]::OnConstructionFinished( entity p ) {
OnFinishCurrentState( p );
counter = constructionCount;

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
objManager.PushCPrintString( p.[[ScriptEvent:getUserName|getUserName]]() );
objManager.CPrintEvent( constructedMessage, $null );

objManager.OnMiningLaserConstructed( self );

firstStage.[[ScriptEvent:remove|remove]]();

DoZap( p );
}
}

void [[ScriptClass:mining_laser_objective|mining_laser_objective]]::DoZap( entity p ) {
if ( deployer == $null_entity || hasZapped ) {
return;
}

[[ScriptClass:mining_laser_beacon|mining_laser_beacon]] targ = deployer.[[ScriptEvent:getEntityKey|getEntityKey]]( "target" );
if ( targ == $null_entity ) {
sys.[[ScriptEvent:error|error]]( "mining_laser_objective::DoZap could not find target" );
}
targ.SetEntities( p, laser );
targ.vOnDeploy();

hasZapped = true;
}

void [[ScriptClass:mining_laser_objective|mining_laser_objective]]::SetEntities( entity o, entity l ) {
deployer = o;
laser = l;
if ( deployer != $null_entity ) {
vStartObjective();
}
}

float [[ScriptClass:mining_laser_objective|mining_laser_objective]]::OnUpdateCrosshairInfo( entity p ) {
if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() == $null_entity ) {
return 1.f;
}

float allegiance = [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p );
float distance;
if ( deployer != $null_entity ) {
distance = deployer.[[ScriptEvent:chGetDistance|chGetDistance]]();
} else {
distance = [[ScriptEvent:chGetDistance|chGetDistance]]();
}
float range = InchesToMetres( distance );

[[ScriptEvent:chSetNumLines|chSetNumLines]]( 0 );

[[ScriptClass:team_base|team_base]] team;

if ( p.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() && objectiveIndex != -1 ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_info" ) ) );
}

// see if theres a valid action to perform
float code = GetActivateCode( p, distance );
if ( code != AK_NONE && p.vHasActionItem( code ) ) {
float index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineMaterial|chSetLineMaterial]]( index, p.vGetActionIcon( code ) );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_IMAGE );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 64, 64 );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, g_colorWhite, 0.9f );

if ( p.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() ) {
if ( !p.[[ScriptEvent:isToolTipPlaying|isToolTipPlaying]]() ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() - p.[[ScriptEvent:getCrosshairStartTime|getCrosshairStartTime]]() > 1.f ) {
if ( p.[[ScriptEvent:getCurrentWeapon|getCurrentWeapon]]() != p.vGetActionItem( code ) ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip1 );
} else {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip2 );
}
}
}
}
}

vector color = GetAllegianceColor( allegiance );

index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, objectName );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );

if( range <= 100 ) {
index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineText|chSetLineText]]( index, G_BuildRangeStr( range ) );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );
}

return 1.f;
}

object [[ScriptClass:mining_laser|mining_laser]] {
void init();
void syncFields();

void vOnDeploy();
void vSetManualDeploy();
void vSetOwner( entity o );

void DoDeployAnim();
float AnimState( float state );
void OnAnimStateChanged();

void BoundsKillThread();

float OnUpdateCrosshairInfo( entity p );

boolean manualDeploy;
entity deployer;
boolean deployed;

float currentAnimState;

handle objectName;
}

void [[ScriptClass:mining_laser|mining_laser]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "deployed" );
[[ScriptEvent:syncCallback|syncCallback]]( "deployed", "vOnDeploy" );

[[ScriptEvent:syncBroadcast|syncBroadcast]]( "currentAnimState" );
[[ScriptEvent:syncCallback|syncCallback]]( "currentAnimState", "OnAnimStateChanged" );
}

void [[ScriptClass:mining_laser|mining_laser]]::init() {
[[ScriptEvent:setContents|setContents]]( CONTENTS_PLAYERCLIP | CONTENTS_VEHICLECLIP | CONTENTS_FLYERHIVECLIP );

objectName = sys.[[ScriptEvent:localizeString|localizeString]]( [[ScriptEvent:getKey|getKey]]( "object_name" ) );

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

if ( !manualDeploy ) {
vOnDeploy();
}
}

[[ScriptEvent:disableImpact|disableImpact]]();
}

void [[ScriptClass:mining_laser|mining_laser]]::OnAnimStateChanged() {
AnimState( currentAnimState );
}

void [[ScriptClass:mining_laser|mining_laser]]::vOnDeploy() {
deployed = true;
[[ScriptEvent:putToRest|putToRest]]();
[[ScriptEvent:disableImpact|disableImpact]]();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
sys.[[ScriptEvent:killThread|killThread]]( "BoundsKillThread_" + [[ScriptEvent:getName|getName]]() );

[[ScriptClass:mining_laser_objective|mining_laser_objective]] objectiveThing = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( "def_objective" ) );
if ( objectiveThing == $null ) {
sys.[[ScriptEvent:error|error]]( "mining_laser::vOnDeploy failed to spawn objective" );
}
objectiveThing.[[ScriptEvent:setOrigin|setOrigin]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
objectiveThing.[[ScriptEvent:setAngles|setAngles]]( [[ScriptEvent:getAngles|getAngles]]() );
objectiveThing.[[ScriptEvent:setGameTeam|setGameTeam]]( [[ScriptEvent:getGameTeam|getGameTeam]]() );
objectiveThing.SetEntities( deployer, self );
objectiveThing.vOnDeploy();

objManager.OnMiningLaserDeployed( objectiveThing );

thread DoDeployAnim();
}
}

float [[ScriptClass:mining_laser|mining_laser]]::AnimState( float state ) {
currentAnimState = state;

if ( currentAnimState == ZA_DEPLOY ) {
return [[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "deploy" );
}
if ( currentAnimState == ZA_IDLE_DAMAGED ) {
return [[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "idle_damaged" );
}
if ( currentAnimState == ZA_STARTFIRE ) {
return [[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "startfire" );
}
if ( currentAnimState == ZA_FIRING ) {
return [[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "fire" );
}
if ( currentAnimState == ZA_FIRED ) {
return [[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "idle_after_firing" );
}

return 0.f;
}

void [[ScriptClass:mining_laser|mining_laser]]::DoDeployAnim() {
sys.[[ScriptEvent:wait|wait]]( AnimState( ZA_DEPLOY ) );
AnimState( ZA_IDLE_DAMAGED );
}

void [[ScriptClass:mining_laser|mining_laser]]::vSetOwner( entity o ) {
deployer = o;
}

void [[ScriptClass:mining_laser|mining_laser]]::vSetManualDeploy() {
manualDeploy = true;
}

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

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

float [[ScriptClass:mining_laser|mining_laser]]::OnUpdateCrosshairInfo( entity p ) {
if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() == $null_entity ) {
return 1.0f;
}

float allegiance = [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p );
vector color = GetAllegianceColor( allegiance );
float distance;
if ( deployer != $null_entity ) {
distance = deployer.[[ScriptEvent:chGetDistance|chGetDistance]]();
} else {
distance = [[ScriptEvent:chGetDistance|chGetDistance]]();
}
float range = InchesToMetres( distance );

[[ScriptEvent:chSetNumLines|chSetNumLines]]( 0 );
float index;

index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, objectName );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );

if( range <= 100 ) {
index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineText|chSetLineText]]( index, G_BuildRangeStr( range ) );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );
}

return 1.f;
}

object [[ScriptClass:mining_laser_beacon|mining_laser_beacon]] {
void preinit();
void init();
void destroy();

void syncFields();

void Idle();
void Update();

void vOnDeploy();

void OnFiringChanged();

entity destroyTarget;
entity destroyTarget2;

float beamEndTime;
float beamRotationSpeed;

object beamEffect;

float damageIndex;
float splashDamageIndex;

boolean hasFired;
boolean firing;

float muzzleJoint;

entity caller;
[[ScriptClass:mining_laser|mining_laser]] laser;

vector target_offset;
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::preinit() {
beamRotationSpeed = [[ScriptEvent:getFloatKey|getFloatKey]]( "beam_rotation_speed" );
damageIndex = GetDamage( [[ScriptEvent:getKey|getKey]]( "dmg_damage" ) );
splashDamageIndex = GetDamage( [[ScriptEvent:getKey|getKey]]( "dmg_splash_damage" ) );
target_offset = [[ScriptEvent:getVectorKey|getVectorKey]]( "target_offset" );
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::init() {
destroyTarget = [[ScriptEvent:getEntityKey|getEntityKey]]( "target" );
destroyTarget2 = [[ScriptEvent:getEntityKey|getEntityKey]]( "target_secondary" );
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::destroy() {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_beam_impact" );
if ( beamEffect != $null_entity ) {
beamEffect.[[ScriptEvent:remove|remove]]();
beamEffect = $null_entity;
}
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "laser" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "firing" );
[[ScriptEvent:syncCallback|syncCallback]]( "firing", "OnFiringChanged" );
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::vOnDeploy() {
[[ScriptEvent:setState|setState]]( "Idle" );
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::OnFiringChanged() {
if ( firing ) {
[[ScriptEvent:setState|setState]]( "Idle" );
}
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::SetEntities( entity o, entity l ) {
caller = o;
laser = l;
}

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::Idle() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
sys.[[ScriptEvent:wait|wait]]( laser.AnimState( ZA_STARTFIRE ) );

beamEndTime = sys.[[ScriptEvent:getTime|getTime]]() + laser.AnimState( ZA_FIRING );

firing = true;
}

muzzleJoint = laser.[[ScriptEvent:getJointHandle|getJointHandle]]( "muzzle" );

while ( firing ) {
Update();
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
laser.AnimState( ZA_FIRED );
} else {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_beam_impact" );
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_explode", "", [[ScriptEvent:getWorldOrigin|getWorldOrigin]](), [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 ), 0 );
[[ScriptEvent:startSound|startSound]]( "snd_beam_stop", SND_WEAPON_FIRE2 );

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

sys.[[ScriptEvent:wait|wait]]( 10.f );

[[ScriptEvent:stopEffect|stopEffect]]( "fx_beam_impact" );

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

void [[ScriptClass:mining_laser_beacon|mining_laser_beacon]]::Update() {
float currentTime = sys.[[ScriptEvent:getTime|getTime]]();

vector endPos = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]();
vector startPos = laser.[[ScriptEvent:getJointPos|getJointPos]]( muzzleJoint );

float count = [[ScriptEvent:entitiesInTranslation|entitiesInTranslation]]( startPos, endPos, MASK_SHOT_RENDERMODEL | MASK_SHOT_BOUNDINGBOX, $null_entity );

boolean doFire;
if ( sys.[[ScriptEvent:isClient|isClient]]() ) {
doFire = firing;
} else {
doFire = currentTime < beamEndTime;
}

if ( doFire ) {
if ( beamEffect == $null_entity ) {
beamEffect = [[ScriptEvent:spawnClientEffect|spawnClientEffect]]( "fx_beam" );
if ( beamEffect != $null_entity ) {
beamEffect.[[ScriptEvent:setEffectLooping|setEffectLooping]]( 1 );
beamEffect.[[ScriptEvent:setOrigin|setOrigin]]( startPos );
beamEffect.[[ScriptEvent:setEffectEndOrigin|setEffectEndOrigin]]( endPos );
}
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_beam_impact", "", endPos + target_offset, [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 ), true );
[[ScriptEvent:startSound|startSound]]( "snd_beam_start", SND_WEAPON_FIRE2 );
}

float i;
for ( i = 0; i < count; i++ ) {
entity ent = [[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( i );

if ( ent == $null_entity ) {
continue;
}

if ( ent == destroyTarget || ent == destroyTarget2 ) {
continue;
}

ent.[[ScriptEvent:applyDamage|applyDamage]]( self, $null_entity, vec3_down, damageIndex, 1.0f, $null_entity );
}
} else {
firing = false;

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

if ( !hasFired ) {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_beam_impact" );
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_explode", "", endPos, [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 ), 0 );
[[ScriptEvent:startSound|startSound]]( "snd_beam_stop", SND_WEAPON_FIRE2 );
if ( destroyTarget != $null_entity ) {
destroyTarget.[[ScriptEvent:applyDamage|applyDamage]]( self, caller, '0 0 1', damageIndex, 1.0f, $null_entity );
}
if ( destroyTarget2 != $null_entity ) {
destroyTarget2.[[ScriptEvent:applyDamage|applyDamage]]( self, caller, '0 0 1', damageIndex, 1.0f, $null_entity );
}
sys.[[ScriptEvent:applyRadiusDamage|applyRadiusDamage]]( endPos, self, caller, $null_entity, self, splashDamageIndex, 1.f, 1.f );
hasFired = true;
}
}

if ( beamEffect != $null_entity ) {
vector forward = sys.[[ScriptEvent:vecNormalize|vecNormalize]](endPos - startPos);
vector up = '0 0 1';
vector right = sys.[[ScriptEvent:crossProduct|crossProduct]]( up, forward );
up = sys.[[ScriptEvent:crossProduct|crossProduct]]( forward, right );

beamEffect.[[ScriptEvent:setWorldAxis|setWorldAxis]]( forward, right, up );
}
}

Script:Files:script/maps/generic/zappor.script - Revision history

Wizz at 10:16, 5 November 2007