Wizz at 18:14, 2 November 2007

2007-11-02T18:14:01Z

New page

/***********************************************************************

tool_pliers.script

***********************************************************************/

// blend times
#define PLIERS_IDLE_TO_LOWER 4
#define PLIERS_IDLE_TO_PUNCH 0
#define PLIERS_RAISE_TO_IDLE 4
#define PLIERS_PUNCH_TO_IDLE 1

#define GUI_STATE_IDLE 0
#define GUI_STATE_ARMING 1
#define GUI_STATE_CONNECTED 2

object [[ScriptClass:tool_pliers|tool_pliers]] : [[ScriptClass:weapon_base|weapon_base]] {

void preinit();
void init();
void destroy();
void Lower();
void Idle();

void Attack();
boolean CheckAttack( float mask );
void StartFireEffect();
void StopFireEffect();
boolean fireEffectOn;

boolean AttackValid();

void ToolTipThread_Raise();

void Repair();
void Arm();
void Disarm();
void Construct();
void Hack();
void Possess();

void UpdateGUI();

handle GetTextHandleForState( float state );

float fireRate;
float repairCount;
float count;

float meleeDistance;

entity cachedEntity;
float cachedAction;

boolean disarmCharge;
boolean armCharge;
boolean armNormal;
boolean canRepair;
boolean canConstruct;
boolean canHack;
boolean canDisguise;

boolean playingFireSound;

float nextActionFailMessageTime;

float guiHandle;
handle guiTextHandle;
}

void [[ScriptClass:tool_pliers|tool_pliers]]::preinit() {
meleeDistance = [[ScriptEvent:getFloatKey|getFloatKey]]( "melee_distance" );

armNormal = [[ScriptEvent:getIntKey|getIntKey]]( "can_arm_normal" );
armCharge = [[ScriptEvent:getIntKey|getIntKey]]( "can_arm_charge" );
disarmCharge = [[ScriptEvent:getIntKey|getIntKey]]( "can_disarm_charge" );
canRepair = [[ScriptEvent:getIntKey|getIntKey]]( "can_repair" );
canConstruct = [[ScriptEvent:getIntKey|getIntKey]]( "can_construct" );
canHack = [[ScriptEvent:getIntKey|getIntKey]]( "can_hack" );
canDisguise = [[ScriptEvent:getIntKey|getIntKey]]( "can_disguise" );

fireRate = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "fire_rate", 0.1f );
repairCount = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "repair_count", 5.f );

if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
guiHandle = [[ScriptEvent:getGUI|getGUI]]( "0" );
}
}

