Wizz at 09:56, 5 November 2007

2007-11-05T09:56:43Z

New page

object [[ScriptClass:deployable_ssm|deployable_ssm]] : [[ScriptClass:deployable_base|deployable_base]] {
void init();
void preinit();
void syncFields();
void destroy();

void Idle();

void Ready();
void Launch();
void Reloading();

void CheckReload();
void CheckLaunch();

boolean vTargetPlayerEligible( entity p );
boolean vTargetGetValid( vector pos );
void vTargetSetTarget( vector targetPos, entity targetEnt );
void vDoneDeploy();
void vOnDeploy();

boolean CalcFiringVelocity( vector targetPos, vector launchPos );

void PlayRaiseAnim();
void PlayLowerAnim();

void MissileCheck();

void OnMissileChanged();
void OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location );

void ClearFiringDecal();
void CreateFiringDecal();
[[ScriptClass:target_marker|target_marker]] vCreateTargetMarker();

float vGetFireSupportMode();

float projectileIndex;

float launchJoint;

float sync_reloadTime;

float reloadTime;

boolean hasTarget;
vector target;
entity targetEntity;

void vStartMagogDrop();
void StartBarrelUpdateThread();
void BarrelUpdateThread();
void OnBarrelChanged();

entity barrelEntity;
boolean barrelThreadActive;
boolean dropping;

float targetHeight;
vector firingVelocity;

entity missile;
boolean missileActive;

[[ScriptClass:generic_target_marker|generic_target_marker]] firingDecal;
entity firingMarker;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "sync_reloadTime" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "hasTarget" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "target" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "missile" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "barrelEntity" );

[[ScriptEvent:syncCallback|syncCallback]]( "missile", "OnMissileChanged" );
[[ScriptEvent:syncCallback|syncCallback]]( "barrelEntity", "OnBarrelChanged" );
}

float [[ScriptClass:deployable_ssm|deployable_ssm]]::vGetFireSupportMode() {
return TARGET_SSM;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::preinit() {
float entityDeclIndex;

reloadTime = [[ScriptEvent:getFloatKey|getFloatKey]]( "reload_time" );
sync_reloadTime = 0;
hasTarget = false;

launchJoint = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "joint_launch" ) );

targetHeight = [[ScriptEvent:getFloatKey|getFloatKey]]( "target_height" );

entityDeclIndex = sys.[[ScriptEvent:getDeclType|getDeclType]]( "entityDef" );
projectileIndex = sys.[[ScriptEvent:getDeclIndex|getDeclIndex]]( entityDeclIndex, [[ScriptEvent:getKey|getKey]]( "def_projectile" ) );

fsStatus = new [[ScriptClass:fireSupportStatus|fireSupportStatus]];

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

void [[ScriptClass:deployable_ssm|deployable_ssm]]::init() {

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
// HACK: barrel clip
barrelEntity = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( "def_barrel_clip" ) );
OnBarrelChanged();
}

