Wizz at 09:55, 5 November 2007

2007-11-05T09:55:26Z

New page

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

// states
float OnUsed( entity p, float distance );

void OnDisabled();
void OnReEnabled();

void OnBeginAttack();
void OnEndAttack();

boolean InRange( vector targetPos );
boolean InFiringRange( vector targetPos );

void KillAttackThread();
void AttackThread();

void vCheckProficiency();

boolean TargetIsValid( entity targetEnt ) { return false; }

void FireMissile();

void FreeArcIcon();
void SetupFiringArc();

void vOnDeploy();

float GetTurretMaxRange();
float GetTurretMinRange();

boolean TraceCheck( entity other );

void OnEnter( entity user );
void OnExit( entity user );

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

float OnValidateTarget();

float OnUpdateCrosshairInfo( entity p );

void CreateDestroyThread();

void UpdateCharge() { }

float vGetFiringStatus( object traceObject );

float numTracerJoints;

float minRange;
float maxRange;
float firingRange;

float angleRange;

float jointBarrel;

float projectileIndex;

float projectileSpeed;
float spread;
float fireRate;
float reFire;

float commandmapVisibleArcHandle;

float checkMask;

vector traceCheckOffset;

boolean playingBrassSound;

entity myUser;

// overheating/power bar stuff
boolean CanFire() { return true; }
void Fired() { }

boolean attacking;
};

void [[ScriptClass:deployable_turret|deployable_turret]]::preinit() {
projectileIndex = GetEntityDef( [[ScriptEvent:getKey|getKey]]( "def_projectile" ) );

projectileSpeed = [[ScriptEvent:getFloatKey|getFloatKey]]( "missile_velocity" );

minRange = MetresToInches( [[ScriptEvent:getFloatKey|getFloatKey]]( "range_min" ) );
maxRange = MetresToInches( [[ScriptEvent:getFloatKey|getFloatKey]]( "range_max" ) );
firingRange = MetresToInches( [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "range_firing", InchesToMetres( maxRange ) ) );

fireRate = [[ScriptEvent:getFloatKey|getFloatKey]]( "fireRate" );
spread = [[ScriptEvent:getFloatKey|getFloatKey]]( "spread" );
reFire = 0;

jointBarrel = [[ScriptEvent:getJointHandle|getJointHandle]]( [[ScriptEvent:getKey|getKey]]( "joint_barrel" ) );

numTracerJoints = [[ScriptEvent:getFloatKey|getFloatKey]]( "num_tracerjoints" );

checkMask = MASK_SHOT_RENDERMODEL | MASK_SHOT_BOUNDINGBOX;

vector mins = [[ScriptEvent:getMins|getMins]]();
vector maxs = [[ScriptEvent:getMaxs|getMaxs]]();

traceCheckOffset_z = mins_z + ( ( maxs_z - mins_z ) * ( [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "trace_offset_pct", 75.f ) * 0.01f ) );

commandmapVisibleArcHandle = -1;
}

void [[ScriptClass:deployable_turret|deployable_turret]]::FreeArcIcon() {
if ( commandmapVisibleArcHandle != -1 ) {
sys.[[ScriptEvent:freeCMIcon|freeCMIcon]]( self, commandmapVisibleArcHandle );
commandmapVisibleArcHandle = -1;
}
}

