Wizz at 09:52, 5 November 2007

2007-11-05T09:52:57Z

New page

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

projectile_charge.script

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

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

void vSetOwner( entity other );
void vSetNewTarget( entity target );

void vOnEndGame();

float OnUpdateCrosshairInfo( entity p );
void DoExplodeEffect( entity collisionEnt );
float FindObjectives();
void GiveDisarmBonus( entity p );

void DoRadiusDamage();

void OnDisarmed( entity p );
void OnArmed( entity p );
void OnUnbind();

void SoundThread();

boolean IsCharge();

void UpdateGUI( entity armee );

void vOnTargetDestroyed();

float vGetFuseRemaining();
float vGetFuseLength();
entity vGetCurrentTarget();

void PlaceGlowThread();

void vOnContextDisarm( entity p );

float disarmProficiency;

entity owner;
entity armer;
entity bindTarget;
float disableRadius;
float disableTime;
float explodeTime;

[[ScriptClass:task|task]] disarmTask;

entity objectiveTarget;

float guiHandle;

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

void [[ScriptClass:projectile_charge|projectile_charge]]::preinit() {
ScheduleFizzle( [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "fizzle_time", 30 ) );

explodeTime = GetGlobalFloat( "charge_explode_time" );

disarmProficiency = GetProficiency( [[ScriptEvent:getKey|getKey]]( "prof_disarm" ) );

disableRadius = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "disable_radius", 512 );
disableTime = [[ScriptEvent:getFloatKeyWithDefault|getFloatKeyWithDefault]]( "disable_time", 30 );

guiHandle = GUI_INVALID;

thread PlaceGlowThread();

stuck = true;
}

void [[ScriptClass:projectile_charge|projectile_charge]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "bindTarget" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "objectiveTarget" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "owner" );
}

void [[ScriptClass:projectile_charge|projectile_charge]]::destroy() {
if ( disarmTask != $null_entity ) {
disarmTask.[[ScriptEvent:free|free]]();
}

if ( owner == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponChargePercent", 0 );
}

[[ScriptEvent:stopEffect|stopEffect]]( "fx_unarmed_glow" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_glow" );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptClass:player|player]] p = owner;

if ( p != $null_entity ) {
p.[[ScriptEvent:setPlayerChargeArmed|setPlayerChargeArmed]]( false, self ); //mal: if we fizzled, or blew up, clear out our owners tracker.
}
}

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

sys.[[ScriptEvent:killThread|killThread]]( "UpdateGUI_" + [[ScriptEvent:getName|getName]]() );
sys.[[ScriptEvent:killThread|killThread]]( "SoundThread_" + [[ScriptEvent:getName|getName]]() );
}

