Wizz at 10:15, 5 November 2007

2007-11-05T10:15:49Z

New page

object [[ScriptClass:hackable_objective|hackable_objective]] {
void preinit();
void syncFields();
void destroy();

float vGetPliersProgressBarValue( float action );
boolean vCheckActionCode( entity p, float actionCode );

void vMakePrimaryObjective( boolean value );

void vCreateMission();
void vFreeMission();
void vCompleteMission();

void OnUpdateGui( entity p );
float OnActivate( entity p, float distance );
float OnUpdateCrosshairInfo( entity p );

boolean HasHackContext( entity other );

float GetActivateCode( entity p, float distance );

void OnHacked( entity p );
void OnHacked_Base( entity p );

void OnIsPrimaryObjectiveChanged();
void OnHackCountChanged();

void SetObjectiveIndicator();
void ClearObjectiveIndicator();
void UpdateObjectiveProgress();
float CalcObjectiveProgress();
void UpdateObjectiveThread();
void SetObjectiveReminderTime( float time );

void KillFizzleThread();
void CreateFizzleThread( float delay );
void OnFizzled();
void FizzleThread( float delay );

void SetObjectiveIndex( float index );

boolean AllowHack() { return true; }

void vHack( entity p );

string vGetObjectiveString() { return "hackObjective"; }

[[ScriptClass:team_base|team_base]] baseTeam;

boolean isPrimaryObjective;

boolean vIsPrimaryObjective() { return isPrimaryObjective; }

void vOnContextDefend( entity p );
void vOnContextHack( entity p );

float hackCount;
float maxHackCount;

float objectiveIndex;

float objectiveGUI;

handle progressMessage;
float nextProgressMessageTime;

float infoToolTip;
float useMeToolTip1;
float useMeToolTip2;

handle objectName;

[[ScriptClass:task|task]] missionTask;

float fizzleTime;
float fizzleEndTime;
boolean fizzleThreadActive;

float hackProficiency;

entity hacker;
float lastHackTime;
boolean forceMessage;

float nextObjectiveReminderTime;

[[ScriptClass:flashpoint_obj|flashpoint_obj]] flashpoint;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::preinit() {
[[ScriptEvent:setGameTeam|setGameTeam]]( sys.[[ScriptEvent:getTeam|getTeam]]( [[ScriptEvent:getKey|getKey]]( "team" ) ) );

hackProficiency = GetProficiency( [[ScriptEvent:getKey|getKey]]( "prof_hack" ) );

baseTeam = [[ScriptEvent:getGameTeam|getGameTeam]]();
objectiveIndex = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "objective_index", -1 );

fizzleTime = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "fizzle_time", 60.f );

progressMessage = sys.[[ScriptEvent:localizeString|localizeString]]( [[ScriptEvent:getKeyWithDefault|getKeyWithDefault]]( "progress_message", "maps/generic/obj_hacking" ) ); //"is hacking the objective!" );

maxHackCount = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "hack_count", 100.f );
objectName = sys.[[ScriptEvent:localizeString|localizeString]]( [[ScriptEvent:getKeyWithDefault|getKeyWithDefault]]( "object_name", "maps/generic/obj_hackable" ) );

forceMessage = false;

infoToolTip = GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_info" ) );
useMeToolTip1 = GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_use_me_1" ) );
useMeToolTip2 = GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_intro_use_me_2" ) );

