Wizz at 09:55, 5 November 2007

2007-11-05T09:55:52Z

New page

/*
===============================================================================

deployable_antipersonnel - anti-personnel turret

===============================================================================
*/

object [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]] : [[ScriptClass:deployable_turret|deployable_turret]] {
entity OnAcquireTarget();

boolean TargetIsValid( entity targetEnt );

void preinit();
void syncFields();

void OnPostDamage_AP( entity attacker, float oldHealth, float newHealth );
void OnPostDamage( entity attacker, float oldHealth, float newHealth ) {
OnPostDamage_AP( attacker, oldHealth, newHealth );
}
void CheckRetribution( entity attacker );

float playerClass;

void OnFullChargeTimeChanged();

boolean ShouldSpinBarrel();

void OnBeginAttack();
void OnEndAttack();
void SpinBarrelThread();

boolean CanFire();
void Fired();
void FireMissile();

void UpdateCharge();

float fullChargeTime;
float cooldownTime;
float chargeTime;
float chargePerShot;
float overheatPenalty;

float spinBarrelJoint;
vector barrelAngles;

float tracerCounter;
float tracerInterval;

boolean barrelThreadActive;

boolean updateChargeThreadActive;
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::preinit() {
playerClass = sys.[[ScriptEvent:getTypeHandle|getTypeHandle]]( "idPlayer" );

fullChargeTime = -1;
cooldownTime = -1;
chargeTime = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "charge_time", 10 );
chargePerShot = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "charge_per_shot", 0.7 );
overheatPenalty = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "overheat_penalty", 5 );

spinBarrelJoint = -1;

string barrelJointName = [[ScriptEvent:getKey|getKey]]( "joint_spin_barrel" );
if ( barrelJointName != "" ) {
spinBarrelJoint = [[ScriptEvent:getJointHandle|getJointHandle]]( barrelJointName );
}

tracerCounter = 0;
tracerInterval = sys.[[ScriptEvent:getEntityDefIntKey|getEntityDefIntKey]]( projectileIndex, "tracer_interval" );
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "cooldownTime" );

