Wizz at 09:56, 5 November 2007

2007-11-05T09:56:58Z

New page

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

void TurningThread();

void ServerIdle();
void ServerAiming();
void ServerFiring();

void ClientIdle();
void ClientFiring();

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

float vGetFireSupportMode();

void InitTargetting( vector targetPos );

void ClearFiringDecal();
void CreateFiringDecal();

void ReloadThread( float delay );

void OnMissileChanged();
void OnFireSupportStateChanged();

//
void UpdateTurning();
boolean UpdateYaw();
boolean UpdatePitch();
void ResetAngles();
void TurnToward( float yaw, float pitch );
boolean PitchValid( float pitch );
boolean CalcTargetAngles( vector targetPos );

// utility funcs ( none of these should be blocking )
void Launch();
void FireMissile();

void StopRotationSounds();
void StopYawSound();
void StopPitchSound();
void PlayYawSound();
void PlayPitchSound();

void MissileCheck();

float recycle;
float fireCount;
float reloadWait;
float fireSyncDelay;
float nextFire;

float jointYaw;
float idealYaw;
float currentYaw;
float oldIdealYaw;
float minYawRate;
float maxYawRate;

float jointPitch;
float idealPitch;
float currentPitch;
float oldIdealPitch;
float minPitchRate;
float maxPitchRate;

float jointBarrel;

float minPitch;
float maxPitch;

float minRange;
float maxRange;

float missileSpeed;

float spread;

float clientState;

float targetYaw;
float targetPitch;
vector targetDiff;

float baseYaw;
float barrelPitch;
float barrelLength;
vector firingOffset;
vector firingVelocity;
boolean hasTarget;
float projectileIndex;

entity targetCapturer;

boolean playingPitchSound;
boolean playingYawSound;
boolean anglesLocked;

entity missile;
boolean missileActive;

vector target;

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "target" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "nextFire" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "fireSupportState" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "idealYaw" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "idealPitch" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "oldIdealYaw" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "oldIdealPitch" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "missile" );

[[ScriptEvent:sync|sync]]( "currentYaw" );
[[ScriptEvent:sync|sync]]( "currentPitch" );

[[ScriptEvent:syncCallback|syncCallback]]( "missile", "OnMissileChanged" );
[[ScriptEvent:syncCallback|syncCallback]]( "fireSupportState", "OnFireSupportStateChanged" );
}

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

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::destroy() {
delete fsStatus;
ClearFiringDecal();
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ReloadThread( float delay ) {
fireSupportState = MPS_RELOADING;

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

fireSupportState = MPS_READY;
}

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::OnFireSupportStateChanged() {
if ( fireSupportState == MPS_FIRING ) {
if ( clientState != ART_CS_FIRING ) {
[[ScriptEvent:setState|setState]]( "ClientFiring" );
}
} else {
if ( clientState != ART_CS_IDLE ) {
[[ScriptEvent:setState|setState]]( "ClientIdle" );
}
}
}

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::preinit() {
vector barrel;
float entityDeclIndex;
float i;
float muzzleHandle;

recycle = [[ScriptEvent:getFloatKey|getFloatKey]]( "missile_recycle" );
fireCount = [[ScriptEvent:getFloatKey|getFloatKey]]( "missile_firecount" );
reloadWait = [[ScriptEvent:getFloatKey|getFloatKey]]( "missile_reload" );
fireSyncDelay = [[ScriptEvent:getFloatKey|getFloatKey]]( "sync_delay" );
spread = [[ScriptEvent:getFloatKey|getFloatKey]]( "spread" );

if ( fireCount <= 0 ) {
fireCount = 6;
}
if ( reloadWait <= 0 ) {
reloadWait = 30;
}
if ( fireSyncDelay <= 0 ) {
fireSyncDelay = 0.5;
}

jointYaw = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "joint_yaw" ) );
jointPitch = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "joint_pitch" ) );
jointBarrel = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "joint_barrel" ) );

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

barrel = [[ScriptEvent:getLocalJointPos|getLocalJointPos]]( jointBarrel ) - [[ScriptEvent:getLocalJointPos|getLocalJointPos]]( jointPitch );
barrelPitch = sys.[[ScriptEvent:atan2|atan2]]( barrel_z, barrel_x );
barrelLength = sys.[[ScriptEvent:vecLength|vecLength]]( barrel );

currentYaw = 0;
idealYaw = 0;
oldIdealYaw = 0;
maxYawRate = [[ScriptEvent:getFloatKey|getFloatKey]]( "max_yaw_turn" );
minYawRate = [[ScriptEvent:getFloatKey|getFloatKey]]( "min_yaw_turn" );

currentPitch = 0;
idealPitch = 0;
oldIdealPitch = 0;
maxPitchRate = [[ScriptEvent:getFloatKey|getFloatKey]]( "max_pitch_turn" );
minPitchRate = [[ScriptEvent:getFloatKey|getFloatKey]]( "min_pitch_turn" );

minPitch = [[ScriptEvent:getFloatKey|getFloatKey]]( "min_pitch" );
maxPitch = [[ScriptEvent:getFloatKey|getFloatKey]]( "max_pitch" );