void [[ScriptClass:deployable_turret|deployable_turret]]::SetupFiringArc() {
FreeArcIcon();

angleRange = [[ScriptEvent:getFloatKey|getFloatKey]]( "angle_range" );
if ( angleRange <= 0 ) {
angleRange = 135;
}

vector ang = [[ScriptEvent:getAngles|getAngles]]();

commandmapVisibleArcHandle = sys.[[ScriptEvent:allocCMIcon|allocCMIcon]]( self, 100 );
sys.[[ScriptEvent:setCMIconAngle|setCMIconAngle]]( commandmapVisibleArcHandle, -ang_y );
sys.[[ScriptEvent:setCMIconSizeMode|setCMIconSizeMode]]( commandmapVisibleArcHandle, SM_WORLD );
sys.[[ScriptEvent:setCMIconColor|setCMIconColor]]( commandmapVisibleArcHandle, g_colorRed, 0.25f );
sys.[[ScriptEvent:setCMIconSides|setCMIconSides]]( commandmapVisibleArcHandle, 24 );
sys.[[ScriptEvent:setCMIconDrawMode|setCMIconDrawMode]]( commandmapVisibleArcHandle, DM_ARC );
sys.[[ScriptEvent:setCMIconMaterial|setCMIconMaterial]]( commandmapVisibleArcHandle, GetMaterial( "_white_depth" ) );
sys.[[ScriptEvent:setCMIconUnknownMaterial|setCMIconUnknownMaterial]]( commandmapVisibleArcHandle, GetMaterial( "_white_depth" ) );
sys.[[ScriptEvent:setCMIconSize|setCMIconSize]]( commandmapVisibleArcHandle, maxRange );
sys.[[ScriptEvent:setCMIconUnknownSize|setCMIconUnknownSize]]( commandmapVisibleArcHandle, maxRange );
sys.[[ScriptEvent:setCMIconFlag|setCMIconFlag]]( commandmapVisibleArcHandle, CMF_ENEMYONLY | CMF_ONLYSHOWKNOWN );
sys.[[ScriptEvent:setCMIconArcAngle|setCMIconArcAngle]]( commandmapVisibleArcHandle, angleRange );
sys.[[ScriptEvent:setCMIconFlag|setCMIconFlag]]( commandmapVisibleArcHandle, CMF_FOLLOWROTATION );

angleRange = sys.[[ScriptEvent:cos|cos]]( angleRange * 0.5f );
}

void [[ScriptClass:deployable_turret|deployable_turret]]::vOnDeploy() {
SetupFiringArc();

thread DoDeploy();
}

void [[ScriptClass:deployable_turret|deployable_turret]]::init() {
[[ScriptEvent:startSound|startSound]]( "snd_turret_yaw", SND_DEPLOYABLE_YAW );
[[ScriptEvent:startSound|startSound]]( "snd_turret_pitch", SND_DEPLOYABLE_PITCH );
[[ScriptEvent:fadeSound|fadeSound]]( SND_DEPLOYABLE_YAW, -60.f, 0.f );
[[ScriptEvent:fadeSound|fadeSound]]( SND_DEPLOYABLE_PITCH, -60.f, 0.f );
}

void [[ScriptClass:deployable_turret|deployable_turret]]::destroy() {
FreeArcIcon();
KillAttackThread();
}

boolean [[ScriptClass:deployable_turret|deployable_turret]]::TraceCheck( entity other ) {
vector targetPos = [[ScriptEvent:getTargetPosition|getTargetPosition]]( other );

sys.[[ScriptEvent:tracePoint|tracePoint]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + traceCheckOffset, targetPos, checkMask, self );
if ( sys.[[ScriptEvent:getTraceFraction|getTraceFraction]]() == 1.f ) {
return true;
}
if ( sys.[[ScriptEvent:getTraceEntity|getTraceEntity]]() != other ) {
return false;
}
return true;
}

void [[ScriptClass:deployable_turret|deployable_turret]]::KillAttackThread() {
sys.[[ScriptEvent:killThread|killThread]]( "AttackThread_" + [[ScriptEvent:getName|getName]]() );
}

void [[ScriptClass:deployable_turret|deployable_turret]]::AttackThread() {
float delay = reFire - sys.[[ScriptEvent:getTime|getTime]]();
if ( delay > 0 ) {
sys.[[ScriptEvent:wait|wait]]( delay );
}

while ( true ) {
if ( CanFire() ) {
FireMissile();
}

delay = fireRate;
reFire = sys.[[ScriptEvent:getTime|getTime]]() + delay;
sys.[[ScriptEvent:wait|wait]]( delay );
}
}

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