void [[ScriptClass:tool_pliers|tool_pliers]]::init() {
if ( myPlayer.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() ) {
thread ToolTipThread_Raise();
}

[[ScriptEvent:weaponState|weaponState]]( "Raise", 0 );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::destroy() {
if ( myPlayer != $null_entity ) {
myPlayer.AI_HOLD_WEAPON = false;
}
[[ScriptEvent:stopAllEffects|stopAllEffects]]();
DestroySound();

if ( playingFireSound ) {
playingFireSound = false;
[[ScriptEvent:startSound|startSound]]( "snd_stop", SND_WEAPON_FIRE );
}
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Lower() {
StopFireEffect();

if ( playingFireSound ) {
playingFireSound = false;
[[ScriptEvent:startSound|startSound]]( "snd_stop", SND_WEAPON_FIRE );
}

[[ScriptEvent:startSound|startSound]]( "snd_lower", SND_WEAPON_IDLE );

Base_Lower();
}

boolean [[ScriptClass:tool_pliers|tool_pliers]]::AttackValid() {
boolean performAction = CheckAttack( MASK_VEHICLESOLID | CONTENTS_PLAYERCLIP );

if ( !performAction ) {
performAction = CheckAttack( CONTENTS_TRIGGER );
}

if ( !performAction ) {
performAction = CheckAttack( CONTENTS_RENDERMODEL );
}

return performAction;
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Idle() {
[[ScriptEvent:weaponReady|weaponReady]]();
[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "idle" );
StopFireEffect();

UpdateCharge();

while ( true ) {
UpdateGUI();

if ( WEAPON_LOWERWEAPON ) {
myPlayer.SetProgressBarVisible( false );
[[ScriptEvent:weaponState|weaponState]]( "Lower", PLIERS_IDLE_TO_LOWER );
}

if ( WEAPON_ATTACK ) {
if ( AttackValid() ) {
if ( !playingFireSound ) {
playingFireSound = true;
[[ScriptEvent:startSound|startSound]]( "snd_start", SND_WEAPON_FIRE );
}

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

[[ScriptEvent:weaponState|weaponState]]( "Attack", PLIERS_IDLE_TO_PUNCH );
} else {
if ( !myPlayer.[[ScriptEvent:isToolTipPlaying|isToolTipPlaying]]() ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() > nextActionFailMessageTime ) {
nextActionFailMessageTime = sys.[[ScriptEvent:getTime|getTime]]() + 5.f;
if ( cachedAction == AC_NONE ) {
myPlayer.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_action_failed" ) ) );
} else if ( cachedAction == AC_ENEMY_REPAIR ) {
myPlayer.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_enemy_repair" ) ) );
}
}
}
}
}

if ( playingFireSound ) {
playingFireSound = false;
[[ScriptEvent:startSound|startSound]]( "snd_stop", SND_WEAPON_FIRE );
}

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

void [[ScriptClass:tool_pliers|tool_pliers]]::StartFireEffect() {
if ( !fireEffectOn ) {
[[ScriptEvent:playEffect|playEffect]]( "fx_fire", idleEffectJoint, 1 );
fireEffectOn = true;
}
}

void [[ScriptClass:tool_pliers|tool_pliers]]::StopFireEffect() {
if ( fireEffectOn ) {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_fire" );
fireEffectOn = false;
}
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Attack() {
myPlayer.AI_HOLD_WEAPON = true;

float currentCachedAction = cachedAction;

if ( [[ScriptEvent:getFloatKey|getFloatKey]]( "has_startfire_anim" ) > 0 ) {
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "fire_start" );
waitUntil( [[ScriptEvent:animDone|animDone]]( ANIMCHANNEL_ALL, 0 ) );
}

StartFireEffect();

while ( true ) {
UpdateGUI();

if ( cachedAction == AC_REPAIR ) {
Repair();
} else if ( cachedAction == AC_ARM || cachedAction == AC_ARM_CHARGE ) {
Arm();
} else if ( cachedAction == AC_DISARM || cachedAction == AC_DISARM_CHARGE ) {
Disarm();
} else if ( cachedAction == AC_CONSTRUCT ) {
Construct();
} else if ( cachedAction == AC_HACK ) {
Hack();
} else if ( cachedAction == AC_POSSESS ) {
Possess();
}

float finishTime = sys.[[ScriptEvent:getTime|getTime]]() + fireRate;

while ( sys.[[ScriptEvent:getTime|getTime]]() < finishTime ) {
if ( [[ScriptEvent:animDone|animDone]]( ANIMCHANNEL_ALL, PLIERS_PUNCH_TO_IDLE ) ) {
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "fire" );
}

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

// re-enable running for any player that had it disabled AFTER the animation (otherwise it's pointless)
myPlayer.[[ScriptEvent:disableRun|disableRun]]( 0.f );

if ( !WEAPON_ATTACK ) {
break;
}

if ( WEAPON_LOWERWEAPON ) {
break;
}

if ( !AttackValid() ) {
break;
}
}

if ( [[ScriptEvent:getFloatKey|getFloatKey]]( "has_endfire_anim" ) > 0 ) {
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "fire_end" );
waitUntil( [[ScriptEvent:animDone|animDone]]( ANIMCHANNEL_ALL, 0 ) );
}

myPlayer.AI_HOLD_WEAPON = false;

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

[[ScriptEvent:weaponState|weaponState]]( "Idle", PLIERS_PUNCH_TO_IDLE );
}

boolean [[ScriptClass:tool_pliers|tool_pliers]]::CheckAttack( float mask ) {
cachedEntity = myPlayer.[[ScriptEvent:getCrosshairEntity|getCrosshairEntity]]();
cachedAction = AC_NONE;

if ( myPlayer.[[ScriptEvent:getCrosshairDistance|getCrosshairDistance]]( true ) > meleeDistance ) {
cachedEntity = $null_entity;
return false;
}

if ( cachedEntity == $null_entity ) {
// there is no crosshair entity to take priority
// try doing a melee trace
[[ScriptEvent:melee|melee]]( mask, meleeDistance, false, false );
cachedEntity = [[ScriptEvent:getMeleeEntity|getMeleeEntity]]();

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

if ( armCharge ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_ARM_CHARGE ) ) {
cachedAction = AC_ARM_CHARGE;
return true;
}
}

if ( disarmCharge ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_DISARM_CHARGE ) ) {
cachedAction = AC_DISARM_CHARGE;
return true;
}
}

if ( canRepair ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_REPAIR ) ) {
cachedAction = AC_REPAIR;
return true;
} else if ( cachedEntity.vCheckActionCode( myPlayer, AC_ENEMY_REPAIR ) ) {
cachedAction = AC_ENEMY_REPAIR;
return false;
}
}

