IW4-Dump-Files/animscripts/setposemovement.gsc

1112 lines
28 KiB
Plaintext
Raw Normal View History

2017-07-08 11:47:21 -07:00
//================================================================================
// SetPoseMovement - Sets the pose (stand, crouch, prone) and movement (run, walk,
// crawl, stop) to the specified values. Accounts for all possible starting poses
// and movements.
//================================================================================
#include animscripts\Utility;
#include maps\_Utility;
#include common_scripts\utility;
#using_animtree( "generic_human" );
SetPoseMovement( desiredPose, desiredMovement )
{
// Scripts can pass empty strings, meaning they don't want to change that aspect of the state.
if ( desiredPose == "" )
{
if ( ( self.a.pose == "prone" ) && ( ( desiredMovement == "walk" ) || ( desiredMovement == "run" ) ) )
desiredPose = "crouch";
else
desiredPose = self.a.pose;
}
if ( !IsDefined( desiredMovement ) || desiredMovement == "" )
{
desiredMovement = self.a.movement;
}
// Now call the function.
[[ anim.SetPoseMovementFnArray[ desiredPose ][ desiredMovement ] ]]();
}
// *****************************
// All of the following "Begin" functions ensure that the actor is in the given pose and movement type.
// They return false if nothing needs to be done, true otherwise.
// *****************************
InitPoseMovementFunctions()
{
// Make an array of movement and pose changing functions.
// Indices are: "desired movement", "desired pose"
anim.SetPoseMovementFnArray[ "stand" ][ "stop" ] = ::BeginStandStop;
anim.SetPoseMovementFnArray[ "stand" ][ "walk" ] = ::BeginStandWalk;
anim.SetPoseMovementFnArray[ "stand" ][ "run" ] = ::BeginStandRun;
anim.SetPoseMovementFnArray[ "crouch" ][ "stop" ] = ::BeginCrouchStop;
anim.SetPoseMovementFnArray[ "crouch" ][ "walk" ] = ::BeginCrouchWalk;
anim.SetPoseMovementFnArray[ "crouch" ][ "run" ] = ::BeginCrouchRun;
anim.SetPoseMovementFnArray[ "prone" ][ "stop" ] = ::BeginProneStop;
anim.SetPoseMovementFnArray[ "prone" ][ "walk" ] = ::BeginProneWalk;
anim.SetPoseMovementFnArray[ "prone" ][ "run" ] = ::BeginProneRun;
}
//--------------------------------------------------------------------------------
// Standing poses
//--------------------------------------------------------------------------------
BeginStandStop()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
return false;
case "walk":
StandWalkToStand();
break;
default:
assert( self.a.movement == "run" );
StandRunToStand();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToStand();
break;
case "walk":
CrouchWalkToStand();
break;
default:
assert( self.a.movement == "run" );
CrouchRunToStand();
break;
}
break;
default:
assert( self.a.pose == "prone" );
switch( self.a.movement )
{
case "stop":
ProneToStand();
break;
default:
assert( self.a.movement == "walk" || self.a.movement == "run" );
ProneToStand(); // Do I need to stop crawling first? Hope not.
break;
}
break;
}
return true;
}
BeginStandWalk()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
BlendIntoStandWalk();
break;
case "walk":
return false;
default:
assert( self.a.movement == "run" );
BlendIntoStandWalk();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToStandWalk();
break;
case "walk":
BlendIntoStandWalk();
break;
default:
assert( self.a.movement == "run" );
BlendIntoStandWalk();
break;
}
break;
default:
assert( self.a.pose == "prone" );
ProneToStandWalk();
break;
}
return true;
}
BeginStandRun()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
case "walk":
return BlendIntoStandRun();
default:
assert( self.a.movement == "run" );
return false;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
return CrouchToStandRun();
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
return BlendIntoStandRun();
}
break;
default:
assert( self.a.pose == "prone" );
ProneToStandRun();
break;
}
return true;
}
//--------------------------------------------------------------------------------
// Crouching functions
//--------------------------------------------------------------------------------
BeginCrouchStop()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
StandToCrouch();
break;
case "walk":
StandWalkToCrouch();
break;
case "run":
StandRunToCrouch();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchStop " + self.a.pose + " " + self.a.movement );
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
// Do nothing
break;
case "walk":
CrouchWalkToCrouch();
break;
case "run":
CrouchRunToCrouch();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchStop " + self.a.pose + " " + self.a.movement );
}
break;
case "prone":
ProneToCrouch();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchStop " + self.a.pose + " " + self.a.movement );
}
}
BeginCrouchWalk()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
BlendIntoCrouchWalk();
break;
case "walk":
BlendIntoCrouchWalk();
break;
default:
assert( self.a.movement == "run" );
BlendIntoCrouchWalk();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToCrouchWalk();
break;
case "walk":
return false;
default:
assert( self.a.movement == "run" );
BlendIntoCrouchWalk();
break;
}
break;
default:
assert( self.a.pose == "prone" );
// Let's try going straight to the run and then blending back to see what it looks like.
ProneToCrouchWalk();
break;
}
return true;
}
BeginCrouchRun()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
BlendIntoCrouchRun();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
BlendIntoCrouchRun();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToCrouchRun();
break;
case "walk":
BlendIntoCrouchRun();
break;
default:
assert( self.a.movement == "run" );
return false;
}
break;
default:
assert( self.a.pose == "prone" );
ProneToCrouchRun();
break;
}
return true;
}
//--------------------------------------------------------------------------------
// Prone Functions
//--------------------------------------------------------------------------------
BeginProneStop()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
StandToProne();
break;
case "walk":
StandToProne();
break;
case "run":
CrouchRunToProne();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchRun " + self.a.pose + " " + self.a.movement );
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToProne();
break;
case "walk":
CrouchToProne();
break;
case "run":
CrouchRunToProne();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchRun " + self.a.pose + " " + self.a.movement );
}
break;
case "prone":
switch( self.a.movement )
{
case "stop":
// Do nothing
break;
case "walk":
case "run":
ProneCrawlToProne();
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchRun " + self.a.pose + " " + self.a.movement );
}
break;
default:
assertEX( 0, "SetPoseMovement::BeginCrouchRun " + self.a.pose + " " + self.a.movement );
}
}
BeginProneWalk()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
StandToProneWalk();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
CrouchRunToProneWalk();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToProneWalk();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
CrouchRunToProneWalk();
break;
}
break;
default:
assert( self.a.pose == "prone" );
switch( self.a.movement )
{
case "stop":
ProneToProneRun();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
self.a.movement = "walk";
return false;
}
break;
}
return true;
}
BeginProneRun()
{
switch( self.a.pose )
{
case "stand":
switch( self.a.movement )
{
case "stop":
StandToProneRun();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
CrouchRunToProneRun();
break;
}
break;
case "crouch":
switch( self.a.movement )
{
case "stop":
CrouchToProneRun();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
CrouchRunToProneRun();
break;
}
break;
default:
assert( self.a.pose == "prone" );
switch( self.a.movement )
{
case "stop":
assert( self.a.movement == "stop" );
ProneToProneRun();
break;
default:
assert( self.a.movement == "run" || self.a.movement == "walk" );
self.a.movement = "run";
return false;
}
break;
}
return true;
}
//--------------------------------------------------------------------------------
// Standing support functions
//--------------------------------------------------------------------------------
PlayBlendTransition( transAnim, crossblendTime, endPose, endMovement )
{
endTime = gettime() + crossblendTime * 1000;
if( isarray( transAnim ) )
transAnim = transAnim[ randomint( transAnim.size ) ];
self setflaggedanimknoball( "blendTransition", transAnim, %body, 1, crossblendTime, 1 );
self animscripts\shared::DoNoteTracksForTime( crossblendTime / 2, "blendTransition" );
self.a.pose = endPose;
self.a.movement = endMovement;
waittime = ( endTime - gettime() ) / 1000;
if ( waittime < 0.05 )
waittime = 0.05;
self animscripts\shared::DoNoteTracksForTime( waittime, "blendTransition" );
}
PlayTransitionStandWalk( transAnim, finalAnim )
{
PlayTransitionAnimation( transAnim, "stand", "walk", finalAnim );
}
StandWalkToStand()
{
assertEX( self.a.pose == "stand", "SetPoseMovement::StandWalkToStand " + self.a.pose );
assertEX( self.a.movement == "walk", "SetPoseMovement::StandWalkToStand " + self.a.movement );
// no transition animations.
self.a.movement = "stop";
}
StandWalkToCrouch()
{
StandWalkToStand();
StandToCrouch();
}
StandRunToStand()
{
assertEX( self.a.pose == "stand", "SetPoseMovement::StandRunToStand " + self.a.pose );
assertEX( self.a.movement == "run", "SetPoseMovement::StandRunToStand " + self.a.movement );
// Do nothing, just blend straight in
self.a.movement = "stop";
}
StandRunToCrouch()
{
self.a.movement = "stop";
self.a.pose = "crouch";
}
PlayBlendTransitionStandRun( animname )
{
// if we're blending into stand run from stop,
// we probably just did utility::initialize's clearAnim(body, .3)
// so we don't have to spend more than .3 seconds here.
// (then we can do fun things like shooting or reloading.)
transtime = 0.3;
if ( self.a.movement != "stop" )
{
self endon( "movemode" );
transtime = 1.0;
}
PlayBlendTransition( animname, transtime, "stand", "run" );
}
BlendIntoStandRun()
{
if ( !self.faceMotion )
{
self.a.movement = "run";
self.a.pose = "stand";
return false;
}
if ( isDefined( self.run_overrideanim ) )
{
PlayBlendTransitionStandRun( self.run_overrideanim );
return true;
}
// Set the specific forward animation we are using to weight 1 immediately
// we will make sure it is blended smoothly by blending in its parent, combatrun_forward
runAnimTransTime = 0.1;
if ( self.a.movement != "stop" && self.stairsState == "none" )
runAnimTransTime = 0.5;
if ( isdefined( self.sprint ) )
self setAnimKnobLimited( moveAnim( "sprint" ), 1, runAnimTransTime, 1 );
else
self setAnimKnobLimited( animscripts\run::GetRunAnim(), 1, runAnimTransTime, 1 );
self animscripts\run::SetMoveNonForwardAnims( moveAnim( "move_b" ), moveAnim( "move_l" ), moveAnim( "move_r" ), self.sideStepRate );
self thread animscripts\run::SetCombatStandMoveAnimWeights( "run" );
wait 0.05;
PlayBlendTransitionStandRun( %combatrun );
return true;
}
BlendIntoStandWalk()
{
if ( self.a.movement != "stop" )
self endon( "movemode" );
if ( !isdefined( self.alwaysRunForward ) && self.a.pose != "prone" )
self animscripts\run::SetMoveNonForwardAnims( moveAnim( "move_b" ), moveAnim( "move_l" ), moveAnim( "move_r" ) );
self.a.pose = "stand";
self.a.movement = "walk";
}
CrouchToStand()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchToStand " + self.a.pose );
assertEX( self.a.movement == "stop", "SetPoseMovement::CrouchToStand " + self.a.movement );
standSpeed = 1;
if ( isdefined( self.fastStand ) )
{
standSpeed = 1.8;
self.fastStand = undefined;
}
if ( self usingSidearm() )
{
PlayTransitionAnimation( %pistol_crouchaimstraight2stand, "stand", "stop", undefined, standSpeed );
}
else
{
// Decide which idle animation to do
self randomizeIdleSet();
PlayTransitionAnimation( %crouch2stand, "stand", "stop", undefined, standSpeed );
}
}
//--------------------------------------------------------------------------------
// Crouched Support Functions
//--------------------------------------------------------------------------------
CrouchToCrouchWalk()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchToCrouchWalk " + self.a.pose );
assertEX( self.a.movement == "stop", "SetPoseMovement::CrouchToCrouchWalk " + self.a.movement );
BlendIntoCrouchWalk();
}
CrouchToStandWalk()
{
CrouchToCrouchWalk();
BlendIntoStandWalk();
}
CrouchWalkToCrouch()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchWalkToCrouch " + self.a.pose );
assertEX( self.a.movement == "walk", "SetPoseMovement::CrouchWalkToCrouch " + self.a.movement );
// Do nothing, just blend straight in
self.a.movement = "stop";
}
CrouchWalkToStand()
{
CrouchWalkToCrouch();
CrouchToStand();
}
CrouchRunToCrouch()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchRunToCrouch " + self.a.pose );
assertEX( self.a.movement == "run", "SetPoseMovement::CrouchRunToCrouch " + self.a.movement );
// Do nothing, just blend straight in
self.a.movement = "stop";
}
CrouchRunToStand()
{
CrouchRunToCrouch();
CrouchToStand();
}
CrouchToCrouchRun()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchToCrouchRun " + self.a.pose );
assertEX( self.a.movement == "stop", "SetPoseMovement::CrouchToCrouchRun " + self.a.movement );
BlendIntoCrouchRun();
}
CrouchToStandRun()
{
return BlendIntoStandRun();
}
BlendIntoCrouchRun()
{
if ( isDefined( self.crouchrun_combatanim ) )
{
PlayBlendTransition( self.crouchrun_combatanim, 0.6, "crouch", "run" );
}
else
{
self setanimknob( %crouchrun, 1, 0.4, self.moveplaybackrate );
self thread animscripts\run::UpdateMoveAnimWeights( "crouchrun", moveAnim( "crouch" ), moveAnim( "crouch_b" ), moveAnim( "crouch_l" ), moveAnim( "crouch_r" ) );
wait 0.05;
PlayBlendTransition( %crouchrun, 0.4, "crouch", "run" );
}
}
ProneToCrouchRun()
{
assertEX( self.a.pose == "prone", "SetPoseMovement::ProneToCrouchRun " + self.a.pose );
self OrientMode( "face current" ); // We don't want to rotate arbitrarily until we've actually stood up.
self ExitProneWrapper( 1.0 );// make code stop lerping in the prone orientation to ground
ProneLegsStraightTree( 0.2 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
PlayTransitionAnimation( %prone_2_crouch, "crouch", "run", animscripts\run::GetCrouchRunAnim() );
}
ProneToStandRun()
{
ProneToCrouchRun();
BlendIntoStandRun();
}
ProneToCrouchWalk()
{
ProneToCrouchRun();
BlendIntoCrouchWalk();
}
BlendIntoCrouchWalk()
{
if ( isDefined( self.crouchrun_combatanim ) )
{
self setanimknoball( self.crouchrun_combatanim, %body, 1, 0.4 );
PlayBlendTransition( self.crouchrun_combatanim, 0.6, "crouch", "walk" );
self notify( "BlendIntoCrouchWalk" );
}
else
{
self setanimknob( %crouchrun, 1, 0.4, self.moveplaybackrate );
self thread animscripts\run::UpdateMoveAnimWeights( "crouchrun", moveAnim( "crouch" ), moveAnim( "crouch_b" ), moveAnim( "crouch_l" ), moveAnim( "crouch_r" ) );
wait 0.05;
PlayBlendTransition( %crouchrun, 0.4, "crouch", "run" );
}
}
StandToCrouch()
{
assertEX( self.a.pose == "stand", "SetPoseMovement::StandToCrouch " + self.a.pose );
assertEX( self.a.movement == "stop", "SetPoseMovement::StandToCrouch " + self.a.movement );
// Decide which idle animation to do
self randomizeIdleSet();
crouchSpeed = 1;
if ( isdefined( self.fastCrouch ) )
{
crouchSpeed = 1.8;
self.fastCrouch = undefined;
}
PlayTransitionAnimation( %exposed_stand_2_crouch, "crouch", "stop", undefined, crouchspeed );
}
ProneToCrouch()
{
assertEX( self.a.pose == "prone", "SetPoseMovement::StandToCrouch " + self.a.pose );
// Decide which idle animation to do
self randomizeIdleSet();
self OrientMode( "face current" ); // We don't want to rotate arbitrarily until we've actually stood up.
self ExitProneWrapper( 1.0 );// make code stop lerping in the prone orientation to ground
ProneLegsStraightTree( 0.1 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
PlayTransitionAnimation( %prone_2_crouch, "crouch", "stop" );
// TODO: Find out if the above lines give the same functionality as below (notably the UpdateProne bit)
// self exitprone(1.0); // make code stop lerping in the prone orientation to ground
//
// ProneLegsStraightTree(0.1);
// self setflaggedanimknob("animdone", %prone2crouch_straight, 1, .1, 1);
// self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
// self waittill ("animdone");
// self.a.pose = "crouch";
}
ProneToStand()
{
assertEx( self.a.pose == "prone", self.a.pose );
self OrientMode( "face current" ); // We don't want to rotate arbitrarily until we've actually stood up.
self ExitProneWrapper( 1.0 );// make code stop lerping in the prone orientation to ground
ProneLegsStraightTree( 0.1 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
PlayTransitionAnimation( %prone_2_stand, "stand", "stop" );
}
ProneToStandWalk()
{
ProneToCrouch();
CrouchToCrouchWalk();
BlendIntoStandWalk();
}
//--------------------------------------------------------------------------------
// Prone Support Functions
//--------------------------------------------------------------------------------
ProneToProneMove( movement )
{
// (The parameter "movement" is just used for setting the state variable, since prone guys move the same whether
// "walking" or "running".
assertEX( self.a.pose == "prone", "SetPoseMovement::ProneToProneMove " + self.a.pose );
assertEX( self.a.movement == "stop", "SetPoseMovement::ProneToProneMove " + self.a.movement );
assertEX( ( movement == "walk" || movement == "run" ), "SetPoseMovement::ProneToProneMove got bad parameter " + movement );
ProneLegsStraightTree( 0.1 );
PlayTransitionAnimation( %prone_2_prone_crawl, "prone", movement, %prone_crawl );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
}
ProneToProneRun()
{
ProneToProneMove( "run" );
}
ProneCrawlToProne()
{
assertEX( self.a.pose == "prone", "SetPoseMovement::ProneCrawlToProne " + self.a.pose );
assertEX( ( self.a.movement == "walk" || self.a.movement == "run" ), "SetPoseMovement::ProneCrawlToProne " + self.a.movement );
ProneLegsStraightTree( 0.1 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
PlayTransitionAnimation( %prone_crawl_2_prone, "prone", "stop" );
// TODO: Find out if the above lines give the same functionality as below (notably the UpdateProne bit)
// ProneLegsStraightTree(0.1);
// self setflaggedanimknob("animdone", %prone_crawl2aim, 1, 0.1, 1);
// self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
// self waittill("animdone");
// self.a.movement = "stop";
}
CrouchToProne()
{
assertEX( self.a.pose == "crouch", "SetPoseMovement::CrouchToProne " + self.a.pose );
// I'd like to be able to assert that I'm stopped at this point, but until I get a better solution for
// guys who are walking and running, this is used for them too.
// assertEX(self.a.movement == "stop", "SetPoseMovement::CrouchToProne "+self.a.movement);
self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
self EnterProneWrapper( 1.0 );// make code start lerping in the prone orientation to ground
ProneLegsStraightTree( 0.3 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
PlayTransitionAnimation( %crouch_2_prone, "prone", "stop" );
// TODO: Find out if the above lines give the same functionality as below (notably the UpdateProne bit)
// self SetProneAnimNodes(-45, 45, %prone_legsdown, %prone_legsstraight, %prone_legsup);
// self EnterProne(1.0); // make code start lerping in the prone orientation to ground
//
// ProneLegsStraightTree(0.3);
// self setflaggedanimknob("animdone", %crouch_2_prone, 1, .3, 1);
// self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
// self waittill ("animdone");
// self.a.pose = "prone";
}
CrouchToProneWalk()
{
CrouchToProne();
ProneToProneRun();
}
CrouchToProneRun()
{
CrouchToProne();
ProneToProneRun();
}
StandToProne()
{
assertEX( self.a.pose == "stand", "SetPoseMovement::StandToProne " + self.a.pose );
// I'd like to be able to assert that I'm stopped at this point, but until I get a better solution for
// guys who are walking and running, this is used for them too.
// assertEX(self.a.movement == "stop", "SetPoseMovement::StandToProne "+self.a.movement);
self endon( "entered_pose" + "prone" );
proneTime = 0.5;// was 1
thread PlayTransitionAnimationThread_WithoutWaitSetStates( %stand_2_prone, "prone", "stop", undefined, proneTime );
self waittillmatch( "transAnimDone2", "anim_pose = \"crouch\"" );
waittillframeend;// so that the one in donotetracks gets hit first
// cause the next pose is prone
self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
self EnterProneWrapper( proneTime );// make code start lerping in the prone orientation to ground
self.a.movement = "stop";
ProneLegsStraightTree( 0.2 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
self waittillmatch( "transAnimDone2", "end" );
// TODO: Find out if the above lines give the same functionality as below (notably the UpdateProne bit)
// self SetProneAnimNodes(-45, 45, %prone_legsdown, %prone_legsstraight, %prone_legsup);
// self EnterProne(1.0); // make code start lerping in the prone orientation to ground
//
// ProneLegsStraightTree(0.2);
// self setflaggedanimknob("animdone", %stand2prone_onehand, 1, .2, 1);
// self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
// self waittill ("animdone");
// self.a.pose = "prone";
}
StandToProneWalk()
{
StandToProne();
ProneToProneRun();
}
StandToProneRun()
{
StandToProne();
ProneToProneRun();
}
CrouchRunToProne()
{
assertEX( ( self.a.pose == "crouch" ) || ( self.a.pose == "stand" ), "SetPoseMovement::CrouchRunToProne " + self.a.pose );
assertEX( ( self.a.movement == "run" || self.a.movement == "walk" ), "SetPoseMovement::CrouchRunToProne " + self.a.movement );
pronetime = 0.5;// was 1
self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
self EnterProneWrapper( proneTime );// make code start lerping in the prone orientation to ground
ProneLegsStraightTree( 0.2 );
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
runDirection = animscripts\utility::getQuadrant( self getMotionAngle() );
diveanim = %crouch_2_prone;
localDeltaVector = GetMoveDelta( diveanim, 0, 1 );
endPoint = self LocalToWorldCoords( localDeltaVector );
if ( self maymovetopoint( endPoint ) )
{
PlayTransitionAnimation( diveanim, "prone", "stop", undefined, pronetime );
}
else
{
//thread [[anim.println]]("Can't dive to prone.");#/
PlayTransitionAnimation( %crouch_2_prone_firing, "prone", "stop", undefined, pronetime );
}
}
CrouchRunToProneWalk()
{
CrouchRunToProne();
ProneToProneRun();
}
CrouchRunToProneRun()
{
CrouchRunToProne();
ProneToProneRun();
}
//--------------------------------------------------------------------------------
// General support functions
//--------------------------------------------------------------------------------
PlayTransitionAnimationThread_WithoutWaitSetStates( transAnim, endPose, endMovement, finalAnim, rate )
{
self endon( "killanimscript" );// the threaded one needs this or it wont die
self endon( "entered_pose" + endPose );
PlayTransitionAnimationFunc( transAnim, endPose, endMovement, finalAnim, rate, false );
}
PlayTransitionAnimation( transAnim, endPose, endMovement, finalAnim, rate )
{
PlayTransitionAnimationFunc( transAnim, endPose, endMovement, finalAnim, rate, true );
}
PlayTransitionAnimationFunc( transAnim, endPose, endMovement, finalAnim, rate, waitSetStatesEnabled )
{
if ( !isdefined( rate ) )
rate = 1;
/#
if ( getdebugdvar( "debug_grenadehand" ) == "on" )
{
if ( endPose != self.a.pose )
{
if ( !animhasnotetrack( transAnim, "anim_pose = \"" + endPose + "\"" ) )
{
println( "Animation ", transAnim, " lacks an endpose notetrack of ", endPose );
assertEx( 0, "A transition animation is missing a pose notetrack (see the line above)" );
}
}
if ( endMovement != self.a.movement )
{
if ( !animhasnotetrack( transAnim, "anim_movement = \"" + endMovement + "\"" ) )
{
println( "Animation ", transAnim, " lacks an endmovement notetrack of ", endMovement );
assertEx( 0, "A transition animation is missing a movement notetrack (see the line above)" );
}
}
}
#/
// Use a second thread to set the anim state halfway through the animation
if ( waitSetStatesEnabled )
self thread waitSetStates( getanimlength( transAnim ) / 2.0, "killtimerscript", endPose );
// Play the anim
// setflaggedanimknoball(notifyName, anim, rootAnim, goalWeight, goalTime, rate)
self setflaggedanimknoballrestart( "transAnimDone2", transAnim, %body, 1, .2, rate );
if ( !isDefined( self.a.pose ) )
self.pose = "undefined";
if ( !isDefined( self.a.movement ) )
self.movement = "undefined";
debugIdentifier = "";
/#debugIdentifier = self.script + ", " + self.a.pose + " to " + endPose + ", " + self.a.movement + " to " + endMovement;#/
self animscripts\shared::DoNoteTracks( "transAnimDone2", undefined, debugIdentifier );
// In case we finished earlier than we expected (eg the animation was already playing before we started),
// set the variables and kill the other thread.
self notify( "killtimerscript" );
self.a.pose = endPose;
self notify( "entered_pose" + endPose );
self.a.movement = endMovement;
if ( isDefined( finalAnim ) )
{
// setflaggedanimknoball(notifyName, anim, rootAnim, goalWeight, goalTime, rate)
self setanimknoball( finalAnim, %body, 1, 0.3, rate ); // Set the animation instantly
}
}
waitSetStates( timetowait, killmestring, endPose )
{
self endon( "killanimscript" );
self endon( "death" );
self endon( killmestring );
oldpose = self.a.pose;
wait timetowait;
// We called Enter/ExitProne before this function was called. These lines should not be necessary, but
// for some reason the code is picking up that I'm setting pose from prone to crouch without calling
// exitprone(). I just hope it's not a thread leak I've missed.
if ( oldpose!= "prone" && endPose == "prone" )
{
self animscripts\cover_prone::UpdateProneWrapper( 0.1 );
self EnterProneWrapper( 1.0 );// make code start lerping in the prone orientation to ground
}
else
if ( oldpose == "prone" && endPose != "prone" )
{
self ExitProneWrapper( 1.0 );// make code stop lerping in the prone orientation to ground
self OrientMode( "face default" ); // We were most likely in "face current" while we were prone.
}
}
ProneLegsStraightTree( blendtime )
{
self setanimknoball( %prone_legsstraight, %body, 1, blendtime, 1 );
}