void [[ScriptClass:deployable_turret|deployable_turret]]::FireMissile() {
entity target;
entity controller = [[ScriptEvent:getBoundPlayer|getBoundPlayer]]( 0 );
if ( controller != $null_entity ) {
target = controller.[[ScriptEvent:getEnemy|getEnemy]]();
} else {
if ( owner != $null_entity ) {
controller = owner;
} else {
controller = self;
}
target = [[ScriptEvent:getEnemy|getEnemy]]();
}

[[ScriptEvent:launchMissileSimple|launchMissileSimple]]( controller, self, target, projectileIndex, -1, spread, [[ScriptEvent:getJointPos|getJointPos]]( jointBarrel ), [[ScriptEvent:getJointAxis|getJointAxis]]( jointBarrel, 0 ) * projectileSpeed );
[[ScriptEvent:playJointEffect|playJointEffect]]( "fx_fire", jointBarrel, 0 );

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

Fired();
}

float [[ScriptClass:deployable_turret|deployable_turret]]::OnValidateTarget() {
entity target = [[ScriptEvent:getEnemy|getEnemy]]();

if ( !TargetIsValid( target ) ) {
return 0.f;
}

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

return 1.f;
}

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

float allegiance = [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p );
vector color = GetAllegianceColor( allegiance );
float distance = [[ScriptEvent:chGetDistance|chGetDistance]]();
float range = InchesToMetres( distance );
float health = [[ScriptEvent:getHealth|getHealth]]();

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

// define length of health bar
float healthBarLength;
float maxHealth = [[ScriptEvent:getMaxHealth|getMaxHealth]]();
if ( maxHealth >= 2000.f ) {
healthBarLength = 150.f;
} else if ( maxHealth >= 1000.f ) {
healthBarLength = 100.f;
} else {
healthBarLength = 75.f;
}

// see if theres a valid action to perform
float code = GetActivateCode( p, distance );
if ( code != AK_NONE ) {
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 ) ) {
if ( code == AK_HACK ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip1_Hack );
}
} else {
if ( code == AK_HACK ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip2_Hack );
}
}
}
}
}
}

vector disabledColor;
if ( allegiance == TA_ENEMY || allegiance == TA_FRIEND ) {
disabledColor = g_colorYellow;
} else {
disabledColor = color;
}

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

if ( health <= 0 ) {
if ( maxHealth != 0.f ) {
index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, g_locStr_Destroyed );
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );
}
} else {
if ( disabledState ) {
index = [[ScriptEvent:chAddLine|chAddLine]]();

float diff = disableEndTime - sys.[[ScriptEvent:getTime|getTime]]();
if ( diff > 0 ) {
sys.[[ScriptEvent:pushLocString|pushLocString]]( int( diff ) );
[[ScriptEvent:chSetLineText|chSetLineText]]( index, sys.[[ScriptEvent:localizeStringArgs|localizeStringArgs]]( "game/disabled_info" ) );
} else {
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, g_locStr_Disabled );
}

[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, disabledColor, 1.f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_TEXT );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, 0, 0 );
}

index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineColor|chSetLineColor]]( index, color, 0.5f );
[[ScriptEvent:chSetLineType|chSetLineType]]( index, CI_BAR );
[[ScriptEvent:chSetLineFraction|chSetLineFraction]]( index, [[ScriptEvent:getHealth|getHealth]]() / [[ScriptEvent:getMaxHealth|getMaxHealth]]() );
[[ScriptEvent:chSetLineSize|chSetLineSize]]( index, healthBarLength, CROSSHAIR_INFO_BAR_HEIGHT );

