Wizz at 10:09, 5 November 2007

2007-11-05T10:09:53Z

New page

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

void Idle();
void FindWeapon();
void RestoreWeapon();

void SetDeployStart( float t );

void OnOwnerChanged();
void OnDeployStartChanged();

entity owner;
void vSetOwner( entity o ) { owner = o; OnOwnerChanged(); }
entity vGetOwner() { return owner; }

void vCancel();
void Cancel();

float openDelay;
void vSetDelay( float time ) { openDelay = time; }

boolean forceStayOpen;
void vForceStayOpen( boolean force ) { forceStayOpen = force; }

float deployStart;
boolean collapsing;
string previousWeapon;

boolean weaponRestored;
}

void [[ScriptClass:parachute|parachute]]::preinit() {
deployStart = -1;
[[ScriptEvent:hide|hide]]();
}

void [[ScriptClass:parachute|parachute]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "owner" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "collapsing" );
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "deployStart" );

[[ScriptEvent:syncCallback|syncCallback]]( "owner", "OnOwnerChanged" );
[[ScriptEvent:syncCallback|syncCallback]]( "deployStart", "OnDeployStartChanged" );
}

void [[ScriptClass:parachute|parachute]]::OnOwnerChanged() {
[[ScriptEvent:setOwner|setOwner]]( owner );
[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:binAdd|binAdd]]( self );
}
}

void [[ScriptClass:parachute|parachute]]::OnDeployStartChanged() {
[[ScriptEvent:setDeployStart|setDeployStart]]( deployStart );
}

void [[ScriptClass:parachute|parachute]]::init() {
[[ScriptEvent:setContents|setContents]]( 0 );
[[ScriptEvent:setClipmask|setClipmask]]( 0 );

while( owner == $null_entity ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}

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

void [[ScriptClass:parachute|parachute]]::destroy() {
[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:binRemove|binRemove]]( self );
}

RestoreWeapon();
}

void [[ScriptClass:parachute|parachute]]::SetDeployStart( float t ) {
deployStart = t;
[[ScriptEvent:setDeployStart|setDeployStart]]( t );
}

void [[ScriptClass:parachute|parachute]]::FindWeapon() {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
previousWeapon = owner.[[ScriptEvent:getCurrentWeapon|getCurrentWeapon]]();
}
}

void [[ScriptClass:parachute|parachute]]::RestoreWeapon() {
if ( weaponRestored ) {
return;
}
weaponRestored = true;

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
if ( previousWeapon != "" && previousWeapon != "inventory/tools/gdf_parachute" ) {
playerOwner.[[ScriptEvent:setWeapon|setWeapon]]( previousWeapon, 0 );
} else {
playerOwner.[[ScriptEvent:selectBestWeapon|selectBestWeapon]]( false );
}
}
}
}

void [[ScriptClass:parachute|parachute]]::Idle() {
[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
// change the owner's weapon
if ( openDelay > 0.0f ) {
playerOwner.[[ScriptEvent:setWeapon|setWeapon]]( "inventory/tools/gdf_parachute", 1 );
} else {
// find out what weapon the player has
FindWeapon();

playerOwner.[[ScriptEvent:setWeapon|setWeapon]]( "inventory/tools/gdf_parachute", 0 );
}
}

sys.[[ScriptEvent:wait|wait]]( openDelay );

[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "deploy" );

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

entity p = owner;
vector origin;
vector angles = g_vectorZero;
if ( playerOwner != $null_entity ) {
origin = playerOwner.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + '0 0 80';
angles = owner.[[ScriptEvent:getViewAngles|getViewAngles]]();
angles_x = 0;
angles_z = 0;
} else {
origin = sys.[[ScriptEvent:toWorldSpace|toWorldSpace]]( p.[[ScriptEvent:getCenterOfMass|getCenterOfMass]](), p );
angles = owner.[[ScriptEvent:getAngles|getAngles]]();
}
[[ScriptEvent:setAngles|setAngles]]( angles );

vector offset = owner.[[ScriptEvent:getVectorKey|getVectorKey]]( "parachute_offset" );
offset = sys.[[ScriptEvent:rotateVecByAngles|rotateVecByAngles]]( offset, angles );
origin += offset;

[[ScriptEvent:setOrigin|setOrigin]]( origin );
[[ScriptEvent:bind|bind]]( p );
[[ScriptEvent:show|show]]();

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
SetDeployStart( sys.[[ScriptEvent:getTime|getTime]]() );
}

