Wizz at 09:57, 5 November 2007

2007-11-05T09:57:10Z

New page

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

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

void ClientIdle();
void ClientFiring();

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

//
boolean InRange( vector targetPos );
boolean InFiringRange( vector targetPos ) { return InRange( targetPos ); }
boolean CalcTargetAngles( vector targetPos );

// utility funcs ( none of these should be blocking )
void Launch();
void FireMissile();
boolean PitchValid( float pitch );

void ReloadThread( float delay );
void OnFireSupportStateChanged();

float vGetFireSupportMode();

[[ScriptClass:target_marker|target_marker]] vCreateTargetMarker();

void ClearFiringDecal();
void CreateFiringDecal();

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

float jointMuzzle;

float minPitch;
float maxPitch;

float minRange;
float maxRange;

float missileSpeed;

float spread;

float clientState;

float targetYaw;
float targetPitch;
vector targetDiff;

float barrelPitch;
vector firingVelocity;
boolean hasTarget;
entity targetPlayerEnemy;
float projectileIndex;
vector targetLocation;
boolean playingPitchSound;
boolean playingYawSound;

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

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "nextFire" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "fireSupportState" );

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

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

float [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::vGetFireSupportMode() {
return TARGET_ROCKETS;
}

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

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;
}

jointMuzzle = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "missile_barrel" ) );

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

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]];
}

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::init() {
vector angles;

angles = [[ScriptEvent:getAngles|getAngles]]();

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

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

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

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

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

while( true ) {
if ( hasTarget ) {
[[ScriptEvent:setState|setState]]( "ServerAiming" );
}

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

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

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

fireSupportState = MPS_READY;
}

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::ServerAiming() {
[[ScriptEvent:setState|setState]]( "ServerFiring" );
}

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::ClientFiring() {
float nextMiniFire = 0;
float baseFireTime = 0;

clientState = ART_CS_FIRING;

while( true ) {
if ( nextFire < sys.[[ScriptEvent:getTime|getTime]]() ) {
baseFireTime = sys.[[ScriptEvent:getTime|getTime]]();
nextFire = baseFireTime + recycle;

Launch();
}

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

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::ServerFiring() {
float count = 0;
float nextMiniFire = 0;
float baseFireTime = 0;

fireSupportState = MPS_FIRING;

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

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

if ( nextFire < sys.[[ScriptEvent:getTime|getTime]]() ) {
baseFireTime = sys.[[ScriptEvent:getTime|getTime]]();
nextFire = baseFireTime + recycle;
count = count + 1;

Launch();

if ( count >= fireCount ) {
break;
}
}

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

nextFire = 0;

thread ReloadThread( reloadWait );

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

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

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::FireMissile() {
vector org = [[ScriptEvent:getJointPos|getJointPos]]( jointMuzzle );

[[ScriptEvent:launchMissileSimple|launchMissileSimple]]( owner, self, targetPlayerEnemy, projectileIndex, -1, spread, org, firingVelocity );

[[ScriptEvent:playJointEffect|playJointEffect]]( "fx_fire", jointMuzzle, 0 );
}

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::Launch() {
string anim;
float channel;

FireMissile();

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

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

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

void [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::vTargetSetTarget( vector targetPos, entity targetEnt ) {
float firingPitch;
float t;
vector gravity;
vector velocity;
vector temp;
float i;

if ( !CalcTargetAngles( targetPos ) ) {
return;
}

gravity_x = 0;
gravity_y = 0;
gravity_z = -1066;

// make target pitch more vertical
targetPitch = targetPitch + ( 90 - targetPitch ) * 0.5;
firingPitch = targetPitch;

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

targetPlayerEnemy = owner.[[ScriptEvent:getEnemy|getEnemy]]();
hasTarget = true;

Base_TargetSetTarget( targetPos, targetEnt );
}

boolean [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::vTargetGetValid( vector targetPos ) {
if ( !InRange( targetPos ) ) {
return 0.f;
}

return CalcTargetAngles( targetPos );
}

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

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

targetDiff = modelOffset - 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 = ( 1066 * 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_plasmamortar|deployable_plasmamortar]]::PitchValid( float pitch ) {
return pitch < maxPitch && pitch > minPitch;
}

boolean [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::InRange( vector targetPos ) {
return true;
}

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

return 1.f;
}

[[ScriptClass:target_marker|target_marker]] [[ScriptClass:deployable_plasmamortar|deployable_plasmamortar]]::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" ) );
if ( vGetFireSupportMode() == TARGET_ROCKETS ) {
marker.SetLocalOnly( true );
}
return marker;
}

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

if ( firingMarker != $null_entity ) {
thread G_DelayRemoveEntity( firingMarker, 5.f );
firingMarker = $null_entity;
}
}

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

if ( vGetFireSupportMode() == TARGET_ROCKETS ) {
sys.[[ScriptEvent:println|println]]( "return" );
return;
}

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();
}

if ( firingDecal != $null_entity ) {
firingDecal.SetTargetPosition( targetLocation );
}
}

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

Wizz at 09:57, 5 November 2007