Wizz at 18:17, 2 November 2007

2007-11-02T18:17:43Z

New page

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

tool_force_shield.script

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

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

void Idle();
void OnHit( object traceObject, vector v, entity other );
void OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location );

float dieTime;
float nextBlink;
boolean blinkState;
float nextEffectTime;

entity owner;
}

object [[ScriptClass:tool_force_shield|tool_force_shield]] : [[ScriptClass:weapon_base|weapon_base]] {
void preinit();
void init();
void destroy();

void Raise();
void Lower();
void Idle();

void Fire();

boolean CanFire();

void ToolTipThread_Raise();

void StartIdleEffect();
void StopIdleEffect();

void StartRechargeEffect();
void StopRechargeEffect();

boolean recharge;
float nextChargeMessageTime;

boolean rechargeEffectOn;
boolean idleEffectOn;
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::preinit() {
rechargeEffectOn = false;
idleEffectOn = false;
}

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

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

void [[ScriptClass:tool_force_shield|tool_force_shield]]::destroy() {
StopIdleEffect();
StopRechargeEffect();
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::Raise() {
UpdateCharge();

Base_Raise();
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::Lower() {
StopIdleEffect();
StopRechargeEffect();

Base_Lower();
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::Idle() {
[[ScriptEvent:weaponReady|weaponReady]]();
boolean playingRecharge;
if ( recharge ) {
playingRecharge = true;
recharge = false;
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "recharge" );

StopIdleEffect();
StartRechargeEffect();
} else {
[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "idle" );

StopRechargeEffect();
StartIdleEffect();
}

while ( true ) {
if ( WEAPON_LOWERWEAPON ) {
[[ScriptEvent:weaponState|weaponState]]( "Lower", 4 );
}

if ( WEAPON_ATTACK ) {
if ( !mainFireDown ) {
mainFireDown = true;
if ( CanFire() ) {
[[ScriptEvent:weaponState|weaponState]]( "Fire", 0 );
} else {
if ( myPlayer.[[ScriptEvent:isLocalPlayer|isLocalPlayer]]() ) {
myPlayer.[[ScriptEvent:sendToolTip|sendToolTip]]( GetToolTip( [[ScriptEvent:getKey|getKey]]( "tt_need_charge" ) ) );
sys.[[ScriptEvent:startSoundDirect|startSoundDirect]]( [[ScriptEvent:getKey|getKey]]( "snd_need_charge" ), SND_ANY );
G_NotifyNoCharge( myPlayer );
}
}
}
} else {
mainFireDown = false;
}

UpdateCharge();

if ( playingRecharge && [[ScriptEvent:animDone|animDone]]( ANIMCHANNEL_ALL, 4 ) ) {
playingRecharge = false;

[[ScriptEvent:setBlendFrames|setBlendFrames]]( ANIMCHANNEL_ALL, 4 );
[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "idle" );

StopRechargeEffect();
StartIdleEffect();
}

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

boolean [[ScriptClass:tool_force_shield|tool_force_shield]]::CanFire() {
return myPlayer.EnergyBar_CanRemove( chargePerUse );
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::Fire() {
[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "fire" );
[[ScriptEvent:fired|fired]]();
sys.[[ScriptEvent:wait|wait]]( 0.1 );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
myPlayer.EnergyBar_Remove( chargePerUse );

string defName = "def_forcefield";
if ( myPlayer.[[ScriptEvent:getProficiency|getProficiency]]( g_proficiencyOppressor ) >= 2 ) {
defName = "def_forcefield_mega";
}

entity shieldProj = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( defName ) );

vector origin = myPlayer.[[ScriptEvent:getViewOrigin|getViewOrigin]]();
vector forward = sys.[[ScriptEvent:angToForward|angToForward]]( myPlayer.[[ScriptEvent:getViewAngles|getViewAngles]]() );
float throwDistance = 32.0f;
vector throwPos = origin + forward * throwDistance;
float meleeDistance = 64.0f;

if( [[ScriptEvent:melee|melee]]( MASK_SHOT_BOUNDINGBOX | MASK_PROJECTILE, meleeDistance, true, false ) ) {
float traceDistance = [[ScriptEvent:getMeleeFraction|getMeleeFraction]]() * meleeDistance;

vector size = shieldProj.[[ScriptEvent:getSize|getSize]]();
float pullOut = sys.[[ScriptEvent:vecLength|vecLength]]( size ) * 0.6f;

if ( traceDistance < meleeDistance + pullOut ) {
throwPos = origin + forward * ( traceDistance - pullOut );
}
}

myPlayer.[[ScriptEvent:setForceShieldState|setForceShieldState]]( false, shieldProj ); //mal: let the bots know theres a shield out there in the world.

shieldProj.[[ScriptEvent:setOrigin|setOrigin]]( throwPos );
vector velocity = shieldProj.[[ScriptEvent:getVectorKeyWithDefault|getVectorKeyWithDefault]]( "velocity", '400 0 0' );
velocity = forward * velocity_x;
shieldProj.[[ScriptEvent:setLinearVelocity|setLinearVelocity]]( velocity );
shieldProj.vSetOwner( myPlayer );
}

waitUntil( [[ScriptEvent:animDone|animDone]]( ANIMCHANNEL_ALL, 1 ) );
recharge = true;

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

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

void [[ScriptClass:tool_force_shield|tool_force_shield]]::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_force_shield|tool_force_shield]]::StartIdleEffect() {
if ( idleEffectOn == false ) {
if ( myPlayer == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
[[ScriptEvent:playEffect|playEffect]]( "fx_loop", "joint7", 1 );
idleEffectOn = true;
}
}
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::StopIdleEffect() {
if ( idleEffectOn == true ) {
if ( myPlayer == sys.[[ScriptEvent:getLocalPlayer|getLocalPlayer]]() ) {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_loop" );
idleEffectOn = false;
}
}
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::StartRechargeEffect() {
if ( rechargeEffectOn == false ) {
[[ScriptEvent:playEffect|playEffect]]( "fx_recharge", "joint7", 0 );
[[ScriptEvent:playEffect|playEffect]]( "fx_recharge2", "joint4", 0 );
[[ScriptEvent:playEffect|playEffect]]( "fx_recharge3", "joint1", 0 );
rechargeEffectOn = true;
}
}

void [[ScriptClass:tool_force_shield|tool_force_shield]]::StopRechargeEffect() {
if ( rechargeEffectOn == true ) {
[[ScriptEvent:stopEffect|stopEffect]]( "fx_recharge" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_recharge2" );
[[ScriptEvent:stopEffect|stopEffect]]( "fx_recharge3" );
rechargeEffectOn = false;
}
}

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

The force_shield itself

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

void [[ScriptClass:force_shield|force_shield]]::preinit() {
nextEffectTime = 0;
}

void [[ScriptClass:force_shield|force_shield]]::init() {
[[ScriptEvent:setContents|setContents]]( CONTENTS_FORCEFIELD | CONTENTS_EXPLOSIONSOLID );
[[ScriptEvent:setClipmask|setClipmask]]( CONTENTS_PROJECTILE );

[[ScriptEvent:setState|setState]]( "Idle" );
}

void [[ScriptClass:force_shield|force_shield]]::destroy() {
}

void [[ScriptClass:force_shield|force_shield]]::Idle() {
[[ScriptEvent:setNetworkSynced|setNetworkSynced]]( 1.f );
float blinkStart = [[ScriptEvent:getFloatKey|getFloatKey]]( "blink_start" );
float blinkMultiplier = [[ScriptEvent:getFloatKey|getFloatKey]]( "blink_multiplier" );
float blinkMaxOff = [[ScriptEvent:getFloatKey|getFloatKey]]( "blink_max_off" );

dieTime = sys.[[ScriptEvent:getTime|getTime]]() + [[ScriptEvent:getFloatKey|getFloatKey]]( "life_time" );
float nextBlink = blinkStart + 0.01;
blinkState = false;
[[ScriptEvent:setShaderParm|setShaderParm]]( 4, 0 );

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

while ( true ) {
float timeLeft = dieTime - sys.[[ScriptEvent:getTime|getTime]]();
if ( timeLeft <= blinkStart ) {
// Shader does a table lookup based on the time left
float fade = 1.0f - ( timeLeft / blinkStart );
[[ScriptEvent:setShaderParm|setShaderParm]]( 4, fade );
}

[[ScriptEvent:setShaderParm|setShaderParm]]( 5, [[ScriptEvent:getHealth|getHealth]]() / [[ScriptEvent:getMaxHealth|getMaxHealth]]());

if ( timeLeft <= 0 && !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptEvent:remove|remove]]();
}

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

void [[ScriptClass:force_shield|force_shield]]::OnKilled( entity inflictor, entity attacker, float damage, vector direction, float location ) {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
// TODO: Apply a nice effect here
[[ScriptEvent:remove|remove]]();
}
}

void [[ScriptClass:force_shield|force_shield]]::OnHit( object traceObject, vector v, entity other ) {
if ( sys.[[ScriptEvent:getTime|getTime]]() > nextEffectTime ) {
vector endPos = traceObject.[[ScriptEvent:getTracePoint|getTracePoint]]();
vector endNormal = traceObject.[[ScriptEvent:getTraceNormal|getTraceNormal]]();
[[ScriptEvent:playOriginEffect|playOriginEffect]]( "fx_hit", "", endPos, endNormal, false );
nextEffectTime = sys.[[ScriptEvent:getTime|getTime]]() + 0.1;
}
}

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

The projectile that spawns the force_shield itself

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

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

void Idle();

void OnTouch( entity other, object traceObject );
float OnCollide( object traceObject, vector velocity, float bodyId );
void OnShieldProjSync();
void OnUnbind();
void OnPostThink();

entity owner;
[[ScriptClass:force_shield|force_shield]] shieldProj;
boolean placedShield;
vector launchAngles;

void vSetOwner( entity o );
};

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::preinit() {
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::init() {
placedShield = false;

[[ScriptEvent:setContents|setContents]]( 0 );
[[ScriptEvent:setClipmask|setClipmask]]( MASK_SHOT_RENDERMODEL | MASK_PROJECTILE );

[[ScriptEvent:setState|setState]]( "Idle" );
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::vSetOwner( entity o ) {
owner = o;

launchAngles = owner.[[ScriptEvent:getViewAngles|getViewAngles]]();
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::destroy() {
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "shieldProj" );
[[ScriptEvent:syncCallback|syncCallback]]( "shieldProj", "OnShieldProjSync" );
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::OnShieldProjSync() {
shieldProj.[[ScriptEvent:bind|bind]]( self );
placedShield = true;
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::Idle() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
float dieTime = sys.[[ScriptEvent:getTime|getTime]]() + 5.0f;

while ( true ) {
if ( shieldProj == $null_entity && placedShield ) {
[[ScriptEvent:remove|remove]]();
}
if ( !placedShield && sys.[[ScriptEvent:getTime|getTime]]() > dieTime ) {
[[ScriptEvent:remove|remove]]();
}

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

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::OnUnbind() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( shieldProj != $null_entity ) {
shieldProj.[[ScriptEvent:remove|remove]]();
}
}
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::OnTouch( entity other, object traceObject ) {
}

// NOTE: If this returns true, all momentum on the object will be cleared, otherwise, it will bounce
float [[ScriptClass:projectile_forceshield|projectile_forceshield]]::OnCollide( object traceObject, vector velocity, float bodyId ) {
float shaderFlags;
entity collisionEnt;

shaderFlags = traceObject.[[ScriptEvent:getTraceSurfaceFlags|getTraceSurfaceFlags]]();
if ( shaderFlags & SURF_NOIMPACT || shaderFlags & SURF_NOPLANT ) {
return false;
}

collisionEnt = traceObject.[[ScriptEvent:getTraceEntity|getTraceEntity]]();

// don't let it stick to a player or a vehicle
[[ScriptClass:player|player]] collisionPlayer = collisionEnt;
if ( collisionPlayer != $null_entity ) {
return false;
}

if ( collisionEnt.vDisablePlantCharge() ) {
return false;
}

// push the view out of the surface a bit
vector normal = traceObject.[[ScriptEvent:getTraceNormal|getTraceNormal]]();

// align to the surface normal
[[ScriptEvent:alignToAxis|alignToAxis]]( normal, Z_AXIS );

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptEvent:freeze|freeze]]( 1.f );
[[ScriptEvent:clearContacts|clearContacts]]();
[[ScriptEvent:putToRest|putToRest]]();
if ( collisionEnt != $null_entity ) {
string joint = traceObject.[[ScriptEvent:getTraceJoint|getTraceJoint]]();
float jointHandle = collisionEnt.[[ScriptEvent:getJointHandle|getJointHandle]]( joint );
if ( jointHandle != INVALID_JOINT ) {
[[ScriptEvent:bindToJoint|bindToJoint]]( collisionEnt, joint, 1 );
} else {
[[ScriptEvent:bind|bind]]( collisionEnt );
}
}

// create the fancy shield
shieldProj = sys.[[ScriptEvent:spawn|spawn]]( [[ScriptEvent:getKey|getKey]]( "def_shield" ) );
shieldProj.[[ScriptEvent:setWorldOrigin|setWorldOrigin]]( [[ScriptEvent:getWorldOrigin|getWorldOrigin]]() );

launchAngles_x = 0;
launchAngles_z = 0;
vector forward = sys.[[ScriptEvent:angToForward|angToForward]]( launchAngles );
vector newAngles = launchAngles;

vector origin = [[ScriptEvent:getWorldOrigin|getWorldOrigin]]();

float dot = forward * normal;
if ( forward * normal < -0.707 ) {
// the forward that the player wanted is kind of embedded into the surface
// so align it with the normal of the surface
newAngles = sys.[[ScriptEvent:vecToAngles|vecToAngles]]( normal );
}

shieldProj.[[ScriptEvent:setAngles|setAngles]]( newAngles );
shieldProj.owner = owner;
shieldProj.[[ScriptEvent:setGameTeam|setGameTeam]]( owner.[[ScriptEvent:getGameTeam|getGameTeam]]() );
OnShieldProjSync();
}

return true;
}

void [[ScriptClass:projectile_forceshield|projectile_forceshield]]::OnPostThink() {
if ( [[ScriptEvent:isBound|isBound]]() ) {
[[ScriptEvent:forceRunPhysics|forceRunPhysics]]();
}
}

Script:Files:script/tools/force shield.script - Revision history

Wizz at 18:17, 2 November 2007