[[ScriptEvent:setState|setState]]( "Idle" );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::OnBarrelChanged() {
float barrelJoint = [[ScriptEvent:getJointHandle|getJointHandle]]( "barrel_base" );
if ( barrelJoint != INVALID_JOINT ) {
vector org = [[ScriptEvent:getJointPos|getJointPos]]( barrelJoint );
vector ang = [[ScriptEvent:getJointAngle|getJointAngle]]( barrelJoint );
barrelEntity.[[ScriptEvent:setContents|setContents]]( CONTENTS_PLAYERCLIP | CONTENTS_VEHICLECLIP | CONTENTS_FLYERHIVECLIP );
barrelEntity.[[ScriptEvent:unbind|unbind]]();
barrelEntity.[[ScriptEvent:setOrigin|setOrigin]]( org );
barrelEntity.[[ScriptEvent:setAngles|setAngles]]( ang );
barrelEntity.[[ScriptEvent:bindToJoint|bindToJoint]]( self, "barrel_base", 1 );
}
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::StartBarrelUpdateThread() {
if ( barrelThreadActive ) {
return;
}

barrelThreadActive = true;
thread BarrelUpdateThread();
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::BarrelUpdateThread() {
float damageIndex = GetDamage( [[ScriptEvent:getKey|getKey]]( "dmg_crush" ) );
vector mins = barrelEntity.[[ScriptEvent:getMins|getMins]]();
vector maxs = barrelEntity.[[ScriptEvent:getMaxs|getMaxs]]();

while ( [[ScriptEvent:isAnimating|isAnimating]]() || dropping ) {
barrelEntity.[[ScriptEvent:forceRunPhysics|forceRunPhysics]]();
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
LocalBoundsDamage( mins, maxs, barrelEntity, self, damageIndex );
}
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}

barrelThreadActive = false;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::vStartMagogDrop() {
dropping = true;
StartBarrelUpdateThread();
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::vOnDeploy() {
dropping = false;
thread DoDeploy();
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::destroy() {
delete fsStatus;
if ( !sys.[[ScriptEvent:isClient|isClient]]() && barrelEntity != $null_entity ) {
barrelEntity.[[ScriptEvent:remove|remove]]();
}
ClearFiringDecal();
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location ) {
if ( !sys.[[ScriptEvent:isClient|isClient]]() && barrelEntity != $null_entity ) {
barrelEntity.[[ScriptEvent:remove|remove]]();
}

DeployableBase_OnKilled( attacker, inflictor );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::Idle() {
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::OnMissileChanged() {
if ( missile != $null_entity ) {
CreateFiringDecal();
} else {
ClearFiringDecal();
}
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::vDoneDeploy() {
PlayRaiseAnim();
SetDeployingFinished();
[[ScriptEvent:setState|setState]]( "Ready" );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::Ready() {
hasTarget = false;
fireSupportState = MPS_READY;

while( 1 ) {
CheckLaunch();
CheckReload();

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

void [[ScriptClass:deployable_ssm|deployable_ssm]]::MissileCheck() {
while ( true ) {
if ( missile != $null_entity ) {
missileActive = true;
} else {
if ( missileActive ) {
missileActive = false;
ClearFiringDecal();
}
}

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

void [[ScriptClass:deployable_ssm|deployable_ssm]]::CheckLaunch() {
if( hasTarget ) {
[[ScriptEvent:setState|setState]]( "Launch" );
}
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::CheckReload() {
if ( sys.[[ScriptEvent:getTime|getTime]]() < sync_reloadTime ) {
[[ScriptEvent:setState|setState]]( "Reloading" );
}
}

boolean [[ScriptClass:deployable_ssm|deployable_ssm]]::CalcFiringVelocity( vector targetPos, vector launchPos ) {
vector targetDiff = targetPos - launchPos;

firingVelocity_x = 0;
firingVelocity_y = 0;
firingVelocity_z = sys.[[ScriptEvent:sqrt|sqrt]]( 2 * 400 * targetHeight );

float upTime = firingVelocity_z / 400;
float downTime = ( 2 * ( targetDiff_z - targetHeight ) ) / -400;
if ( downTime < 0.f ) {
return false;
}
downTime = sys.[[ScriptEvent:sqrt|sqrt]]( downTime );

float t1 = upTime + downTime;

vector temp = targetDiff;
temp_z = 0.f;
targetDiff = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( temp );
float diffX = sys.[[ScriptEvent:vecLength|vecLength]]( temp );

firingVelocity = firingVelocity + ( ( diffX / t1 ) * targetDiff );

return true;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::Launch() {
CreateFiringDecal();

vector missilePos;
string anim;
float channel;

fireSupportState = MPS_FIRING;

missilePos = [[ScriptEvent:getJointPos|getJointPos]]( launchJoint );

if ( CalcFiringVelocity( target, missilePos ) ) {
if( !sys.[[ScriptEvent:isClient|isClient]]() ) {
missile = [[ScriptEvent:launchMissileSimple|launchMissileSimple]]( owner, self, $null_entity, projectileIndex, -1, 0.f, missilePos, firingVelocity );
missile.vSetNewTarget( targetEntity );
}
} else {
ClearFiringDecal();
}

anim = [[ScriptEvent:getKey|getKey]]( "missile_anim" );
if ( anim != "" ) {
channel = [[ScriptEvent:getIntKey|getIntKey]]( "missile_channel" );

[[ScriptEvent:playAnim|playAnim]]( channel, anim );
StartBarrelUpdateThread();
}

objManager.CPrintEvent( sys.[[ScriptEvent:localizeString|localizeString]]( "game/hammer_fired" ), $null );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
sync_reloadTime = sys.[[ScriptEvent:getTime|getTime]]() + reloadTime;
}

sys.[[ScriptEvent:wait|wait]]( 3 );

[[ScriptEvent:setState|setState]]( "Reloading" );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::Reloading() {
boolean playAnims = currentState == DS_NORMAL;
if ( playAnims ) {
PlayLowerAnim();
}

fireSupportState = MPS_RELOADING;

while ( 1 ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() > sync_reloadTime ) {
break;
}

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

float waitTime = [[ScriptEvent:getFloatKey|getFloatKey]]( "stay_lowered_time" );
if( waitTime <= 0 ) {
waitTime = 15;
}
sys.[[ScriptEvent:wait|wait]]( waitTime );

if ( playAnims && currentState == DS_NORMAL ) {
PlayRaiseAnim();
}

[[ScriptEvent:setState|setState]]( "Ready" );
}

boolean [[ScriptClass:deployable_ssm|deployable_ssm]]::vTargetPlayerEligible( entity p ) {
if ( disabledState || !finishedDeploying ) {
return 0.f;
}

return 1.f;
}

boolean [[ScriptClass:deployable_ssm|deployable_ssm]]::vTargetGetValid( vector pos ) {
return true;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::vTargetSetTarget( vector targetPos, entity targetEnt ) {
hasTarget = true;
target = targetPos;
targetEntity = targetEnt;

Base_TargetSetTarget( targetPos, targetEnt );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::PlayLowerAnim() {
[[ScriptEvent:startSound|startSound]]( "snd_lower", SND_ANY );
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "lowering" );
StartBarrelUpdateThread();
waitUntil( ![[ScriptEvent:isAnimating|isAnimating]]() );
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::PlayRaiseAnim() {
[[ScriptEvent:startSound|startSound]]( "snd_raise", SND_ANY );
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "raising" );
StartBarrelUpdateThread();
waitUntil( ![[ScriptEvent:isAnimating|isAnimating]]() );
}

[[ScriptClass:target_marker|target_marker]] [[ScriptClass:deployable_ssm|deployable_ssm]]::vCreateTargetMarker() {
string entityDef = [[ScriptEvent:getKey|getKey]]( "def_marker" );
if ( entityDef == "" ) {
return $null;
}

[[ScriptClass:generic_target_marker|generic_target_marker]] marker = new [[ScriptClass:generic_target_marker|generic_target_marker]];
marker.Init( self, entityDef, [[ScriptEvent:getKey|getKey]]( "mtr_marker_cm" ), [[ScriptEvent:getFloatKey|getFloatKey]]( "cm_marker_sort" ) );
return marker;
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::ClearFiringDecal() {
if ( firingDecal != $null_entity ) {
delete firingDecal;
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( firingMarker != $null_entity ) {
thread G_DelayRemoveEntity( firingMarker, 5.f );
firingMarker = $null_entity;
}
}
}

void [[ScriptClass:deployable_ssm|deployable_ssm]]::CreateFiringDecal() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
firingMarker = G_CreateFiringMarker( self, firingMarker, target );
}

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

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

if ( firingDecal == $null ) {
firingDecal = vCreateTargetMarker();
}
firingDecal.SetTargetPosition( target );
}

Script:Files:script/deployables/ssm.script - Revision history

Wizz at 09:56, 5 November 2007