while ( 1 ) {
// HACK - force change to parachute
if ( playerOwner != $null_entity ) {
string weapon = playerOwner.[[ScriptEvent:getCurrentWeapon|getCurrentWeapon]]();
if ( weapon != "inventory/tools/gdf_parachute" ) {
// change the owner's weapon
if ( openDelay > 0.0f ) {
playerOwner.[[ScriptEvent:setWeapon|setWeapon]]( "inventory/tools/gdf_parachute", 1 );
} else {
playerOwner.[[ScriptEvent:setWeapon|setWeapon]]( "inventory/tools/gdf_parachute", 0 );
}
}
}

if ( ![[ScriptEvent:isAnimating|isAnimating]]() ) {
[[ScriptEvent:playCycle|playCycle]]( ANIMCHANNEL_ALL, "idle_open" );
}

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

if ( playerOwner != $null_entity ) {
if ( playerOwner.[[ScriptEvent:getProxyEntity|getProxyEntity]]() != $null_entity ) {
break;
}
}

if ( owner.[[ScriptEvent:getHealth|getHealth]]() <= 0 ) {
break;
}

if ( !forceStayOpen ) {
if ( playerOwner == $null_entity ) {
if ( [[ScriptEvent:isMovingTooSlow|isMovingTooSlow]]() ) {
break;
}
} else {
if ( playerOwner.AI_ONLADDER || playerOwner.AI_INWATER || playerOwner.AI_ONGROUND ) {
break;
}
}
}
}

if ( collapsing ) {
break;
}

if ( playerOwner == sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]() && !pm_thirdperson.[[ScriptEvent:getBoolValue|getBoolValue]]() ) {
[[ScriptEvent:hide|hide]]();
} else {
[[ScriptEvent:show|show]]();
}

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

vCancel();
}

void [[ScriptClass:parachute|parachute]]::vCancel() {

[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:binRemove|binRemove]]( self );
}

if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
SetDeployStart( -1 );
}

// collapse into a crumpled heap
collapsing = true;

[[ScriptEvent:startSound|startSound]]( "snd_stop", SND_VEHICLE_IDLE );

[[ScriptEvent:playAnim|playAnim]]( ANIMCHANNEL_ALL, "compact" );
RestoreWeapon();

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