void [[ScriptClass:projectile_charge|projectile_charge]]::UpdateGUI( entity armee ) {
float length = vGetFuseLength();
if( length <= 0 ) {
return;
}

// Gordon: Not sure why this is being done like this, it could easily be fire and forget

float value;
[[ScriptClass:player|player]] p = owner;
float timeLeft;
boolean updateGui;
while( true ) {
value = 1.0 - ( vGetFuseRemaining() / length );
if( value >= 1.0f ) {
return;
}

updateGui = false;
if ( p != $null_entity ) {
if ( p == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
if ( [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p ) == TA_FRIEND ) {
float armeeClass = p.[[ScriptEvent:getPlayerClass|getPlayerClass]]();
if ( armeeClass == g_playerClassSoldier || armeeClass == g_playerClassAggressor ) {
updateGui = true;
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponChargePercent", value );
}
}
}
}

if ( !updateGui ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponChargePercent", 0 );
break;
}

if ( guiHandle != GUI_INVALID ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( guiHandle, "charge.timeLeft", vGetFuseRemaining() );
}

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

void [[ScriptClass:projectile_charge|projectile_charge]]::vSetOwner( entity other ) {
owner = other;
}

float [[ScriptClass:projectile_charge|projectile_charge]]::FindObjectives() {
return [[ScriptEvent:entitiesOfCollection|entitiesOfCollection]]( "hetrigger" );
}

void [[ScriptClass:projectile_charge|projectile_charge]]::OnArmed( entity p ) {
armer = p;

ProjectileArmable_OnArmed( p );

CancelFizzle();

if ( sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() != $null_entity ) {
thread SoundThread();
thread UpdateGUI( p );
}

ScheduleExplosion( explodeTime, MS_EXPLODED );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptClass:player|player]] playerEnt = p;

if ( playerEnt != $null_entity ) {
playerEnt.[[ScriptEvent:setPlayerChargeArmed|setPlayerChargeArmed]]( true, self ); //mal: this charge is armed. Code elsewhere will notify the bots if its a noteworthy arming event.
}

// alert nearby entities
float count;
float i;
entity ent;

count = FindObjectives();

for ( i = 0; i < count; i++ ) {
ent = [[ScriptEvent:getBoundsCacheEntity|getBoundsCacheEntity]]( i );
if ( self.[[ScriptEvent:touches|touches]]( ent, 0 ) ) {
if ( bindTarget != ent.vGetCurrentTarget() ) {
continue;
}

if ( ent.vChargePlaced( self, armer ) ) {
objectiveTarget = ent.vGetCurrentTarget();

if ( [[ScriptEvent:getGameTeam|getGameTeam]]() == gdfTeam ) {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_disarm_strogg" ), stroggTeam );
} else {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_disarm_gdf" ), gdfTeam );
}
break;
}
}
}

if ( objectiveTarget != $null_entity ) {
disarmTask = taskManager.[[ScriptEvent:allocEntityTask|allocEntityTask]]( GetPlayerTask( [[ScriptEvent:getKey|getKey]]( "task_defuse" ) ), self );
}
}
}

void [[ScriptClass:projectile_charge|projectile_charge]]::OnUnbind() {
if( armingEntity == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) { // Gordon: I don't really get what this is meant to do
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponChargePercent", 0 );
}

[[ScriptEvent:stopEffect|stopEffect]]( "fx_unarmed_glow" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_glow" );
Fizzle();
}

void [[ScriptClass:projectile_charge|projectile_charge]]::GiveDisarmBonus( entity p ) {
float useDisarmProficiency = disarmProficiency;

if ( objectiveTarget != $null_entity ) {
objectiveTarget.vChargeDisarmed( self, p );

useDisarmProficiency = objectiveTarget.vGetDisarmProficiency();
}

if ( useDisarmProficiency != -1 ) {
if ( [[ScriptEvent:getEntityAllegiance|getEntityAllegiance]]( p ) == TA_ENEMY ) {
p.[[ScriptEvent:giveProficiency|giveProficiency]]( useDisarmProficiency, 1.f, disarmTask, "disarmed charge" );
}
}
}

void [[ScriptClass:projectile_charge|projectile_charge]]::OnDisarmed( entity p ) {
GiveDisarmBonus( p );

ProjectileArmable_OnDisarmed( p );

if ( bindTarget.vIsDestructibleObjective() ) {
if ( [[ScriptEvent:getGameTeam|getGameTeam]]() == gdfTeam ) {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_disarmed_strogg" ), stroggTeam );
} else {
objManager.PlaySound( [[ScriptEvent:getKey|getKey]]( "snd_disarmed_gdf" ), gdfTeam );
}
}

if ( owner == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
sys.[[ScriptEvent:setGUIFloat|setGUIFloat]]( GUI_GLOBALS_HANDLE, "gameHud.weaponChargePercent", 0 );
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( disarmTask != $null_entity ) {
disarmTask.[[ScriptEvent:free|free]]();
}
}

CancelExplosion();
[[ScriptEvent:stopEffect|stopEffect]]( "fx_glow" );
Fizzle();
}

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

[[ScriptClass:team_base|team_base]] team;

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

CheckContextToolTip( allegiance, code, p );
}

