home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 March / Gamestar_82_2006-03_dvd.iso / DVDStar / Editace / quake4_sdkv10.exe / source / game / Player_States.cpp < prev    next >
C/C++ Source or Header  |  2005-11-14  |  27KB  |  920 lines
  1. #include "../idlib/precompiled.h"
  2. #pragma hdrstop
  3.  
  4. #include "Game_local.h"
  5.  
  6. CLASS_STATES_DECLARATION ( idPlayer )
  7.  
  8.     // Wait States
  9.     STATE ( "Wait_Alive",                    idPlayer::State_Wait_Alive )
  10.     STATE ( "Wait_ReloadAnim",                idPlayer::State_Wait_ReloadAnim )
  11.  
  12.     // Torso States
  13.     STATE ( "Torso_Idle",                    idPlayer::State_Torso_Idle )
  14.     STATE ( "Torso_IdleThink",                idPlayer::State_Torso_IdleThink )
  15.     STATE ( "Torso_Teleport",                idPlayer::State_Torso_Teleport )
  16.     STATE ( "Torso_RaiseWeapon",            idPlayer::State_Torso_RaiseWeapon )
  17.     STATE ( "Torso_LowerWeapon",            idPlayer::State_Torso_LowerWeapon )
  18.     STATE ( "Torso_Fire",                    idPlayer::State_Torso_Fire )
  19.     STATE ( "Torso_Fire_Windup",            idPlayer::State_Torso_Fire_Windup )
  20.     STATE ( "Torso_Reload",                    idPlayer::State_Torso_Reload )
  21.     STATE ( "Torso_Pain",                    idPlayer::State_Torso_Pain )
  22.     STATE ( "Torso_Dead",                    idPlayer::State_Torso_Dead )
  23.     STATE ( "Torso_Emote",                    idPlayer::State_Torso_Emote )
  24.  
  25.     // Leg States
  26.     STATE ( "Legs_Idle",                    idPlayer::State_Legs_Idle )
  27.     STATE ( "Legs_Crouch",                    idPlayer::State_Legs_Crouch )
  28.     STATE ( "Legs_Uncrouch",                idPlayer::State_Legs_Uncrouch )
  29.     STATE ( "Legs_Run_Forward",                idPlayer::State_Legs_Run_Forward )
  30.     STATE ( "Legs_Run_Backward",            idPlayer::State_Legs_Run_Backward )
  31.     STATE ( "Legs_Run_Left",                idPlayer::State_Legs_Run_Left )
  32.     STATE ( "Legs_Run_Right",                idPlayer::State_Legs_Run_Right )
  33.     STATE ( "Legs_Walk_Forward",            idPlayer::State_Legs_Walk_Forward )
  34.     STATE ( "Legs_Walk_Backward",            idPlayer::State_Legs_Walk_Backward )
  35.     STATE ( "Legs_Walk_Left",                idPlayer::State_Legs_Walk_Left )
  36.     STATE ( "Legs_Walk_Right",                idPlayer::State_Legs_Walk_Right )
  37.     STATE ( "Legs_Crouch_Idle",                idPlayer::State_Legs_Crouch_Idle )
  38.     STATE ( "Legs_Crouch_Forward",            idPlayer::State_Legs_Crouch_Forward )
  39.     STATE ( "Legs_Crouch_Backward",            idPlayer::State_Legs_Crouch_Backward )
  40.     STATE ( "Legs_Fall",                    idPlayer::State_Legs_Fall )
  41.     STATE ( "Legs_Jump",                    idPlayer::State_Legs_Jump )
  42.     STATE ( "Legs_Fall",                    idPlayer::State_Legs_Fall )
  43.     STATE ( "Legs_Land",                    idPlayer::State_Legs_Land )
  44.     STATE ( "Legs_Dead",                    idPlayer::State_Legs_Dead )
  45.  
  46. END_CLASS_STATES
  47.  
  48. /*
  49. ================
  50. idPlayer::State_Torso_Idle
  51. ================
  52. */
  53. stateResult_t idPlayer::State_Torso_Idle ( const stateParms_t& parms ) {
  54.     if ( SRESULT_WAIT == State_Torso_IdleThink ( parms ) ) {
  55.         PlayCycle ( ANIMCHANNEL_TORSO, "idle", parms.blendFrames  );
  56.         PostAnimState ( ANIMCHANNEL_TORSO, "Torso_IdleThink", parms.blendFrames );
  57.     }
  58.     return SRESULT_DONE;
  59. }
  60.  
  61. /*
  62. ================
  63. idPlayer::State_Torso_IdleThink
  64. ================
  65. */
  66. stateResult_t idPlayer::State_Torso_IdleThink ( const stateParms_t& parms ) {
  67.     if ( pfl.teleport ) {
  68.         PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Teleport", 0 );
  69.         return SRESULT_DONE;
  70.     }
  71.     if ( pfl.weaponFired ) {
  72.         PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Fire", 0 );
  73.         return SRESULT_DONE;
  74.     }
  75.     
  76.     if( pfl.attackHeld && weapon && weapon->wfl.hasWindupAnim)    {
  77.         PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Fire_Windup", 0 );
  78.         return SRESULT_DONE;
  79.     }
  80.     
  81.     if ( pfl.attackHeld && HasAnim ( ANIMCHANNEL_TORSO, "startfire" ) ) {
  82.            PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Fire_StartFire", 2 );
  83.            return SRESULT_DONE;
  84.        }
  85.        if ( pfl.pain ) {
  86.           PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Pain", 0 );
  87.           return SRESULT_DONE;
  88.        }
  89.     if ( emote != PE_NONE ) {
  90.         PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Emote", 5 );
  91.         return SRESULT_DONE;
  92.     }
  93.  
  94.        
  95.        return SRESULT_WAIT;
  96. }
  97.  
  98. /*
  99. ================
  100. idPlayer::State_Torso_Teleport
  101. ================
  102. */
  103. stateResult_t idPlayer::State_Torso_Teleport ( const stateParms_t& parms ) {
  104.     enum {
  105.         STAGE_INIT,
  106.         STAGE_WAIT
  107.     };
  108.     switch ( parms.stage ) {
  109.         case STAGE_INIT:        
  110.             pfl.teleport = false;
  111.             PlayAnim ( ANIMCHANNEL_TORSO, "teleport", parms.blendFrames );
  112.             return SRESULT_STAGE ( STAGE_WAIT );
  113.         
  114.         case STAGE_WAIT:
  115.             if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
  116.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
  117.                 return SRESULT_DONE;
  118.             }
  119.             return SRESULT_WAIT;
  120.     }
  121.     return SRESULT_ERROR;
  122. }
  123.  
  124. /*
  125. ================
  126. idPlayer::State_Torso_RaiseWeapon
  127. ================
  128. */
  129. stateResult_t idPlayer::State_Torso_RaiseWeapon ( const stateParms_t& parms ) {
  130.     PlayAnim( ANIMCHANNEL_TORSO, "raise", parms.blendFrames );
  131.     PostAnimState ( ANIMCHANNEL_TORSO, "Wait_TorsoAnim", 3 );
  132.     PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 3 );
  133.     return SRESULT_DONE;
  134. }
  135.  
  136. /*
  137. ================
  138. idPlayer::State_Torso_LowerWeapon
  139. ================
  140. */
  141. stateResult_t idPlayer::State_Torso_LowerWeapon ( const stateParms_t& parms ) {    
  142.     PlayAnim( ANIMCHANNEL_TORSO, "lower", parms.blendFrames );
  143.     PostAnimState ( ANIMCHANNEL_TORSO, "Wait_TorsoAnim", 3 );
  144.     return SRESULT_DONE;
  145. }
  146.  
  147. /*
  148. ================
  149. idPlayer::State_Torso_Fire
  150. ================
  151. */
  152. stateResult_t idPlayer::State_Torso_Fire ( const stateParms_t& parms ) {
  153.     enum {
  154.         TORSO_FIRE_INIT,
  155.         TORSO_FIRE_WAIT,
  156.         TORSO_FIRE_AIM,
  157.         TORSO_FIRE_AIMWAIT
  158.     };
  159.  
  160.     switch ( parms.stage ) {
  161.         // Start the firing sequence
  162.         case TORSO_FIRE_INIT:
  163.              PlayAnim ( ANIMCHANNEL_TORSO, "fire", parms.blendFrames );
  164.             pfl.weaponFired = false;
  165.             return SRESULT_STAGE(TORSO_FIRE_WAIT);
  166.         
  167.         // Wait for the firing animation to be finished
  168.         case TORSO_FIRE_WAIT:
  169.             if ( pfl.weaponFired ) {
  170.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Fire", parms.blendFrames );
  171.                 return SRESULT_DONE;
  172.             }
  173.             if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {    
  174.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", parms.blendFrames );
  175.                 return SRESULT_DONE;
  176.             }
  177.             return SRESULT_WAIT;
  178.             
  179.         // Keep the gun aimed but dont shoot
  180.         case TORSO_FIRE_AIM:
  181.             PlayAnim ( ANIMCHANNEL_TORSO, "aim", 3 );
  182.             return SRESULT_STAGE(TORSO_FIRE_AIMWAIT);
  183.             
  184.         // Keep the gun aimed as long as the attack button is held and nothing is firing
  185.         case TORSO_FIRE_AIMWAIT:
  186.             if ( pfl.weaponFired ) {
  187.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Fire", 3 );
  188.                 return SRESULT_DONE;
  189.             } else if ( !pfl.attackHeld ) {
  190.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", parms.blendFrames );
  191.                 return SRESULT_DONE;
  192.             }
  193.             return SRESULT_WAIT;
  194.     }
  195.     return SRESULT_DONE;
  196. }        
  197.  
  198. /*
  199. ================
  200. idPlayer::State_Torso_Fire_Windup
  201. ================
  202. */
  203. stateResult_t idPlayer::State_Torso_Fire_Windup ( const stateParms_t& parms ) {
  204.     enum {
  205.         TORSO_FIRE_INIT,
  206.         TORSO_WINDUP_WAIT,
  207.         TORSO_FIRE_LOOP,
  208.         TORSO_FIRE_WAIT,
  209.         TORSO_WINDDOWN_START,
  210.         TORSO_WINDDOWN_WAIT,
  211.         TORSO_FIRE_AIM,
  212.         TORSO_FIRE_AIMWAIT
  213.     };
  214.  
  215.     switch ( parms.stage ) {
  216.         // Start the firing sequence
  217.         case TORSO_FIRE_INIT:
  218.             //jshepard: HACK for now we're blending here, but we need to support charge up anims here
  219.              PlayAnim ( ANIMCHANNEL_TORSO, "fire", 4 );
  220.             pfl.weaponFired = false;
  221.             return SRESULT_STAGE(TORSO_WINDUP_WAIT);
  222.  
  223.         // wait for the windup anim to end, or the attackHeld to be false.
  224.         case TORSO_WINDUP_WAIT:
  225.             if( !pfl.attackHeld )    {
  226.                 return SRESULT_STAGE( TORSO_WINDDOWN_START );
  227.             }
  228.             if( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames )) {
  229.                 return SRESULT_STAGE( TORSO_FIRE_LOOP );                                
  230.             }
  231.             return SRESULT_WAIT;
  232.         
  233.         // play the firing loop
  234.         case TORSO_FIRE_LOOP:
  235.             if( !pfl.attackHeld )    {
  236.                 return SRESULT_STAGE( TORSO_WINDDOWN_START );
  237.             }
  238.             PlayAnim ( ANIMCHANNEL_TORSO, "fire", parms.blendFrames );
  239.             return SRESULT_STAGE( TORSO_FIRE_WAIT );
  240.             
  241.         // loop the fire anim
  242.         case TORSO_FIRE_WAIT:
  243.             if( !pfl.attackHeld )    {
  244.                 return SRESULT_STAGE( TORSO_WINDDOWN_START );
  245.             }
  246.             //loop the attack anim
  247.             if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {    
  248.                 PlayAnim ( ANIMCHANNEL_TORSO, "fire", parms.blendFrames );
  249.                 return SRESULT_STAGE( TORSO_FIRE_WAIT );
  250.             }
  251.             return SRESULT_WAIT;
  252.  
  253.         //wind down
  254.         case TORSO_WINDDOWN_START:
  255.             //jshepard: HACK just blend back into idle for now, we could support winddown anims here.
  256.             PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
  257.             pfl.weaponFired = false;
  258.             return SRESULT_DONE;
  259.         
  260.     }
  261.     return SRESULT_DONE;
  262. }        
  263. /*
  264. ================
  265. idPlayer::State_Torso_Reload
  266. ================
  267. */
  268. stateResult_t idPlayer::State_Torso_Reload ( const stateParms_t& parms ) {
  269.     enum {
  270.         TORSO_RELOAD_START,
  271.         TORSO_RELOAD_STARTWAIT,
  272.         TORSO_RELOAD_LOOP,
  273.         TORSO_RELOAD_LOOPWAIT,
  274.         TORSO_RELOAD_WAIT,
  275.         TORSO_RELOAD_END
  276.     };
  277.     switch ( parms.stage ) {
  278.         // Start the reload by either playing the reload animation or the reload_start animation
  279.         case TORSO_RELOAD_START:
  280.             if ( HasAnim ( ANIMCHANNEL_TORSO, "reload_start" ) ) {
  281.                 PlayAnim ( ANIMCHANNEL_TORSO, "reload_start", parms.blendFrames );
  282.                 return SRESULT_STAGE(TORSO_RELOAD_STARTWAIT);
  283.             }
  284.             
  285.             PlayAnim( ANIMCHANNEL_TORSO, "reload", parms.blendFrames );
  286.             return SRESULT_STAGE(TORSO_RELOAD_WAIT);
  287.             
  288.         // Wait for the reload_start animation to finish and transition to reload_loop
  289.         case TORSO_RELOAD_STARTWAIT:
  290.             if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
  291.                 return SRESULT_STAGE(TORSO_RELOAD_LOOP);
  292.             } else if ( pfl.weaponFired ) {
  293.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 3 );
  294.                 return SRESULT_DONE;
  295.             }
  296.             return SRESULT_WAIT;
  297.             
  298.         // Play a single reload from the reload loop
  299.         case TORSO_RELOAD_LOOP:
  300.             if ( !pfl.reload ) {
  301.                 return SRESULT_STAGE(TORSO_RELOAD_END);
  302.             }
  303.             PlayAnim ( ANIMCHANNEL_TORSO, "reload_loop", 0 );
  304.             return SRESULT_STAGE(TORSO_RELOAD_LOOPWAIT);
  305.  
  306.         // Wait for the looping reload to finish and either start a new one or end the reload
  307.         case TORSO_RELOAD_LOOPWAIT:
  308.             if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
  309.                 return SRESULT_STAGE(TORSO_RELOAD_LOOP);
  310.             } else if ( pfl.weaponFired ) {
  311.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 3 );
  312.                 return SRESULT_DONE;
  313.             }
  314.             return SRESULT_WAIT;
  315.  
  316.         // End the reload
  317.         case TORSO_RELOAD_END:
  318.             if ( pfl.weaponFired ) {
  319.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 3 );
  320.                 return SRESULT_DONE;
  321.             }
  322.  
  323.             PlayAnim( ANIMCHANNEL_TORSO, "reload_end", 3 );
  324.             return SRESULT_STAGE(TORSO_RELOAD_WAIT);
  325.         
  326.         // Wait for reload to finish (called by both reload_end and reload)
  327.         case TORSO_RELOAD_WAIT:
  328.             if ( pfl.weaponFired || AnimDone ( ANIMCHANNEL_TORSO, 3 ) ) {
  329.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 3 );
  330.                 return SRESULT_DONE;
  331.             }
  332.             return SRESULT_WAIT;
  333.     }
  334.     
  335.     return SRESULT_DONE;
  336. }
  337.  
  338. /*
  339. ================
  340. idPlayer::State_Torso_Pain
  341. ================
  342. */
  343. stateResult_t idPlayer::State_Torso_Pain ( const stateParms_t& parms ) {
  344.     PlayAnim ( ANIMCHANNEL_TORSO, painAnim.Length()?painAnim:"pain", parms.blendFrames );
  345.     PostAnimState ( ANIMCHANNEL_TORSO, "Wait_TorsoAnim", 4  );
  346.     PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 4 );
  347.     return SRESULT_DONE;
  348. }
  349.  
  350. /*
  351. ================
  352. idPlayer::State_Torso_Dead
  353. ================
  354. */
  355. stateResult_t idPlayer::State_Torso_Dead ( const stateParms_t& parms ) {
  356.     PostAnimState ( ANIMCHANNEL_TORSO, "Wait_Alive", 0 );
  357.     PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 0 );
  358.     return SRESULT_DONE;
  359. }
  360.  
  361. /*
  362. ================
  363. idPlayer::State_Torso_Emote
  364. ================
  365. */
  366. stateResult_t idPlayer::State_Torso_Emote ( const stateParms_t& parms ) {
  367.     enum {
  368.         STAGE_INIT,
  369.         STAGE_WAIT
  370.     };
  371.     switch ( parms.stage ) {
  372.         case STAGE_INIT:
  373.             if( emote == PE_GRAB_A ) {
  374.                 PlayAnim ( ANIMCHANNEL_TORSO, "grab_a", parms.blendFrames );
  375.             } else if( emote == PE_GRAB_B ) {
  376.                 PlayAnim ( ANIMCHANNEL_TORSO, "grab_b", parms.blendFrames );
  377.             } else if( emote == PE_SALUTE ) {
  378.                 PlayAnim ( ANIMCHANNEL_TORSO, "salute", parms.blendFrames );
  379.             } else if( emote == PE_CHEER ) {
  380.                 PlayAnim ( ANIMCHANNEL_TORSO, "cheer", parms.blendFrames );
  381.             } else if( emote == PE_TAUNT ) {
  382.                 PlayAnim ( ANIMCHANNEL_TORSO, "taunt", parms.blendFrames );
  383.             }
  384.  
  385.             emote = PE_NONE;
  386.             
  387.             return SRESULT_STAGE ( STAGE_WAIT );
  388.  
  389.         case STAGE_WAIT:
  390.             if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {
  391.                 PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", parms.blendFrames );
  392.                 return SRESULT_DONE;
  393.             }
  394.             return SRESULT_WAIT;
  395.     }
  396.     return SRESULT_ERROR;
  397. }
  398.  
  399. /*
  400. ===============================================================================
  401.  
  402.     AI Leg States
  403.  
  404. ===============================================================================
  405. */
  406.  
  407. /*
  408. ================
  409. idPlayer::IsLegsIdle
  410. ================
  411. */
  412. bool idPlayer::IsLegsIdle ( bool crouching ) const {
  413.     return ( (pfl.crouch == crouching) && pfl.onGround && (pfl.forward==pfl.backward) && (pfl.strafeLeft==pfl.strafeRight) );
  414. }
  415.  
  416. /*
  417. ================
  418. idPlayer::State_Legs_Idle
  419. ================
  420. */
  421. stateResult_t idPlayer::State_Legs_Idle ( const stateParms_t& parms ) {
  422.     enum {
  423.         STAGE_INIT,
  424.         STAGE_WAIT
  425.     };
  426.     switch ( parms.stage ) {
  427.         case STAGE_INIT:
  428.             if ( pfl.crouch ) {
  429.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch", parms.blendFrames );
  430.                 return SRESULT_DONE;
  431.             }
  432.             IdleAnim ( ANIMCHANNEL_LEGS, "idle", parms.blendFrames );
  433.             return SRESULT_STAGE ( STAGE_WAIT );
  434.         
  435.         case STAGE_WAIT:
  436.             // If now crouching go back to idle so we can transition to crouch 
  437.             if ( pfl.crouch ) {
  438.                  PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch", 4 );
  439.                 return SRESULT_DONE;
  440.             } else if ( pfl.jump ) {
  441.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Jump", 4 );
  442.                 return SRESULT_DONE;
  443.             } else if ( !pfl.onGround ) {
  444.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Fall", 4 );
  445.                 return SRESULT_DONE;
  446.             }else if ( pfl.forward && !pfl.backward ) {
  447.                 if( usercmd.buttons & BUTTON_RUN ) {
  448.                      PlayCycle( ANIMCHANNEL_LEGS, "run_forward", parms.blendFrames );
  449.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Forward", parms.blendFrames );
  450.                 } else {
  451.                     PlayCycle( ANIMCHANNEL_LEGS, "walk_forward", parms.blendFrames );
  452.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Forward", parms.blendFrames );
  453.                 }
  454.                 
  455.                 return SRESULT_DONE;
  456.             } else if ( pfl.backward && !pfl.forward ) {
  457.                 if( usercmd.buttons & BUTTON_RUN ) {
  458.                     PlayCycle( ANIMCHANNEL_LEGS, "run_backwards", parms.blendFrames );
  459.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Backward", parms.blendFrames );
  460.                 } else {
  461.                     PlayCycle( ANIMCHANNEL_LEGS, "walk_backwards", parms.blendFrames );
  462.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Backward", parms.blendFrames );
  463.                 }
  464.             
  465.                 return SRESULT_DONE;
  466.             } else if ( pfl.strafeLeft && !pfl.strafeRight ) {
  467.                 if( usercmd.buttons & BUTTON_RUN ) {
  468.                     PlayCycle( ANIMCHANNEL_LEGS, "run_strafe_left", parms.blendFrames );
  469.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Left", parms.blendFrames );
  470.                 } else {
  471.                     PlayCycle( ANIMCHANNEL_LEGS, "walk_left", parms.blendFrames );
  472.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Left", parms.blendFrames );
  473.                 }
  474.                 
  475.                 return SRESULT_DONE;
  476.             } else if ( pfl.strafeRight && !pfl.strafeLeft ) {
  477.                 if( usercmd.buttons & BUTTON_RUN ) {
  478.                     PlayCycle( ANIMCHANNEL_LEGS, "run_strafe_right", parms.blendFrames );
  479.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Right", parms.blendFrames );
  480.                 } else {
  481.                     PlayCycle( ANIMCHANNEL_LEGS, "walk_right", parms.blendFrames );
  482.                     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Right", parms.blendFrames );
  483.                 }
  484.  
  485.                 return SRESULT_DONE;
  486.             }
  487.             return SRESULT_WAIT;
  488.         
  489.     }
  490.     return SRESULT_ERROR;
  491. }
  492.  
  493. /*
  494. ================
  495. idPlayer::State_Legs_Crouch_Idle
  496. ================
  497. */
  498. stateResult_t idPlayer::State_Legs_Crouch_Idle ( const stateParms_t& parms ) {
  499.     enum {
  500.         STAGE_INIT,
  501.         STAGE_WAIT
  502.     };
  503.     switch ( parms.stage ) {
  504.         case STAGE_INIT:            
  505.             if ( !pfl.crouch ) {
  506.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Uncrouch", parms.blendFrames );
  507.                 return SRESULT_DONE;
  508.             }
  509.             PlayCycle ( ANIMCHANNEL_LEGS, "crouch", parms.blendFrames );
  510.             return SRESULT_STAGE ( STAGE_WAIT );
  511.         
  512.         case STAGE_WAIT:
  513.             if ( !pfl.crouch || pfl.jump ) {
  514.                  PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Uncrouch", 4 );
  515.                 return SRESULT_DONE;
  516.             } else if ( (pfl.forward && !pfl.backward) || (pfl.strafeLeft != pfl.strafeRight) ) {                
  517.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch_Forward", parms.blendFrames );
  518.                 return SRESULT_DONE;
  519.             } else if ( pfl.backward && !pfl.forward ) {
  520.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch_Backward", parms.blendFrames );
  521.                 return SRESULT_DONE;
  522.             }
  523.             return SRESULT_WAIT;
  524.     }
  525.     return SRESULT_ERROR;
  526. }
  527.  
  528. /*
  529. ================
  530. idPlayer::State_Legs_Crouch
  531. ================
  532. */
  533. stateResult_t idPlayer::State_Legs_Crouch ( const stateParms_t& parms ) {
  534.     enum {
  535.         STAGE_INIT,
  536.         STAGE_WAIT
  537.     };
  538.     switch ( parms.stage ) {
  539.         case STAGE_INIT:
  540.             PlayAnim ( ANIMCHANNEL_LEGS, "crouch_down", parms.blendFrames );
  541.             return SRESULT_STAGE ( STAGE_WAIT );
  542.         
  543.         case STAGE_WAIT:
  544.             if ( !IsLegsIdle ( true ) || AnimDone ( ANIMCHANNEL_LEGS, 4 ) ) {
  545.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch_Idle", parms.blendFrames );
  546.                 return SRESULT_DONE;
  547.             }
  548.             return SRESULT_WAIT;
  549.     }
  550.     return SRESULT_ERROR;
  551. }
  552.  
  553. /*
  554. ================
  555. idPlayer::State_Legs_Uncrouch
  556. ================
  557. */
  558. stateResult_t idPlayer::State_Legs_Uncrouch ( const stateParms_t& parms ) {
  559.     enum {
  560.         STAGE_INIT,
  561.         STAGE_WAIT
  562.     };
  563.     switch ( parms.stage ) {
  564.         case STAGE_INIT:
  565.             PlayAnim ( ANIMCHANNEL_LEGS, "crouch_up", parms.blendFrames );
  566.             return SRESULT_STAGE ( STAGE_WAIT );
  567.         
  568.         case STAGE_WAIT:
  569.             if ( !IsLegsIdle ( false ) || AnimDone ( ANIMCHANNEL_LEGS, 4 ) ) {
  570.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", 4 );
  571.                 return SRESULT_DONE;
  572.             }
  573.             return SRESULT_WAIT;
  574.     }
  575.     return SRESULT_ERROR;
  576. }
  577.  
  578. /*
  579. ================
  580. idPlayer::State_Legs_Run_Forward
  581. ================
  582. */
  583. stateResult_t idPlayer::State_Legs_Run_Forward ( const stateParms_t& parms ) {
  584.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && !pfl.backward && pfl.forward ) {
  585.         if( usercmd.buttons & BUTTON_RUN ) {
  586.             return SRESULT_WAIT;
  587.         } else {
  588.             PlayCycle( ANIMCHANNEL_LEGS, "walk_forward", parms.blendFrames );
  589.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Forward", parms.blendFrames );
  590.             return SRESULT_DONE;
  591.         }
  592.     }
  593.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  594.     return SRESULT_DONE;
  595. }
  596.  
  597. /*
  598. ================
  599. idPlayer::State_Legs_Run_Backward
  600. ================
  601. */
  602. stateResult_t idPlayer::State_Legs_Run_Backward ( const stateParms_t& parms ) {
  603.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && !pfl.forward && pfl.backward ) {
  604.         if( usercmd.buttons & BUTTON_RUN ) {
  605.             return SRESULT_WAIT;
  606.         } else {
  607.             PlayCycle( ANIMCHANNEL_LEGS, "walk_backwards", parms.blendFrames );
  608.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Backward", parms.blendFrames );
  609.             return SRESULT_DONE;
  610.         }
  611.     }
  612.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  613.     return SRESULT_DONE;
  614. }
  615.  
  616. /*
  617. ================
  618. idPlayer::State_Legs_Run_Left
  619. ================
  620. */
  621. stateResult_t idPlayer::State_Legs_Run_Left ( const stateParms_t& parms ) {
  622.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && (pfl.forward == pfl.backward) && pfl.strafeLeft && !pfl.strafeRight ) {
  623.         if( usercmd.buttons & BUTTON_RUN ) {
  624.             return SRESULT_WAIT;
  625.         } else {
  626.             PlayCycle( ANIMCHANNEL_LEGS, "walk_left", parms.blendFrames );
  627.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Left", parms.blendFrames );
  628.             return SRESULT_DONE;
  629.         }
  630.     }
  631.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  632.     return SRESULT_DONE;
  633. }
  634.  
  635. /*
  636. ================
  637. idPlayer::State_Legs_Run_Right
  638. ================
  639. */
  640. stateResult_t idPlayer::State_Legs_Run_Right ( const stateParms_t& parms ) {
  641.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && (pfl.forward == pfl.backward) && pfl.strafeRight && !pfl.strafeLeft ) {
  642.         if( usercmd.buttons & BUTTON_RUN ) {
  643.             return SRESULT_WAIT;
  644.         } else {
  645.             PlayCycle( ANIMCHANNEL_LEGS, "walk_right", parms.blendFrames );
  646.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Walk_Right", parms.blendFrames );
  647.             return SRESULT_DONE;
  648.         }
  649.     }
  650.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  651.     return SRESULT_DONE;
  652. }
  653.  
  654. /*
  655. ================
  656. idPlayer::State_Legs_Walk_Forward
  657. ================
  658. */
  659. stateResult_t idPlayer::State_Legs_Walk_Forward ( const stateParms_t& parms ) {
  660.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && !pfl.backward && pfl.forward ) {
  661.         if( !(usercmd.buttons & BUTTON_RUN) ) {
  662.             return SRESULT_WAIT;
  663.         } else {
  664.             PlayCycle( ANIMCHANNEL_LEGS, "run_forward", parms.blendFrames );
  665.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Forward", parms.blendFrames );
  666.             return SRESULT_DONE;
  667.         }
  668.     }
  669.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  670.     return SRESULT_DONE;
  671. }
  672.  
  673. /*
  674. ================
  675. idPlayer::State_Legs_Walk_Backward
  676. ================
  677. */
  678. stateResult_t idPlayer::State_Legs_Walk_Backward ( const stateParms_t& parms ) {
  679.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && !pfl.forward && pfl.backward ) {
  680.         if( !(usercmd.buttons & BUTTON_RUN) ) {
  681.             return SRESULT_WAIT;
  682.         } else {
  683.             PlayCycle( ANIMCHANNEL_LEGS, "run_backwards", parms.blendFrames );
  684.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Backward", parms.blendFrames );
  685.             return SRESULT_DONE;
  686.         }
  687.     }
  688.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  689.     return SRESULT_DONE;
  690. }
  691.  
  692. /*
  693. ================
  694. idPlayer::State_Legs_Walk_Left
  695. ================
  696. */
  697. stateResult_t idPlayer::State_Legs_Walk_Left ( const stateParms_t& parms ) {
  698.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && (pfl.forward == pfl.backward) && pfl.strafeLeft && !pfl.strafeRight ) {
  699.         if( !(usercmd.buttons & BUTTON_RUN) ) {
  700.             return SRESULT_WAIT;
  701.         } else {
  702.             PlayCycle( ANIMCHANNEL_LEGS, "run_strafe_left", parms.blendFrames );
  703.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Left", parms.blendFrames );
  704.             return SRESULT_DONE;
  705.         }
  706.     }
  707.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  708.     return SRESULT_DONE;
  709. }
  710.  
  711. /*
  712. ================
  713. idPlayer::State_Legs_Walk_Right
  714. ================
  715. */
  716. stateResult_t idPlayer::State_Legs_Walk_Right ( const stateParms_t& parms ) {
  717.     if ( !pfl.jump && pfl.onGround && !pfl.crouch && (pfl.forward == pfl.backward) && pfl.strafeRight && !pfl.strafeLeft ) {
  718.         if( !(usercmd.buttons & BUTTON_RUN) ) {
  719.             return SRESULT_WAIT;
  720.         } else {
  721.             PlayCycle( ANIMCHANNEL_LEGS, "run_strafe_right", parms.blendFrames );
  722.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Run_Right", parms.blendFrames );
  723.             return SRESULT_DONE;
  724.         }
  725.     }
  726.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  727.     return SRESULT_DONE;
  728. }
  729.  
  730. /*
  731. ================
  732. idPlayer::State_Legs_Crouch_Forward
  733. ================
  734. */
  735. stateResult_t idPlayer::State_Legs_Crouch_Forward ( const stateParms_t& parms ) {
  736.     enum {
  737.         STAGE_INIT,
  738.         STAGE_WAIT
  739.     };
  740.     switch ( parms.stage ) {
  741.         case STAGE_INIT:
  742.             PlayCycle( ANIMCHANNEL_LEGS, "crouch_walk", parms.blendFrames );
  743.             return SRESULT_STAGE ( STAGE_WAIT );
  744.         
  745.         case STAGE_WAIT:
  746.             if ( !pfl.jump && pfl.onGround && pfl.crouch && ((!pfl.backward && pfl.forward) || (pfl.strafeLeft != pfl.strafeRight)) ) {
  747.                 return SRESULT_WAIT;
  748.             }
  749.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch_Idle", 2 );
  750.             return SRESULT_DONE;
  751.     }
  752.     return SRESULT_DONE;
  753. }
  754.  
  755. /*
  756. ================
  757. idPlayer::State_Legs_Crouch_Backward
  758. ================
  759. */
  760. stateResult_t idPlayer::State_Legs_Crouch_Backward ( const stateParms_t& parms ) {
  761.     enum {
  762.         STAGE_INIT,
  763.         STAGE_WAIT
  764.     };
  765.     switch ( parms.stage ) {
  766.         case STAGE_INIT:
  767.             PlayCycle( ANIMCHANNEL_LEGS, "crouch_walk_backward", parms.blendFrames );
  768.             return SRESULT_STAGE ( STAGE_WAIT );
  769.         
  770.         case STAGE_WAIT:
  771.             if ( !pfl.jump && pfl.onGround && pfl.crouch && !pfl.forward && pfl.backward ) {
  772.                 return SRESULT_WAIT;
  773.             }
  774.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Crouch_Idle", parms.blendFrames );
  775.             return SRESULT_DONE;
  776.     }
  777.     return SRESULT_ERROR;
  778. }
  779.  
  780. /*
  781. ================
  782. idPlayer::State_Legs_Jump
  783. ================
  784. */
  785. stateResult_t idPlayer::State_Legs_Jump ( const stateParms_t& parms ) {
  786.     enum {
  787.         STAGE_INIT,
  788.         STAGE_WAIT
  789.     };
  790.     switch ( parms.stage ) {
  791.         case STAGE_INIT:
  792.             // prevent infinite recursion
  793.             pfl.jump = false;
  794.             if ( pfl.run ) {
  795.                 PlayAnim ( ANIMCHANNEL_LEGS, "run_jump", parms.blendFrames );
  796.             } else {
  797.                 PlayAnim ( ANIMCHANNEL_LEGS, "jump", parms.blendFrames );
  798.             }
  799.             return SRESULT_STAGE ( STAGE_WAIT );
  800.         
  801.         case STAGE_WAIT:
  802.             if ( pfl.onGround ) {
  803.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Land", 4 );
  804.                 return SRESULT_DONE;
  805.             }
  806.             if ( AnimDone ( ANIMCHANNEL_LEGS, 4 ) ) {
  807.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Fall", 4 );
  808.                 return SRESULT_DONE;
  809.             }            
  810.             return SRESULT_WAIT;
  811.     }
  812.      return SRESULT_ERROR;
  813. }
  814.  
  815. /*
  816. ================
  817. idPlayer::State_Legs_Fall
  818. ================
  819. */
  820. stateResult_t idPlayer::State_Legs_Fall ( const stateParms_t& parms ) {
  821.     enum {
  822.         STAGE_INIT,
  823.         STAGE_WAIT
  824.     };
  825.     switch ( parms.stage ) {
  826.         case STAGE_INIT:
  827.             if ( pfl.onGround ) {
  828.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Land", 2 );
  829.                 return SRESULT_DONE;
  830.             }
  831.             PlayCycle ( ANIMCHANNEL_LEGS, "fall", parms.blendFrames );
  832.             return SRESULT_STAGE ( STAGE_WAIT );            
  833.         case STAGE_WAIT:
  834.             if ( pfl.onGround ) {
  835.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Land", 2 );
  836.                 return SRESULT_DONE;
  837.             }
  838.             return SRESULT_WAIT;
  839.     }
  840.     return SRESULT_DONE;
  841. }
  842.  
  843. /*
  844. ================
  845. idPlayer::State_Legs_Land
  846. ================
  847. */
  848. stateResult_t idPlayer::State_Legs_Land ( const stateParms_t& parms ) {
  849.     enum {
  850.         STAGE_INIT,
  851.         STAGE_WAIT
  852.     };
  853.     switch ( parms.stage ) {
  854.         case STAGE_INIT:
  855.             if ( IsLegsIdle ( false ) && ( pfl.hardLanding || pfl.softLanding ) ) {                    
  856.                 if ( pfl.hardLanding ) {
  857.                     PlayAnim ( ANIMCHANNEL_LEGS, "hard_land", parms.blendFrames );
  858.                 } else {
  859.                     PlayAnim ( ANIMCHANNEL_LEGS, "soft_land", parms.blendFrames );
  860.                 }
  861.                 return SRESULT_STAGE ( STAGE_WAIT );
  862.             }
  863.             PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", 4 );
  864.             return SRESULT_DONE;
  865.             
  866.         case STAGE_WAIT:
  867.             if ( !IsLegsIdle ( false ) || AnimDone ( ANIMCHANNEL_LEGS, parms.blendFrames ) ) {
  868.                 PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", parms.blendFrames );
  869.                 return SRESULT_DONE;
  870.             }
  871.             return SRESULT_WAIT;
  872.     }
  873.     return SRESULT_ERROR;
  874. }
  875.  
  876. /*
  877. ================
  878. idPlayer::State_Legs_Dead
  879. ================
  880. */
  881. stateResult_t idPlayer::State_Legs_Dead ( const stateParms_t& parms ) {
  882.     PostAnimState ( ANIMCHANNEL_LEGS, "Wait_Alive", 0 );
  883.     PostAnimState ( ANIMCHANNEL_LEGS, "Legs_Idle", 0 );
  884.     return SRESULT_DONE;
  885. }
  886.  
  887. /*
  888. ================
  889. idPlayer::State_Wait_Alive
  890.  
  891. Waits until the player is alive again.
  892. ================
  893. */
  894. stateResult_t idPlayer::State_Wait_Alive ( const stateParms_t& parms ) {
  895.     if ( pfl.dead ) {
  896.         return SRESULT_WAIT;
  897.     }
  898.     return SRESULT_DONE;
  899. }
  900.  
  901. /*
  902. ================
  903. idPlayer::State_Wait_ReloadAnim
  904. ================
  905. */
  906. stateResult_t idPlayer::State_Wait_ReloadAnim ( const stateParms_t& parms ) {
  907.     // The gun firing can cancel any of the relod animations
  908.     if ( pfl.weaponFired ) {        
  909.         SetAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", parms.blendFrames );
  910.         return SRESULT_DONE;
  911.     }
  912.     
  913.     // wait for the animation to finish
  914.     if ( AnimDone ( ANIMCHANNEL_TORSO, parms.blendFrames ) ) {
  915.         return SRESULT_DONE;
  916.     }
  917.     
  918.     return SRESULT_WAIT;
  919. }
  920.