objectiveGUI = -1;
if ( [[ScriptEvent:getIntKey|getIntKey]]( "use_objective_gui" ) ) {
objectiveGUI = [[ScriptEvent:getGUI|getGUI]]( "0" );
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::syncFields() {
[[ScriptEvent:sync|sync]]( "hackCount" );
[[ScriptEvent:syncCallback|syncCallback]]( "hackCount", "OnHackCountChanged" );
}

void [[ScriptClass:hackable_objective|hackable_objective]]::destroy() {
vFreeMission();

if ( flashpoint != $null ) {
delete flashpoint;
}

if ( isPrimaryObjective ) {
ClearObjectiveIndicator();
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnIsPrimaryObjectiveChanged() {
ClearObjectiveIndicator();

if ( isPrimaryObjective ) {
SetObjectiveIndicator();
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::SetObjectiveReminderTime( float time ) {
if ( time > nextObjectiveReminderTime ) {
nextObjectiveReminderTime = time;
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::UpdateObjectiveThread() {
waitUntil( objManager.gameState == GS_GAMEON );

objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_intro_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_intro_gdf" ), gdfTeam );

SetObjectiveReminderTime( sys.[[ScriptEvent:getTime|getTime]]() + OBJECTIVEMESSAGE_WAIT_TIME );

while ( true ) {
UpdateObjectiveProgress();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() >= nextObjectiveReminderTime ) {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_reminder_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_reminder_gdf" ), gdfTeam );

SetObjectiveReminderTime( sys.[[ScriptEvent:getTime|getTime]]() + OBJECTIVEMESSAGE_WAIT_TIME );
}
}

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

void [[ScriptClass:hackable_objective|hackable_objective]]::SetObjectiveIndicator() {
UpdateObjectiveProgress();

thread UpdateObjectiveThread();

if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "hackObjective.active", 1.f );
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::ClearObjectiveIndicator() {
sys.[[ScriptEvent:killThread|killThread]]( "UpdateObjectiveThread_" + [[ScriptEvent:getName|getName]]() );

if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "hackObjective.active", 0.f );
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::UpdateObjectiveProgress() {
if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
float progress = CalcObjectiveProgress();
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "hackObjective.progress", progress );
}
}

float [[ScriptClass:hackable_objective|hackable_objective]]::CalcObjectiveProgress() {
return hackCount / maxHackCount;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vMakePrimaryObjective( boolean value ) {
isPrimaryObjective = value;

OnIsPrimaryObjectiveChanged();
}

boolean [[ScriptClass:hackable_objective|hackable_objective]]::vCheckActionCode( entity p, float actionCode ) {
if ( objManager.gameState != GS_GAMEON ) {
return false;
}

if ( actionCode == AC_HACK && AllowHack() ) {
if ( p.[[ScriptEvent:getGameTeam|getGameTeam]]() == baseTeam ) {
return false;
}
return [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p ) == TA_ENEMY;
}

return false;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnHacked( entity p ) {
OnHacked_Base( p );
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnHacked_Base( entity p ) {
object newTeam = p.[[ScriptEvent:getGameTeam|getGameTeam]]();

string statName = newTeam.[[ScriptEvent:getName|getName]]();
if ( objectiveIndex != -1 ) {
statName = statName + "_primary";
objManager.CompleteObjective( objectiveIndex, p );
} else {
statName = statName + "_secondary";
}
statName = statName + "_objective_hacked";

if ( p != $null_entity ) {
sys.[[ScriptEvent:increaseStatInt|increaseStatInt]]( sys.[[ScriptEvent:allocStatInt|allocStatInt]]( statName ), p.[[ScriptEvent:getEntityNumber|getEntityNumber]](), 1 );
sys.[[ScriptEvent:increaseStatInt|increaseStatInt]]( sys.[[ScriptEvent:allocStatInt|allocStatInt]]( newTeam.[[ScriptEvent:getName|getName]]() + "_hack_uses" ), p.[[ScriptEvent:getEntityNumber|getEntityNumber]](), 1 );
}

objManager.OnHackComplete( self );

G_PlayObjectiveCompletedRollEnt( self );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_finished_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_finished_gdf" ), gdfTeam );

[[ScriptEvent:setGameTeam|setGameTeam]]( newTeam );

KillFizzleThread();
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnUpdateGui( entity p ) {
float guiHandle = [[ScriptEvent:getGUI|getGUI]]( "0" );
if ( guiHandle == GUI_INVALID ) {
return;
}

if ( self.[[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p ) != TA_FRIEND ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( guiHandle, "disabled", 1 );
} else {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( guiHandle, "disabled", 0 );
}
}

boolean [[ScriptClass:hackable_objective|hackable_objective]]::HasHackContext( entity other ) {
object otherTeam = other.[[ScriptEvent:getGameTeam|getGameTeam]]();
if ( otherTeam == baseTeam ) {
return false;
}

if ( otherTeam == [[ScriptEvent:getGameTeam|getGameTeam]]() ) {
return false;
}

if ( !AllowHack() ) {
return false;
}

return true;
}

float [[ScriptClass:hackable_objective|hackable_objective]]::GetActivateCode( entity p, float distance ) {
if ( objManager.gameState != GS_GAMEON ) {
return AK_INWARMUP;
}

if ( p.[[ScriptEvent:getViewingEntity|getViewingEntity]]() != p ) {
return AK_NONE;
}

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

float allegiance = [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p );

if ( p.[[ScriptEvent:getGameTeam|getGameTeam]]() == baseTeam ) {
return AK_NONE;
}

if ( p.[[ScriptEvent:getGameTeam|getGameTeam]]() == [[ScriptEvent:getGameTeam|getGameTeam]]() ) {
return AK_NONE;
}

if ( distance < DISTANCE_FOR_ACTION ) {
if ( AllowHack() ) {
if ( p.[[ScriptEvent:hasAbility|hasAbility]]( "hack" ) ) {
return AK_HACK;
}
}
}

return AK_NONE;
}

float [[ScriptClass:hackable_objective|hackable_objective]]::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;

if ( p.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() && objectiveIndex != -1 ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( infoToolTip );
}

// see if theres a valid action to perform
float code = GetActivateCode( p, distance );
if ( code != AK_NONE && p.vHasActionItem( code ) ) {
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 ) ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip1 );
} else {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( useMeToolTip2 );
}
}
}
}
} else if ( code == AK_INWARMUP ) {
if ( p.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() && distance < DISTANCE_FOR_ACTION ) {
[[ScriptClass:team_base|team_base]] team = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
if ( team != $null_entity ) {
p.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_noobjective" ) ) );
}
}
}

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

return 1.f;
}

float [[ScriptClass:hackable_objective|hackable_objective]]::vGetPliersProgressBarValue( float action ) {
if ( action == AC_HACK ) {
return hackCount / maxHackCount;
}

return 0.f;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vHack( entity p ) {
float time = sys.[[ScriptEvent:getTime|getTime]]();
entity oldHacker = hacker;
if ( hacker == $null_entity || lastHackTime < time - 2 ) {
hacker = p;
if ( lastHackTime < time - 10 ) {
oldHacker = $null_entity;
}
}

if ( objectiveIndex != -1 || forceMessage ) {
if ( p == hacker ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() > nextProgressMessageTime ) {
objManager.PushCPrintString( p.[[ScriptEvent:getUserName|getUserName]]() );
objManager.CPrintEvent( progressMessage, $null );
nextProgressMessageTime = sys.[[ScriptEvent:getTime|getTime]]() + 5.f;
}

if ( hacker != oldHacker ) {

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
objManager.[[ScriptEvent:setBotActionStateForEvent|setBotActionStateForEvent]]( ACTION_STATE_START_HACK, hacker ); //mal: let the bots know someone is hacking the obj!
}

objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_hacking_strogg" ), stroggTeam );
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_hacking_gdf" ), gdfTeam );

SetObjectiveReminderTime( sys.[[ScriptEvent:getTime|getTime]]() + ( OBJECTIVEMESSAGE_WAIT_TIME * 0.5f ) );
}
}
}

lastHackTime = time;

if ( hackCount >= maxHackCount ) {
hackCount = 0;
}

float count = 1;
[[ScriptClass:team_base|team_base]] team = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
if ( team.HasFastHackBonus( p ) ) {
count = count * 1.25f;
}

hackCount = hackCount + count;
OnHackCountChanged();

if ( hackProficiency != -1 ) {
p.[[ScriptEvent:giveProficiency|giveProficiency]]( hackProficiency, ( count / maxHackCount ), missionTask, "hacking objective" );
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( hackCount >= maxHackCount ) {
OnHacked( p );
} else {
if ( fizzleTime > 0.f ) {
CreateFizzleThread( fizzleTime );
}
}
}
}

float [[ScriptClass:hackable_objective|hackable_objective]]::OnActivate( entity p, float distance ) {
if ( distance > 128.f ) {
return 0.0f;
}

if ( p.[[ScriptEvent:getViewingEntity|getViewingEntity]]() != p ) {
return 0.0f;
}

if ( vCheckActionCode( p, AC_HACK ) ) {
if ( p.[[ScriptEvent:isDisguised|isDisguised]]() ) {
p.[[ScriptEvent:disguise|disguise]]( $null_entity );
}

[[ScriptClass:team_base|team_base]] team = p.[[ScriptEvent:getGameTeam|getGameTeam]]();
team.SelectActionItem( p, AK_HACK );
}

return 1.f;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::SetObjectiveIndex( float index ) {
objectiveIndex = index;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vCreateMission() {
vFreeMission();
missionTask = taskManager.[[ScriptEvent:allocEntityTask|allocEntityTask]]( GetPlayerTask( [[ScriptEvent:getKey|getKey]]( "task_hack" ) ), self );
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vFreeMission() {
if ( missionTask != $null ) {
missionTask.[[ScriptEvent:free|free]]();
missionTask = $null;
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vCompleteMission() {
if ( missionTask != $null ) {
missionTask.[[ScriptEvent:complete|complete]]();
missionTask.[[ScriptEvent:free|free]]();
missionTask = $null;
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::KillFizzleThread() {
fizzleEndTime = 0;
}

void [[ScriptClass:hackable_objective|hackable_objective]]::CreateFizzleThread( float delay ) {
fizzleEndTime = sys.[[ScriptEvent:getTime|getTime]]() + delay;
if ( !fizzleThreadActive ) {
thread FizzleThread( delay );
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnFizzled() {
hackCount = 0;
OnHackCountChanged();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
objManager.[[ScriptEvent:setBotActionStateForEvent|setBotActionStateForEvent]]( ACTION_STATE_HACK_FIZZLED, self ); //mal: let the bots know the hack has fizzled
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::FizzleThread( float delay ) {
fizzleThreadActive = true;
while ( sys.[[ScriptEvent:getTime|getTime]]() < fizzleEndTime ) {
sys.[[ScriptEvent:wait|wait]]( fizzleEndTime - sys.[[ScriptEvent:getTime|getTime]]() );
}
fizzleThreadActive = false;
if ( fizzleEndTime != 0 ) {
OnFizzled();
}
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vOnContextDefend( entity p ) {
[[ScriptClass:player|player]] local = sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]();
if ( local == $null_entity || p == $null_entity ) {
return;
}

if ( flashpoint != $null ) {
delete flashpoint;
}

flashpoint = new [[ScriptClass:flashpoint_obj|flashpoint_obj]];
flashpoint.SetOwner( self );
flashpoint.SetMaterial( [[ScriptEvent:getKey|getKey]]( "mtr_icon_flash_defend" ) );
}

void [[ScriptClass:hackable_objective|hackable_objective]]::vOnContextHack( entity p ) {
[[ScriptClass:player|player]] local = sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]();
if ( local == $null_entity || p == $null_entity ) {
return;
}

if ( flashpoint != $null ) {
delete flashpoint;
}

flashpoint = new [[ScriptClass:flashpoint_obj|flashpoint_obj]];
flashpoint.SetOwner( self );
flashpoint.SetMaterial( [[ScriptEvent:getKey|getKey]]( "mtr_icon_flash" ) );
}

void [[ScriptClass:hackable_objective|hackable_objective]]::OnHackCountChanged() {
if ( objectiveGUI != -1 ) {
if ( sys.[[ScriptEvent:doClientSideStuff|doClientSideStuff]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( objectiveGUI, "progress", CalcObjectiveProgress() );
}
}
}

Script:Files:script/maps/generic/hackable objective.script - Revision history

Wizz at 10:15, 5 November 2007