handle nameHandle = sys.[[ScriptEvent:localizeString|localizeString]]( [[ScriptEvent:getKey|getKey]]( "task_name" ) );
if ( objectiveTarget != $null_entity ) {
string objName = objectiveTarget.[[ScriptEvent:getKey|getKey]]( "charge_name" );
if ( objName != "" ) {
nameHandle = sys.[[ScriptEvent:localizeString|localizeString]]( objName );
}
}
index = [[ScriptEvent:chAddLine|chAddLine]]();
[[ScriptEvent:chSetLineTextIndex|chSetLineTextIndex]]( index, nameHandle );
[[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;
}

void [[ScriptClass:projectile_charge|projectile_charge]]::DoRadiusDamage() {
if ( splashDamageIndex != -1 ) {
float power = 1.f;
sys.[[ScriptEvent:applyRadiusDamage|applyRadiusDamage]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]](), self, armer, radiusDamageIgnoreEntity, self, splashDamageIndex, power, 1.f );
}
}

void [[ScriptClass:projectile_charge|projectile_charge]]::DoExplodeEffect( entity collisionEnt ) {
if ( objectiveTarget != $null_entity ) {
objectiveTarget.vChargeExploded( self, armer );
}

DoRadiusDamage();

ScheduleRemoval( 0.5f );
}

boolean [[ScriptClass:projectile_charge|projectile_charge]]::IsCharge() {
return true;
}

void [[ScriptClass:projectile_charge|projectile_charge]]::vSetNewTarget( entity target ) {
bindTarget = target;
}

void [[ScriptClass:projectile_charge|projectile_charge]]::SoundThread() {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_unarmed_glow" );

sys.[[ScriptEvent:wait|wait]]( [[ScriptEvent:startSound|startSound]]( "snd_armed", SND_WEAPON_SIG ) );

if ( IsCharge() ) {
// find a good position for the light
vector lStart = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 );
vector lEnd = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 ) * 50.0f;
float frac = sys.[[ScriptEvent:tracePoint|tracePoint]]( lStart, lEnd, CONTENTS_SOLID, self );
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_glow", "", lStart + ( lEnd - lStart ) * frac * 0.95f, vec3_up, 1 );

sys.[[ScriptEvent:wait|wait]]( 24.f );

[[ScriptEvent:stopEffect|stopEffect]]( "fx_glow" );

while ( true ) {
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_glow", "", lStart + ( lEnd - lStart ) * frac * 0.95f, vec3_up, 1 );
sys.[[ScriptEvent:wait|wait]]( 0.5f );
[[ScriptEvent:killEffect|killEffect]]( "fx_glow" );
}
}
}

void [[ScriptClass:projectile_charge|projectile_charge]]::vOnTargetDestroyed() {
[[ScriptEvent:remove|remove]]();
}

float [[ScriptClass:projectile_charge|projectile_charge]]::vGetFuseRemaining() {
return explodeTime - ( sys.[[ScriptEvent:getTime|getTime]]() - armTime );
}

float [[ScriptClass:projectile_charge|projectile_charge]]::vGetFuseLength() {
return explodeTime;
}

entity [[ScriptClass:projectile_charge|projectile_charge]]::vGetCurrentTarget() {
return objectiveTarget;
}

void [[ScriptClass:projectile_charge|projectile_charge]]::PlaceGlowThread() {
while ( true ) {
if ( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() != vec3_origin ) {
break;
}
sys.[[ScriptEvent:wait|wait]]( 1.0f );
}

vector lStart = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 );
vector lEnd = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + [[ScriptEvent:getWorldAxis|getWorldAxis]]( 0 ) * 50.0f;
float frac = sys.[[ScriptEvent:tracePoint|tracePoint]]( lStart, lEnd, CONTENTS_SOLID, self );
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_unarmed_glow", "", lStart + ( lEnd - lStart ) * frac * 0.95f, vec3_up, 1 );
}

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

if ( objectiveTarget == $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:projectile_charge|projectile_charge]]::vOnEndGame() {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_unarmed_glow" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_glow" );
Fizzle();
}

Script:Files:script/projectiles/charge.script - Revision history

Wizz at 09:52, 5 November 2007