if ( !disabledState ) {
float fsState = vGetFiringStatus( $null_entity );
G_StringForFireSupportState( fsState );

index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, g_fireSupportStateStr );
[[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;
}
boolean [[ScriptClass:deployable_turret|deployable_turret]]::InRange( vector targetPos ) {
float len = sys.[[ScriptEvent:vecLength|vecLength]]( targetPos - [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
return ( ( len >= minRange ) && ( len <= maxRange ) );
}

boolean [[ScriptClass:deployable_turret|deployable_turret]]::InFiringRange( vector targetPos ) {
float len = sys.[[ScriptEvent:vecLength|vecLength]]( targetPos - [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );
return ( ( len >= minRange ) && ( len <= firingRange ) );
}

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

float [[ScriptClass:deployable_turret|deployable_turret]]::OnUsed( entity p, float distance ) {
entity team = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
if ( team == $null_entity ) {
return 0.f;
}

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

if ( distance > 128.f ) {
return 0.f;
}

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

entity other = p.[[ScriptEvent:getProxyEntity|getProxyEntity]]();
if ( other != $null_entity ) {
sys.[[ScriptEvent:assert|assert]]( self == other );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptEvent:removeBoundPlayer|removeBoundPlayer]]( p );
}

return 1.f;
}

if ( [[ScriptEvent:getBoundPlayer|getBoundPlayer]]( 0 ) != $null_entity ) {
return 1.f;
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
p.[[ScriptEvent:enter|enter]]( self );
}

return 1.f;
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnKilled( entity inflictor, entity attacker, float damage, vector dir, float location ) {
entity currentUser = [[ScriptEvent:getBoundPlayer|getBoundPlayer]]( 0 );
if( currentUser != $null_entity ) {
currentUser.[[ScriptEvent:applyDamage|applyDamage]]( inflictor, attacker, dir, GetDamage( "damage_deployable_turret_user" ), 1.f, $null_entity );
}

DeployableBase_OnKilled( attacker, inflictor );
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnEnter( entity user ) {
sys.[[ScriptEvent:assert|assert]]( false );

if ( user.[[ScriptEvent:isDisguised|isDisguised]]() ) {
user.[[ScriptEvent:disguise|disguise]]( $null_entity );
}

myUser = user;
user.vHideNormalChargeBar( true );
if ( user == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIString|setGUIString]]( GUI_GLOBALS_HANDLE, "gameHud.weaponCrosshair", [[ScriptEvent:getKey|getKey]]( "crosshair" ) );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponShowAllAmmo", 1 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponShowClip", 0 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponHideAmmo", 0 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCharge", 1 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.energySegments", 1 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponShowCustom", 0 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.showHeat", 1.f );

thread UpdateCharge();
}
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnExit( entity user ) {
sys.[[ScriptEvent:assert|assert]]( false );

myUser = $null_entity;
user.vHideNormalChargeBar( false );
if ( user == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.showHeat", 0 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.energyAvailable", 1 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.energyBarCharge", 1 );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "weapons.cooling", 0 );
}
}

void [[ScriptClass:deployable_turret|deployable_turret]]::CreateDestroyThread() {
sys.[[ScriptEvent:freeCMIcon|freeCMIcon]]( self, commandmapVisibleArcHandle );
commandmapVisibleArcHandle = -1;
thread DestroyThread();
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnBeginAttack() {
attacking = true;

KillAttackThread();
thread AttackThread();
}

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

KillAttackThread();
}

void [[ScriptClass:deployable_turret|deployable_turret]]::vCheckProficiency() {
SetupFiringArc();
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnDisabled() {
[[ScriptEvent:setDisabled|setDisabled]]( true );
sys.[[ScriptEvent:setCMIconShaderParm|setCMIconShaderParm]]( commandMapHandle, 5, 0 );
if ( owner != $null_entity ) {
if ( owner.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "deployables.state", DS_DISABLED );
}
}
}

void [[ScriptClass:deployable_turret|deployable_turret]]::OnReEnabled() {
[[ScriptEvent:setDisabled|setDisabled]]( false );
sys.[[ScriptEvent:setCMIconShaderParm|setCMIconShaderParm]]( commandMapHandle, 5, 1 );
if ( owner != $null_entity ) {
if ( owner.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "deployables.state", DS_NORMAL );
}
}
}

float [[ScriptClass:deployable_turret|deployable_turret]]::GetTurretMaxRange() {
return firingRange;
}

float [[ScriptClass:deployable_turret|deployable_turret]]::GetTurretMinRange() {
return minRange;
}

float [[ScriptClass:deployable_turret|deployable_turret]]::vGetFiringStatus( object traceObject ) {
if ( attacking ) {
return MPS_FIRING;
}

if ( !finishedDeploying ) {
return MPS_NONE_ACTIVE;
}

return MPS_READY;
}

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

Wizz at 09:55, 5 November 2007