[[ScriptEvent:sync|sync]]( "fullChargeTime" );
[[ScriptEvent:syncCallback|syncCallback]]( "fullChargeTime", "OnFullChargeTimeChanged" );
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::OnFullChargeTimeChanged() {
if ( !updateChargeThreadActive ) {
if ( myUser == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
thread UpdateCharge();
}
}
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::CheckRetribution( entity attacker ) {
if ( !TargetIsValid( attacker ) ) {
return;
}

if ( !InRange( attacker.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() ) ) {
return;
}

[[ScriptEvent:setEnemy|setEnemy]]( attacker );
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::OnPostDamage_AP( entity attacker, float oldHealth, float newHealth ) {
boolean oldDisabled = disabledState;
UpdateState( newHealth );

if ( !disabledState ) {
if ( [[ScriptEvent:getEnemy|getEnemy]]() == $null_entity && newHealth < oldHealth ) {
CheckRetribution( attacker );
}
}

UpdateDisabledStats( attacker, oldDisabled );
}

boolean [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::TargetIsValid( entity targetEnt ) {
[[ScriptClass:player|player]] testPlayer = targetEnt;

if ( testPlayer == $null_entity ) {
return false;
}

if ( testPlayer.[[ScriptEvent:getHealth|getHealth]]() <= 0 ) {
return false;
}

if ( testPlayer.[[ScriptEvent:getVehicle|getVehicle]]() != $null_entity ) {
return false;
}

if ( testPlayer.[[ScriptEvent:isDisguised|isDisguised]]() ) {
return false;
}

if ( [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( testPlayer ) != TA_ENEMY ) {
return false;
}

if ( testPlayer.[[ScriptEvent:isInvulnerable|isInvulnerable]]() ) {
return false;
}

if ( !TraceCheck( testPlayer ) ) {
return false;
}

return true;
}

entity [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::OnAcquireTarget() {
if ( !finishedDeploying || disabledState ) {
return $null_entity;
}

float i;
float count;
entity ent;
entity targetingRangeEnt;
vector targetDir;
vector selfDir;

[[ScriptEvent:entitiesOfClass|entitiesOfClass]]( playerClass, 0 );
[[ScriptEvent:filterEntitiesByDisguiseAllegiance|filterEntitiesByDisguiseAllegiance]]( TA_FLAG_ENEMY, 1 ); // only damage enemies
[[ScriptEvent:filterEntitiesByRadius|filterEntitiesByRadius]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]](), maxRange, 1 ); // find entities within maxRange radius

selfDir = [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 );
selfDir_z = 0;

count = [[ScriptEvent:getBoundsCacheCount|getBoundsCacheCount]](); // number of remaining entities
for ( i = 0; i < count; i++ ) {
ent = [[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( i );

targetDir = sys.[[ScriptEvent:vecNormalize|vecNormalize]]( ent.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() - [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
targetDir_z = 0;

if ( targetDir * selfDir < angleRange ) {
continue;
}

if ( !TargetIsValid( ent ) ) {
continue;
}

if ( !InRange( ent.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() ) ) {
continue;
}
if ( InFiringRange( ent.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() ) ) {
return ent;
}

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

return targetingRangeEnt;
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::UpdateCharge() {
sys.[[ScriptEvent:assert|assert]]( false );

updateChargeThreadActive = true;

while ( true ) {
if ( myUser != sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
break;
}

float time = sys.[[ScriptEvent:getTime|getTime]]();

float chargeAmount = ( chargeTime - ( fullChargeTime - time ) ) / chargeTime;
if ( chargeAmount > 1 ) {
chargeAmount = 1;
}

sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.energyBarCharge", chargeAmount );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.energyAvailable", time >= cooldownTime );

if ( chargeAmount == 1.f ) {
break;
}

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

updateChargeThreadActive = false;
}

boolean [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::CanFire() {
if ( myUser == $null_entity ) {
return true;
}

float time = sys.[[ScriptEvent:getTime|getTime]]();
float chargeAmount = ( chargeTime - ( fullChargeTime - time ) ) / chargeTime;
if ( chargeAmount >= chargePerShot && time > cooldownTime ) {
return true;
}

return false;
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::Fired() {
if ( myUser == $null_entity ) {
return;
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
float timePerShot = chargeTime * chargePerShot;

if ( fullChargeTime < sys.[[ScriptEvent:getTime|getTime]]() ) {
fullChargeTime = sys.[[ScriptEvent:getTime|getTime]]();
}
fullChargeTime = fullChargeTime + timePerShot;

float time = sys.[[ScriptEvent:getTime|getTime]]();
if ( fullChargeTime >= time + chargeTime - timePerShot ) {
cooldownTime = sys.[[ScriptEvent:getTime|getTime]]() + overheatPenalty;
}
}

if ( !updateChargeThreadActive ) {
if ( myUser == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
thread UpdateCharge();
}
}
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::FireMissile() {
float muzzleJoint;

float forceTracer = TRACER_CHANCE;
if ( tracerInterval > 0 ) {
if ( tracerCounter % tracerInterval == 0 ) {
forceTracer = TRACER_FORCE;
}
}

entity controller = owner;
if ( controller == $null_entity ) {
controller = self;
}

[[ScriptEvent:launchBullet|launchBullet]]( controller, self, projectileIndex, spread, [[ScriptEvent:getJointPos|getJointPos]]( jointBarrel ), [[ScriptEvent:getJointAxis|getJointAxis]]( jointBarrel, 0 ), forceTracer, false ); // hit scan
tracerCounter++;

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

if( numTracerJoints > 1 ) {
muzzleJoint = int( sys.[[ScriptEvent:random|random]]( numTracerJoints ) ) + 1;
} else {
muzzleJoint = numTracerJoints;
}
[[ScriptEvent:playEffect|playEffect]]( "fx_muzzle", [[ScriptEvent:getKey|getKey]]( "joint_tracer" + muzzleJoint ), 0 );

Fired();
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::OnBeginAttack() {
KillAttackThread();
thread AttackThread();

attacking = true;

if ( spinBarrelJoint != -1 && !barrelThreadActive ) {
thread SpinBarrelThread();
}

[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "fire" );
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::OnEndAttack() {
attacking = false;

[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "base" );

KillAttackThread();
}

boolean [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::ShouldSpinBarrel() {
return attacking && sys.[[ScriptEvent:getTime|getTime]]() > cooldownTime;
}

void [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]]::SpinBarrelThread() {
barrelThreadActive = true;

float speed = 0.f;
float maxSpeed = 900;

float frameTime;

while ( attacking ) {
if ( ShouldSpinBarrel() ) {
[[ScriptEvent:startSound|startSound]]( "snd_fire_start", SND_DEPLOYABLE_FIRE );
[[ScriptEvent:startSound|startSound]]( "snd_fire_far", SND_DEPLOYABLE_FIRE_FAR );
[[ScriptEvent:startSound|startSound]]( "snd_brass", SND_DEPLOYABLE_BRASS );

while ( ShouldSpinBarrel() ) {
frameTime = sys.[[ScriptEvent:getFrameTime|getFrameTime]]();

speed = speed + ( frameTime * 600 );
if ( speed > maxSpeed ) {
speed = maxSpeed;
}

barrelAngles_y = ( barrelAngles_y + ( frameTime * speed ) ) % 360;
[[ScriptEvent:setJointAngle|setJointAngle]]( spinBarrelJoint, JOINTMOD_LOCAL, barrelAngles );

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

[[ScriptEvent:startSound|startSound]]( "snd_brass_stop", SND_DEPLOYABLE_BRASS );
[[ScriptEvent:startSound|startSound]]( "snd_fire_stop", SND_DEPLOYABLE_FIRE );
[[ScriptEvent:startSound|startSound]]( "snd_fire_far_stop", SND_DEPLOYABLE_FIRE_FAR );
}

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

frameTime = sys.[[ScriptEvent:getFrameTime|getFrameTime]]();

speed = speed - ( frameTime * 600 );
if ( speed < 0 ) {
speed = 0;
break;
}

barrelAngles_y = ( barrelAngles_y + ( frameTime * speed ) ) % 360;
[[ScriptEvent:setJointAngle|setJointAngle]]( spinBarrelJoint, JOINTMOD_LOCAL, barrelAngles );
}
}

barrelThreadActive = false;
}

/*
===============================================================================

deployable_antipersonnel_salvage - anti-personnel turret that can't be destroyed
 starts with zero health though

===============================================================================
*/
object [[ScriptClass:deployable_antipersonnel_salvage|deployable_antipersonnel_salvage]] : [[ScriptClass:deployable_antipersonnel|deployable_antipersonnel]] {
void init();

void UpdateState( float health );
void CreateDestroyThread() { }
void OnPostDamage( entity attacker, float oldHealth, float newHealth );
};

void [[ScriptClass:deployable_antipersonnel_salvage|deployable_antipersonnel_salvage]]::init() {
[[ScriptEvent:setHealth|setHealth]]( 1 );
UpdateState( 1 );
}

void [[ScriptClass:deployable_antipersonnel_salvage|deployable_antipersonnel_salvage]]::OnPostDamage( entity attacker, float oldHealth, float newHealth ) {
if ( newHealth <= 0 ) {
[[ScriptEvent:setHealth|setHealth]]( 1 );
newHealth = 1;
}

OnPostDamage_AP( attacker, oldHealth, newHealth );
}

void [[ScriptClass:deployable_antipersonnel_salvage|deployable_antipersonnel_salvage]]::UpdateState( float health ) {
float frac = health / [[ScriptEvent:getMaxHealth|getMaxHealth]]();

float newState;

[[ScriptClass:player|player]] p = sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]();

boolean showHealthStatus = false;
if ( p != $null_entity ) {
[[ScriptClass:team_base|team_base]] team = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
float allegiance = [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p );
if ( allegiance == TA_FRIEND ) {
showHealthStatus = true;
}
}

float healthStatusParm = 0;

if ( frac < ( 2.f / 3.f ) ) {
newState = DS_DAMAGED;
healthStatusParm = frac * 2;
} else {
newState = DS_NORMAL;
}

if ( showHealthStatus && !disabledState ) {
sys.[[ScriptEvent:setCMIconShaderParm|setCMIconShaderParm]]( commandMapHandle, 5, healthStatusParm );
}

SetDeployableState( newState );
}

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

Wizz at 09:55, 5 November 2007