minRange = [[ScriptEvent:getFloatKey|getFloatKey]]( "range_min" );
maxRange = [[ScriptEvent:getFloatKey|getFloatKey]]( "range_max" );

missileSpeed = [[ScriptEvent:getFloatKey|getFloatKey]]( "missile_speed" );

hasTarget = false;

nextFire = 0;

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

thread TurningThread();
thread MissileCheck();
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::init() {
if ( sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptEvent:setState|setState]]( "ClientIdle" );
} else {
[[ScriptEvent:setState|setState]]( "ServerIdle" );
}
}

// ==========================================
// States
// ==========================================

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

if ( disabledState ) {
StopRotationSounds();
} else {
UpdateTurning();
}
}
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ClientIdle() {
clientState = ART_CS_IDLE;
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ServerIdle() {
hasTarget = false;

ResetAngles();
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::UpdateTurning() {
boolean yawDone;
boolean pitchDone;
vector angles;

yawDone = UpdateYaw();
pitchDone = UpdatePitch();

if ( !yawDone ) {
angles_x = 0;
angles_y = currentYaw;
angles_z = 0;
[[ScriptEvent:setJointAngle|setJointAngle]]( jointYaw, JOINTMOD_LOCAL, angles );

PlayYawSound();
} else {
StopYawSound();
}

if ( !pitchDone ) {
angles_x = currentPitch;
angles_y = 0;
angles_z = 0;
[[ScriptEvent:setJointAngle|setJointAngle]]( jointPitch, JOINTMOD_LOCAL, angles );

PlayPitchSound();
} else {
StopPitchSound();
}

if ( yawDone && pitchDone ) {
anglesLocked = true;
} else {
anglesLocked = false;
}
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ServerAiming() {
fireSupportState = MPS_FIRING_PREPARE;

while ( !anglesLocked ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();

if ( disabledState ) {
[[ScriptEvent:setState|setState]]( "ServerIdle" );
}
}

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ClientFiring() {
clientState = ART_CS_FIRING;

while( true ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() > nextFire ) {
Launch();
break;
}

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ServerFiring() {
fireSupportState = MPS_FIRING;

nextFire = sys.[[ScriptEvent:getTime|getTime]]() + 2.f;

while( true ) {
if ( disabledState ) {
ClearFiringDecal();
break;
}

if ( sys.[[ScriptEvent:getTime|getTime]]() > nextFire ) {
Launch();
break;
}

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

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

nextFire = 0;

thread ReloadThread( reloadWait );

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

// ==========================================
// Utility Funcs
// ==========================================

void [[ScriptClass:deployable_ssg|deployable_ssg]]::FireMissile() {
vector org = [[ScriptEvent:getJointPos|getJointPos]]( jointPitch ) + firingOffset;

missile = [[ScriptEvent:launchMissileSimple|launchMissileSimple]]( owner, self, $null_entity, projectileIndex, -1, 0.f, org, firingVelocity );
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::Launch() {
FireMissile();

string anim = [[ScriptEvent:getKey|getKey]]( "missile_anim" );
if ( anim != "" ) {
[[ScriptEvent:playAnim|playAnim]]( [[ScriptEvent:getIntKey|getIntKey]]( "missile_channel" ), anim );
}

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

[[ScriptClass:team_base|team_base]] team = [[ScriptEvent:getGameTeam|getGameTeam]]();
objManager.PlaySound( team.[[ScriptEvent:getKey|getKey]]( "snd_ssg_fired" ), team );
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::StopYawSound() {
if ( playingYawSound ) {
playingYawSound = false;
[[ScriptEvent:startSound|startSound]]( "snd_turret_stop", SND_DEPLOYABLE_YAW );
}
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::StopPitchSound() {
if ( playingPitchSound ) {
playingPitchSound = false;
[[ScriptEvent:startSound|startSound]]( "snd_barrel_stop", SND_DEPLOYABLE_PITCH );
}
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::PlayYawSound() {
if ( !playingYawSound ) {
playingYawSound = true;
[[ScriptEvent:startSound|startSound]]( "snd_turret_start", SND_DEPLOYABLE_YAW );
}
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::PlayPitchSound() {
if ( !playingPitchSound ) {
playingPitchSound = true;
[[ScriptEvent:startSound|startSound]]( "snd_barrel_start", SND_DEPLOYABLE_PITCH );
}
}

// ==========================================
// ==========================================

boolean [[ScriptClass:deployable_ssg|deployable_ssg]]::UpdateYaw() {
float ang;
float maxTurn;
float frac;

if ( idealYaw == currentYaw ) {
return true;
}

ang = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( idealYaw - currentYaw );
frac = sys.[[ScriptEvent:sin|sin]]( sys.[[ScriptEvent:fabs|fabs]]( ang / sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( idealYaw - oldIdealYaw ) ) * MATH_PI );

maxTurn = ( minYawRate + ( maxYawRate - minYawRate ) * frac ) * sys.[[ScriptEvent:getFrameTime|getFrameTime]]();

if ( ang < -maxTurn ) {
currentYaw = currentYaw - maxTurn;
} else if ( ang > maxTurn ) {
currentYaw = currentYaw + maxTurn;
} else {
currentYaw = idealYaw;
}

return false;
}

boolean [[ScriptClass:deployable_ssg|deployable_ssg]]::UpdatePitch() {
float ang;
float maxTurn;
float frac;

if ( idealPitch == currentPitch ) {
return true;
}

ang = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( idealPitch - currentPitch );
frac = sys.[[ScriptEvent:sin|sin]]( sys.[[ScriptEvent:fabs|fabs]]( ang / sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( idealPitch - oldIdealPitch ) ) * MATH_PI );

maxTurn = ( minPitchRate + ( maxPitchRate - minPitchRate ) * frac ) * sys.[[ScriptEvent:getFrameTime|getFrameTime]]();

if ( ang < -maxTurn ) {
currentPitch = currentPitch - maxTurn;
} else if ( ang > maxTurn ) {
currentPitch = currentPitch + maxTurn;
} else {
currentPitch = idealPitch;
}

return false;
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::TurnToward( float yaw, float pitch ) {
oldIdealYaw = currentYaw;
oldIdealPitch = currentPitch;
idealYaw = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( yaw );
idealPitch = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( pitch );
anglesLocked = false;
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::ResetAngles() {
TurnToward( 0, 0 );
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::InitTargetting( vector targetPos ) {
float firingPitch;
float t;
vector gravity = '0 0 -1066';
vector velocity;
vector temp;
float i;

if ( !CalcTargetAngles( targetPos ) ) {
hasTarget = false;
return;
}

if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
CreateFiringDecal();
}

firingPitch = targetPitch - barrelPitch;

firingVelocity = targetDiff * ( sys.[[ScriptEvent:cos|cos]]( targetPitch ) * missileSpeed );
firingVelocity_z = sys.[[ScriptEvent:sin|sin]]( targetPitch ) * missileSpeed;

t = barrelLength / missileSpeed;

gravity = gravity * t * t * 0.5f;

temp = firingVelocity * t;

firingOffset = temp + gravity;
firingVelocity = firingVelocity + ( gravity * t );

TurnToward( targetYaw - baseYaw, -firingPitch );
}

boolean [[ScriptClass:deployable_ssg|deployable_ssg]]::CalcTargetAngles( vector targetPos ) {
vector barrelOrg;
vector temp;
float diffY;
float diffX;
float rootA;
float count;
float root1;
float root2;

barrelOrg = [[ScriptEvent:getJointPos|getJointPos]]( jointPitch );

targetDiff = targetPos - barrelOrg;

targetYaw = sys.[[ScriptEvent:angleNormalize180|angleNormalize180]]( sys.[[ScriptEvent:atan2|atan2]]( targetDiff_y, targetDiff_x ) );

temp = targetDiff;

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

// FIXME: Expose default gravity
rootA = ( 400 * diffX * diffX ) / ( 2 * missileSpeed * missileSpeed );

count = sys.[[ScriptEvent:solveRoots|solveRoots]]( rootA, -diffX, rootA + diffY );
if ( count == 0 ) {
return false;
}

if ( count == 1 ) {
targetPitch = sys.[[ScriptEvent:atan|atan]]( sys.[[ScriptEvent:getRoot|getRoot]]( 0 ) );
return PitchValid( targetPitch );
}

targetPitch = sys.[[ScriptEvent:atan|atan]]( sys.[[ScriptEvent:getRoot|getRoot]]( 0 ) );
if ( PitchValid( targetPitch ) ) {
return true;
}

targetPitch = sys.[[ScriptEvent:atan|atan]]( sys.[[ScriptEvent:getRoot|getRoot]]( 1 ) );
return PitchValid( targetPitch );
}

boolean [[ScriptClass:deployable_ssg|deployable_ssg]]::PitchValid( float pitch ) {
return pitch < maxPitch && pitch > minPitch;
}

void [[ScriptClass:deployable_ssg|deployable_ssg]]::StopRotationSounds() {
StopYawSound();
StopPitchSound();
}

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

return 1.f;
}

boolean [[ScriptClass:deployable_ssg|deployable_ssg]]::vTargetGetValid( vector pos ) {
return CalcTargetAngles( pos );
}

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

InitTargetting( targetPos );
Base_TargetSetTarget( targetPos, targetEnt );

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

void [[ScriptClass:deployable_ssg|deployable_ssg]]::vDoneDeploy() {
vector angles = [[ScriptEvent:getAngles|getAngles]]();
baseYaw = angles_y;
SetDeployingFinished();
}

[[ScriptClass:target_marker|target_marker]] [[ScriptClass:deployable_ssg|deployable_ssg]]::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_ssg|deployable_ssg]]::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_ssg|deployable_ssg]]::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_entity ) {
firingDecal = vCreateTargetMarker();
}
firingDecal.SetTargetPosition( target );
}

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

Wizz at 09:56, 5 November 2007