void [[ScriptClass:parachute|parachute]]::Cancel() {
waitUntil( ![[ScriptEvent:isAnimating|isAnimating]]() );

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

/*
===============================================================================

Parachute cockpit

===============================================================================
*/

object [[ScriptClass:tool_parachute|tool_parachute]] : [[ScriptClass:weapon_base|weapon_base]] {
void init();
void Idle();
};

void [[ScriptClass:tool_parachute|tool_parachute]]::init() {
[[ScriptEvent:weaponState|weaponState]]( "Raise", 0 );
}

void [[ScriptClass:tool_parachute|tool_parachute]]::Idle() {
[[ScriptEvent:weaponReady|weaponReady]]();
[[ScriptEvent:enableClamp|enableClamp]]( '0 0 0' );

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

sys.[[ScriptEvent:wait|wait]]( 0.2f );
while ( true ) {
if ( WEAPON_LOWERWEAPON ) {
[[ScriptEvent:weaponState|weaponState]]( "Lower", 4 );
}

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

/*
===============================================================================

Strogg "Parachute"

===============================================================================
*/
object [[ScriptClass:strogg_parachute|strogg_parachute]] : [[ScriptClass:parachute_base|parachute_base]] {
void preinit();
void init();
void destroy();
void syncFields();

void Idle();

void CleanUp();
void OnOwnerChanged();

entity owner;
void vSetOwner( entity o ) { owner = o; OnOwnerChanged(); }

void vCancel();
void Cancel();

float openDelay;
void vSetDelay( float time ) { openDelay = time; }

boolean collapsing;
boolean cleanupApplied;
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::preinit() {
collapsing = false;
openDelay = 0;
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::syncFields() {
[[ScriptEvent:syncBroadcast|syncBroadcast]]( "owner" );
[[ScriptEvent:syncCallback|syncCallback]]( "owner", "OnOwnerChanged" );

[[ScriptEvent:syncBroadcast|syncBroadcast]]( "collapsing" );
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::init() {
while( owner == $null_entity ) {
sys.[[ScriptEvent:waitFrame|waitFrame]]();
}

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

void [[ScriptClass:strogg_parachute|strogg_parachute]]::destroy() {
CleanUp();
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::CleanUp() {
if ( cleanupApplied ) {
return;
}

[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:binRemove|binRemove]]( self );
playerOwner.[[ScriptEvent:disableFallingDamage|disableFallingDamage]]( false );
}

cleanupApplied = true;
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::OnOwnerChanged() {
[[ScriptClass:player|player]] playerOwner = owner;
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:binAdd|binAdd]]( self );
playerOwner.[[ScriptEvent:disableFallingDamage|disableFallingDamage]]( true );
}
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::Idle() {
[[ScriptClass:player|player]] playerOwner = owner;

if ( openDelay > 0.f ) {
if ( playerOwner != $null_entity ) {
playerOwner.[[ScriptEvent:selectBestWeapon|selectBestWeapon]]( true );
}
sys.[[ScriptEvent:wait|wait]]( openDelay );
}

[[ScriptEvent:setContents|setContents]]( 0 );

if ( owner != sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]() || pm_thirdperson.[[ScriptEvent:getBoolValue|getBoolValue]]() ) {
[[ScriptEvent:playEffect|playEffect]]( "fx_fly", "", 1 );
}

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

float deployTime = 1.0f;

// Doesn't really need to do this I guess, but if they use a model it will work
entity p = owner;
vector origin;
vector angles = g_vectorZero;
if ( owner != $null_entity ) {
origin = playerOwner.[[ScriptEvent:getWorldOrigin|getWorldOrigin]]() + '0 0 80';
angles = owner.[[ScriptEvent:getViewAngles|getViewAngles]]();
angles_x = 0;
angles_z = 0;
} else {
origin = sys.[[ScriptEvent:toWorldSpace|toWorldSpace]]( p.[[ScriptEvent:getCenterOfMass|getCenterOfMass]](), p );
angles = owner.[[ScriptEvent:getAngles|getAngles]]();
}
[[ScriptEvent:setAngles|setAngles]]( angles );

vector offset = owner.[[ScriptEvent:getVectorKey|getVectorKey]]( "parachute_offset" );
offset = sys.[[ScriptEvent:rotateVecByAngles|rotateVecByAngles]]( offset, angles );
origin += offset;

[[ScriptEvent:setOrigin|setOrigin]]( origin );
[[ScriptEvent:bind|bind]]( p );

float maxSpeed = [[ScriptEvent:getFloatKey|getFloatKey]]( "min_speed" );

float tooSlowTime = 0;

float deployStart = sys.[[ScriptEvent:getTime|getTime]]();
while ( 1 ) {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( owner == $null_entity ) {
break;
}
if ( playerOwner != $null_entity ) {
if ( playerOwner.[[ScriptEvent:getProxyEntity|getProxyEntity]]() != $null_entity ) {
break;
}
}
if ( owner.[[ScriptEvent:getHealth|getHealth]]() <= 0 ) {
break;
}
}

if ( collapsing ) {
break;
}

if ( owner == sys.[[ScriptEvent:getLocalViewPlayer|getLocalViewPlayer]]() && !pm_thirdperson.[[ScriptEvent:getBoolValue|getBoolValue]]() ) {
[[ScriptEvent:hide|hide]]();
} else {
[[ScriptEvent:show|show]]();
}

// convert velocity to metric
vector velocity = InchesToMetres( p.[[ScriptEvent:getLinearVelocity|getLinearVelocity]]() );
float speedSquared = sys.[[ScriptEvent:vecLengthSquared|vecLengthSquared]]( velocity );

if ( velocity_z > -maxSpeed ) {
if ( !sys.[[ScriptEvent:isClient|isClient]]() ) {
if ( !tooSlowTime ) {
tooSlowTime = sys.[[ScriptEvent:getTime|getTime]]();
} else {
if ( sys.[[ScriptEvent:getTime|getTime]]() - tooSlowTime > 0.1f ) {
break;
}
}
}
}

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

vCancel();
}

void [[ScriptClass:strogg_parachute|strogg_parachute]]::vCancel() {
CleanUp();

// collapse into a crumpled heap
collapsing = true;

[[ScriptEvent:startSound|startSound]]( "snd_stop", SND_VEHICLE_IDLE );

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

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

void [[ScriptClass:strogg_parachute|strogg_parachute]]::Cancel() {
sys.[[ScriptEvent:wait|wait]]( 1.0f );

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

Script:Files:script/misc/parachute.script - Revision history

Wizz at 10:09, 5 November 2007