if ( armNormal ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_ARM ) ) {
cachedAction = AC_ARM;
return true;
}

if ( cachedEntity.vCheckActionCode( myPlayer, AC_DISARM ) ) {
cachedAction = AC_DISARM;
return true;
}
}

if ( canConstruct ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_CONSTRUCT ) ) {
cachedAction = AC_CONSTRUCT;
return true;
}
}

if ( canHack ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_HACK ) ) {
cachedAction = AC_HACK;
return true;
}
}

if ( canDisguise ) {
if ( cachedEntity.vCheckActionCode( myPlayer, AC_POSSESS ) ) {
cachedAction = AC_POSSESS;
return true;
}
}

return false;
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Construct() {
myPlayer.[[ScriptEvent:disableRun|disableRun]]( 1.f );
cachedEntity.vConstruct( myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_CONSTRUCT );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Hack() {
myPlayer.[[ScriptEvent:disableRun|disableRun]]( 1.f );
cachedEntity.vHack( myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_HACK );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Possess() {
myPlayer.[[ScriptEvent:disableRun|disableRun]]( 1.f );
cachedEntity.vPossess( myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_POSSESS );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Repair() {
myPlayer.[[ScriptEvent:disableRun|disableRun]]( 1.f );

float scale = 1.f;
[[ScriptClass:team_base|team_base]] team = myPlayer.[[ScriptEvent:getGameTeam|getGameTeam]]();
if ( team.HasRepairBonus( myPlayer ) ) {
scale = 1.20f;
}

cachedEntity.vRepair( repairCount * scale, myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_REPAIR );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Disarm() {
cachedEntity.vArm( myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_DISARM );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::Arm() {
cachedEntity.vArm( myPlayer );
myPlayer.ShowProgressBar( cachedEntity, AC_ARM );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::ToolTipThread_Raise() {
myPlayer.[[ScriptEvent:cancelToolTips|cancelToolTips]]();
sys.[[ScriptEvent:wait|wait]]( myPlayer.CalcTooltipWait() );

WAIT_FOR_TOOLTIP;
myPlayer.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_1" ) ) );

WAIT_FOR_TOOLTIP;
myPlayer.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_2" ) ) );
}

void [[ScriptClass:tool_pliers|tool_pliers]]::UpdateGUI() {
if ( myPlayer != sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]() || guiHandle == GUI_INVALID ) {
return;
}

float guiState = GUI_STATE_IDLE;
if ( myPlayer.AI_HOLD_WEAPON ) {
guiState = GUI_STATE_ARMING;
} else if ( CheckAttack( MASK_VEHICLESOLID | CONTENTS_PLAYERCLIP ) ) {
if ( cachedAction == AC_ARM || cachedAction == AC_ARM_CHARGE ) {
guiState = GUI_STATE_CONNECTED;
}
}

guiTextHandle = GetTextHandleForState( guiState );
sys.[[ScriptEvent:setGUIHandle|setGUIHandle]]( GUI_GLOBALS_HANDLE, "armTool.statusTextHandle", guiTextHandle );
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "armTool.isSearching", guiState == GUI_STATE_IDLE );
}

handle [[ScriptClass:tool_pliers|tool_pliers]]::GetTextHandleForState( float state ) {
if ( state == GUI_STATE_ARMING ) { return sys.[[ScriptEvent:localizeString|localizeString]]( "game/arm/arming" );
} else if ( state == GUI_STATE_CONNECTED ) { return sys.[[ScriptEvent:localizeString|localizeString]]( "game/arm/connected" );
} else if ( state == GUI_STATE_IDLE ) { return sys.[[ScriptEvent:localizeString|localizeString]]( "game/arm/search" );
} else { sys.[[ScriptEvent:assert|assert]]( 0 );
}
return 0;
}

Script:Files:script/tools/pliers.script - Revision history

Wizz at 18:14, 2 November 2007