00001 // BG_PAnimate.c 00002 00003 #include "q_shared.h" 00004 #include "bg_public.h" 00005 #include "bg_strap.h" 00006 #include "bg_local.h" 00007 #include "anims.h" 00008 #include "../cgame/animtable.h" 00009 #ifdef QAGAME 00010 #include "g_local.h" 00011 #endif 00012 00013 #ifdef CGAME 00014 #include "../namespace_begin.h" 00015 extern sfxHandle_t trap_S_RegisterSound( const char *sample); 00016 extern int trap_FX_RegisterEffect( const char *file); 00017 #include "../namespace_end.h" 00018 #endif 00019 00020 extern saberInfo_t *BG_MySaber( int clientNum, int saberNum ); 00021 /* 00022 ============================================================================== 00023 BEGIN: Animation utility functions (sequence checking) 00024 ============================================================================== 00025 */ 00026 //Called regardless of pm validity: 00027 00028 // VVFIXME - Most of these functions are totally stateless and stupid. Don't 00029 // need multiple copies of this, but it's much easier (and less likely to 00030 // break in the future) if I keep separate namespace versions now. 00031 #include "../namespace_begin.h" 00032 00033 qboolean BG_SaberStanceAnim( int anim ) 00034 { 00035 switch ( anim ) 00036 { 00037 case BOTH_STAND1://not really a saberstance anim, actually... "saber off" stance 00038 case BOTH_STAND2://single-saber, medium style 00039 case BOTH_SABERFAST_STANCE://single-saber, fast style 00040 case BOTH_SABERSLOW_STANCE://single-saber, strong style 00041 case BOTH_SABERSTAFF_STANCE://saber staff style 00042 case BOTH_SABERDUAL_STANCE://dual saber style 00043 return qtrue; 00044 break; 00045 } 00046 return qfalse; 00047 } 00048 00049 qboolean BG_CrouchAnim( int anim ) 00050 { 00051 switch ( anim ) 00052 { 00053 case BOTH_SIT1: //# Normal chair sit. 00054 case BOTH_SIT2: //# Lotus position. 00055 case BOTH_SIT3: //# Sitting in tired position: elbows on knees 00056 case BOTH_CROUCH1: //# Transition from standing to crouch 00057 case BOTH_CROUCH1IDLE: //# Crouching idle 00058 case BOTH_CROUCH1WALK: //# Walking while crouched 00059 case BOTH_CROUCH1WALKBACK: //# Walking while crouched 00060 case BOTH_CROUCH2TOSTAND1: //# going from crouch2 to stand1 00061 case BOTH_CROUCH3: //# Desann crouching down to Kyle (cin 9) 00062 case BOTH_KNEES1: //# Tavion on her knees 00063 case BOTH_CROUCHATTACKBACK1://FIXME: not if in middle of anim? 00064 case BOTH_ROLL_STAB: 00065 return qtrue; 00066 break; 00067 } 00068 return qfalse; 00069 } 00070 00071 qboolean BG_InSpecialJump( int anim ) 00072 { 00073 switch ( (anim) ) 00074 { 00075 case BOTH_WALL_RUN_RIGHT: 00076 case BOTH_WALL_RUN_RIGHT_STOP: 00077 case BOTH_WALL_RUN_RIGHT_FLIP: 00078 case BOTH_WALL_RUN_LEFT: 00079 case BOTH_WALL_RUN_LEFT_STOP: 00080 case BOTH_WALL_RUN_LEFT_FLIP: 00081 case BOTH_WALL_FLIP_RIGHT: 00082 case BOTH_WALL_FLIP_LEFT: 00083 case BOTH_FLIP_BACK1: 00084 case BOTH_FLIP_BACK2: 00085 case BOTH_FLIP_BACK3: 00086 case BOTH_WALL_FLIP_BACK1: 00087 case BOTH_BUTTERFLY_LEFT: 00088 case BOTH_BUTTERFLY_RIGHT: 00089 case BOTH_BUTTERFLY_FL1: 00090 case BOTH_BUTTERFLY_FR1: 00091 case BOTH_FJSS_TR_BL: 00092 case BOTH_FJSS_TL_BR: 00093 case BOTH_FORCELEAP2_T__B_: 00094 case BOTH_JUMPFLIPSLASHDOWN1://# 00095 case BOTH_JUMPFLIPSTABDOWN://# 00096 case BOTH_JUMPATTACK6: 00097 case BOTH_JUMPATTACK7: 00098 case BOTH_ARIAL_LEFT: 00099 case BOTH_ARIAL_RIGHT: 00100 case BOTH_ARIAL_F1: 00101 case BOTH_CARTWHEEL_LEFT: 00102 case BOTH_CARTWHEEL_RIGHT: 00103 00104 case BOTH_FORCELONGLEAP_START: 00105 case BOTH_FORCELONGLEAP_ATTACK: 00106 case BOTH_FORCEWALLRUNFLIP_START: 00107 case BOTH_FORCEWALLRUNFLIP_END: 00108 case BOTH_FORCEWALLRUNFLIP_ALT: 00109 case BOTH_FLIP_ATTACK7: 00110 case BOTH_FLIP_HOLD7: 00111 case BOTH_FLIP_LAND: 00112 case BOTH_A7_SOULCAL: 00113 return qtrue; 00114 } 00115 if ( BG_InReboundJump( anim ) ) 00116 { 00117 return qtrue; 00118 } 00119 if ( BG_InReboundHold( anim ) ) 00120 { 00121 return qtrue; 00122 } 00123 if ( BG_InReboundRelease( anim ) ) 00124 { 00125 return qtrue; 00126 } 00127 if ( BG_InBackFlip( anim ) ) 00128 { 00129 return qtrue; 00130 } 00131 return qfalse; 00132 } 00133 00134 qboolean BG_InSaberStandAnim( int anim ) 00135 { 00136 switch ( (anim) ) 00137 { 00138 case BOTH_SABERFAST_STANCE: 00139 case BOTH_STAND2: 00140 case BOTH_SABERSLOW_STANCE: 00141 case BOTH_SABERDUAL_STANCE: 00142 case BOTH_SABERSTAFF_STANCE: 00143 return qtrue; 00144 default: 00145 return qfalse; 00146 } 00147 } 00148 00149 qboolean BG_InReboundJump( int anim ) 00150 { 00151 switch ( anim ) 00152 { 00153 case BOTH_FORCEWALLREBOUND_FORWARD: 00154 case BOTH_FORCEWALLREBOUND_LEFT: 00155 case BOTH_FORCEWALLREBOUND_BACK: 00156 case BOTH_FORCEWALLREBOUND_RIGHT: 00157 return qtrue; 00158 break; 00159 } 00160 return qfalse; 00161 } 00162 00163 qboolean BG_InReboundHold( int anim ) 00164 { 00165 switch ( anim ) 00166 { 00167 case BOTH_FORCEWALLHOLD_FORWARD: 00168 case BOTH_FORCEWALLHOLD_LEFT: 00169 case BOTH_FORCEWALLHOLD_BACK: 00170 case BOTH_FORCEWALLHOLD_RIGHT: 00171 return qtrue; 00172 break; 00173 } 00174 return qfalse; 00175 } 00176 00177 qboolean BG_InReboundRelease( int anim ) 00178 { 00179 switch ( anim ) 00180 { 00181 case BOTH_FORCEWALLRELEASE_FORWARD: 00182 case BOTH_FORCEWALLRELEASE_LEFT: 00183 case BOTH_FORCEWALLRELEASE_BACK: 00184 case BOTH_FORCEWALLRELEASE_RIGHT: 00185 return qtrue; 00186 break; 00187 } 00188 return qfalse; 00189 } 00190 00191 qboolean BG_InBackFlip( int anim ) 00192 { 00193 switch ( anim ) 00194 { 00195 case BOTH_FLIP_BACK1: 00196 case BOTH_FLIP_BACK2: 00197 case BOTH_FLIP_BACK3: 00198 return qtrue; 00199 break; 00200 } 00201 return qfalse; 00202 } 00203 00204 qboolean BG_DirectFlippingAnim( int anim ) 00205 { 00206 switch ( (anim) ) 00207 { 00208 case BOTH_FLIP_F: //# Flip forward 00209 case BOTH_FLIP_B: //# Flip backwards 00210 case BOTH_FLIP_L: //# Flip left 00211 case BOTH_FLIP_R: //# Flip right 00212 return qtrue; 00213 break; 00214 } 00215 00216 return qfalse; 00217 } 00218 00219 qboolean BG_SaberInAttackPure( int move ) 00220 { 00221 if ( move >= LS_A_TL2BR && move <= LS_A_T2B ) 00222 { 00223 return qtrue; 00224 } 00225 return qfalse; 00226 } 00227 qboolean BG_SaberInAttack( int move ) 00228 { 00229 if ( move >= LS_A_TL2BR && move <= LS_A_T2B ) 00230 { 00231 return qtrue; 00232 } 00233 switch ( move ) 00234 { 00235 case LS_A_BACK: 00236 case LS_A_BACK_CR: 00237 case LS_A_BACKSTAB: 00238 case LS_ROLL_STAB: 00239 case LS_A_LUNGE: 00240 case LS_A_JUMP_T__B_: 00241 case LS_A_FLIP_STAB: 00242 case LS_A_FLIP_SLASH: 00243 case LS_JUMPATTACK_DUAL: 00244 case LS_JUMPATTACK_ARIAL_LEFT: 00245 case LS_JUMPATTACK_ARIAL_RIGHT: 00246 case LS_JUMPATTACK_CART_LEFT: 00247 case LS_JUMPATTACK_CART_RIGHT: 00248 case LS_JUMPATTACK_STAFF_LEFT: 00249 case LS_JUMPATTACK_STAFF_RIGHT: 00250 case LS_BUTTERFLY_LEFT: 00251 case LS_BUTTERFLY_RIGHT: 00252 case LS_A_BACKFLIP_ATK: 00253 case LS_SPINATTACK_DUAL: 00254 case LS_SPINATTACK: 00255 case LS_LEAP_ATTACK: 00256 case LS_SWOOP_ATTACK_RIGHT: 00257 case LS_SWOOP_ATTACK_LEFT: 00258 case LS_TAUNTAUN_ATTACK_RIGHT: 00259 case LS_TAUNTAUN_ATTACK_LEFT: 00260 case LS_KICK_F: 00261 case LS_KICK_B: 00262 case LS_KICK_R: 00263 case LS_KICK_L: 00264 case LS_KICK_S: 00265 case LS_KICK_BF: 00266 case LS_KICK_RL: 00267 case LS_KICK_F_AIR: 00268 case LS_KICK_B_AIR: 00269 case LS_KICK_R_AIR: 00270 case LS_KICK_L_AIR: 00271 case LS_STABDOWN: 00272 case LS_STABDOWN_STAFF: 00273 case LS_STABDOWN_DUAL: 00274 case LS_DUAL_SPIN_PROTECT: 00275 case LS_STAFF_SOULCAL: 00276 case LS_A1_SPECIAL: 00277 case LS_A2_SPECIAL: 00278 case LS_A3_SPECIAL: 00279 case LS_UPSIDE_DOWN_ATTACK: 00280 case LS_PULL_ATTACK_STAB: 00281 case LS_PULL_ATTACK_SWING: 00282 case LS_SPINATTACK_ALORA: 00283 case LS_DUAL_FB: 00284 case LS_DUAL_LR: 00285 case LS_HILT_BASH: 00286 return qtrue; 00287 break; 00288 } 00289 return qfalse; 00290 } 00291 00292 qboolean BG_SaberInKata( int saberMove ) 00293 { 00294 switch ( saberMove ) 00295 { 00296 case LS_A1_SPECIAL: 00297 case LS_A2_SPECIAL: 00298 case LS_A3_SPECIAL: 00299 case LS_DUAL_SPIN_PROTECT: 00300 case LS_STAFF_SOULCAL: 00301 return qtrue; 00302 } 00303 return qfalse; 00304 } 00305 00306 qboolean BG_InKataAnim(int anim) 00307 { 00308 switch (anim) 00309 { 00310 case BOTH_A6_SABERPROTECT: 00311 case BOTH_A7_SOULCAL: 00312 case BOTH_A1_SPECIAL: 00313 case BOTH_A2_SPECIAL: 00314 case BOTH_A3_SPECIAL: 00315 return qtrue; 00316 } 00317 return qfalse; 00318 } 00319 00320 qboolean BG_SaberInSpecial( int move ) 00321 { 00322 switch( move ) 00323 { 00324 case LS_A_BACK: 00325 case LS_A_BACK_CR: 00326 case LS_A_BACKSTAB: 00327 case LS_ROLL_STAB: 00328 case LS_A_LUNGE: 00329 case LS_A_JUMP_T__B_: 00330 case LS_A_FLIP_STAB: 00331 case LS_A_FLIP_SLASH: 00332 case LS_JUMPATTACK_DUAL: 00333 case LS_JUMPATTACK_ARIAL_LEFT: 00334 case LS_JUMPATTACK_ARIAL_RIGHT: 00335 case LS_JUMPATTACK_CART_LEFT: 00336 case LS_JUMPATTACK_CART_RIGHT: 00337 case LS_JUMPATTACK_STAFF_LEFT: 00338 case LS_JUMPATTACK_STAFF_RIGHT: 00339 case LS_BUTTERFLY_LEFT: 00340 case LS_BUTTERFLY_RIGHT: 00341 case LS_A_BACKFLIP_ATK: 00342 case LS_SPINATTACK_DUAL: 00343 case LS_SPINATTACK: 00344 case LS_LEAP_ATTACK: 00345 case LS_SWOOP_ATTACK_RIGHT: 00346 case LS_SWOOP_ATTACK_LEFT: 00347 case LS_TAUNTAUN_ATTACK_RIGHT: 00348 case LS_TAUNTAUN_ATTACK_LEFT: 00349 case LS_KICK_F: 00350 case LS_KICK_B: 00351 case LS_KICK_R: 00352 case LS_KICK_L: 00353 case LS_KICK_S: 00354 case LS_KICK_BF: 00355 case LS_KICK_RL: 00356 case LS_KICK_F_AIR: 00357 case LS_KICK_B_AIR: 00358 case LS_KICK_R_AIR: 00359 case LS_KICK_L_AIR: 00360 case LS_STABDOWN: 00361 case LS_STABDOWN_STAFF: 00362 case LS_STABDOWN_DUAL: 00363 case LS_DUAL_SPIN_PROTECT: 00364 case LS_STAFF_SOULCAL: 00365 case LS_A1_SPECIAL: 00366 case LS_A2_SPECIAL: 00367 case LS_A3_SPECIAL: 00368 case LS_UPSIDE_DOWN_ATTACK: 00369 case LS_PULL_ATTACK_STAB: 00370 case LS_PULL_ATTACK_SWING: 00371 case LS_SPINATTACK_ALORA: 00372 case LS_DUAL_FB: 00373 case LS_DUAL_LR: 00374 case LS_HILT_BASH: 00375 return qtrue; 00376 } 00377 return qfalse; 00378 } 00379 00380 qboolean BG_KickMove( int move ) 00381 { 00382 switch( move ) 00383 { 00384 case LS_KICK_F: 00385 case LS_KICK_B: 00386 case LS_KICK_R: 00387 case LS_KICK_L: 00388 case LS_KICK_S: 00389 case LS_KICK_BF: 00390 case LS_KICK_RL: 00391 case LS_KICK_F_AIR: 00392 case LS_KICK_B_AIR: 00393 case LS_KICK_R_AIR: 00394 case LS_KICK_L_AIR: 00395 case LS_HILT_BASH: 00396 return qtrue; 00397 } 00398 return qfalse; 00399 } 00400 00401 qboolean BG_SaberInIdle( int move ) 00402 { 00403 switch ( move ) 00404 { 00405 case LS_NONE: 00406 case LS_READY: 00407 case LS_DRAW: 00408 case LS_PUTAWAY: 00409 return qtrue; 00410 break; 00411 } 00412 return qfalse; 00413 } 00414 00415 qboolean BG_InExtraDefenseSaberMove( int move ) 00416 { 00417 switch ( move ) 00418 { 00419 case LS_SPINATTACK_DUAL: 00420 case LS_SPINATTACK: 00421 case LS_DUAL_SPIN_PROTECT: 00422 case LS_STAFF_SOULCAL: 00423 case LS_A1_SPECIAL: 00424 case LS_A2_SPECIAL: 00425 case LS_A3_SPECIAL: 00426 case LS_JUMPATTACK_DUAL: 00427 return qtrue; 00428 break; 00429 } 00430 return qfalse; 00431 } 00432 00433 qboolean BG_FlippingAnim( int anim ) 00434 { 00435 switch ( anim ) 00436 { 00437 case BOTH_FLIP_F: //# Flip forward 00438 case BOTH_FLIP_B: //# Flip backwards 00439 case BOTH_FLIP_L: //# Flip left 00440 case BOTH_FLIP_R: //# Flip right 00441 case BOTH_WALL_RUN_RIGHT_FLIP: 00442 case BOTH_WALL_RUN_LEFT_FLIP: 00443 case BOTH_WALL_FLIP_RIGHT: 00444 case BOTH_WALL_FLIP_LEFT: 00445 case BOTH_FLIP_BACK1: 00446 case BOTH_FLIP_BACK2: 00447 case BOTH_FLIP_BACK3: 00448 case BOTH_WALL_FLIP_BACK1: 00449 //Not really flips, but... 00450 case BOTH_WALL_RUN_RIGHT: 00451 case BOTH_WALL_RUN_LEFT: 00452 case BOTH_WALL_RUN_RIGHT_STOP: 00453 case BOTH_WALL_RUN_LEFT_STOP: 00454 case BOTH_BUTTERFLY_LEFT: 00455 case BOTH_BUTTERFLY_RIGHT: 00456 case BOTH_BUTTERFLY_FL1: 00457 case BOTH_BUTTERFLY_FR1: 00458 // 00459 case BOTH_ARIAL_LEFT: 00460 case BOTH_ARIAL_RIGHT: 00461 case BOTH_ARIAL_F1: 00462 case BOTH_CARTWHEEL_LEFT: 00463 case BOTH_CARTWHEEL_RIGHT: 00464 case BOTH_JUMPFLIPSLASHDOWN1: 00465 case BOTH_JUMPFLIPSTABDOWN: 00466 case BOTH_JUMPATTACK6: 00467 case BOTH_JUMPATTACK7: 00468 //JKA 00469 case BOTH_FORCEWALLRUNFLIP_END: 00470 case BOTH_FORCEWALLRUNFLIP_ALT: 00471 case BOTH_FLIP_ATTACK7: 00472 case BOTH_A7_SOULCAL: 00473 return qtrue; 00474 break; 00475 } 00476 return qfalse; 00477 } 00478 00479 qboolean BG_SpinningSaberAnim( int anim ) 00480 { 00481 switch ( anim ) 00482 { 00483 //level 1 - FIXME: level 1 will have *no* spins 00484 case BOTH_T1_BR_BL: 00485 case BOTH_T1__R__L: 00486 case BOTH_T1__R_BL: 00487 case BOTH_T1_TR_BL: 00488 case BOTH_T1_BR_TL: 00489 case BOTH_T1_BR__L: 00490 case BOTH_T1_TL_BR: 00491 case BOTH_T1__L_BR: 00492 case BOTH_T1__L__R: 00493 case BOTH_T1_BL_BR: 00494 case BOTH_T1_BL__R: 00495 case BOTH_T1_BL_TR: 00496 //level 2 00497 case BOTH_T2_BR__L: 00498 case BOTH_T2_BR_BL: 00499 case BOTH_T2__R_BL: 00500 case BOTH_T2__L_BR: 00501 case BOTH_T2_BL_BR: 00502 case BOTH_T2_BL__R: 00503 //level 3 00504 case BOTH_T3_BR__L: 00505 case BOTH_T3_BR_BL: 00506 case BOTH_T3__R_BL: 00507 case BOTH_T3__L_BR: 00508 case BOTH_T3_BL_BR: 00509 case BOTH_T3_BL__R: 00510 //level 4 00511 case BOTH_T4_BR__L: 00512 case BOTH_T4_BR_BL: 00513 case BOTH_T4__R_BL: 00514 case BOTH_T4__L_BR: 00515 case BOTH_T4_BL_BR: 00516 case BOTH_T4_BL__R: 00517 //level 5 00518 case BOTH_T5_BR_BL: 00519 case BOTH_T5__R__L: 00520 case BOTH_T5__R_BL: 00521 case BOTH_T5_TR_BL: 00522 case BOTH_T5_BR_TL: 00523 case BOTH_T5_BR__L: 00524 case BOTH_T5_TL_BR: 00525 case BOTH_T5__L_BR: 00526 case BOTH_T5__L__R: 00527 case BOTH_T5_BL_BR: 00528 case BOTH_T5_BL__R: 00529 case BOTH_T5_BL_TR: 00530 //level 6 00531 case BOTH_T6_BR_TL: 00532 case BOTH_T6__R_TL: 00533 case BOTH_T6__R__L: 00534 case BOTH_T6__R_BL: 00535 case BOTH_T6_TR_TL: 00536 case BOTH_T6_TR__L: 00537 case BOTH_T6_TR_BL: 00538 case BOTH_T6_T__TL: 00539 case BOTH_T6_T__BL: 00540 case BOTH_T6_TL_BR: 00541 case BOTH_T6__L_BR: 00542 case BOTH_T6__L__R: 00543 case BOTH_T6_TL__R: 00544 case BOTH_T6_TL_TR: 00545 case BOTH_T6__L_TR: 00546 case BOTH_T6__L_T_: 00547 case BOTH_T6_BL_T_: 00548 case BOTH_T6_BR__L: 00549 case BOTH_T6_BR_BL: 00550 case BOTH_T6_BL_BR: 00551 case BOTH_T6_BL__R: 00552 case BOTH_T6_BL_TR: 00553 //level 7 00554 case BOTH_T7_BR_TL: 00555 case BOTH_T7_BR__L: 00556 case BOTH_T7_BR_BL: 00557 case BOTH_T7__R__L: 00558 case BOTH_T7__R_BL: 00559 case BOTH_T7_TR__L: 00560 case BOTH_T7_T___R: 00561 case BOTH_T7_TL_BR: 00562 case BOTH_T7__L_BR: 00563 case BOTH_T7__L__R: 00564 case BOTH_T7_BL_BR: 00565 case BOTH_T7_BL__R: 00566 case BOTH_T7_BL_TR: 00567 case BOTH_T7_TL_TR: 00568 case BOTH_T7_T__BR: 00569 case BOTH_T7__L_TR: 00570 case BOTH_V7_BL_S7: 00571 //special 00572 //case BOTH_A2_STABBACK1: 00573 case BOTH_ATTACK_BACK: 00574 case BOTH_CROUCHATTACKBACK1: 00575 case BOTH_BUTTERFLY_LEFT: 00576 case BOTH_BUTTERFLY_RIGHT: 00577 case BOTH_FJSS_TR_BL: 00578 case BOTH_FJSS_TL_BR: 00579 case BOTH_JUMPFLIPSLASHDOWN1: 00580 case BOTH_JUMPFLIPSTABDOWN: 00581 return qtrue; 00582 break; 00583 } 00584 return qfalse; 00585 } 00586 00587 qboolean BG_SaberInSpecialAttack( int anim ) 00588 { 00589 switch ( anim ) 00590 { 00591 case BOTH_A2_STABBACK1: 00592 case BOTH_ATTACK_BACK: 00593 case BOTH_CROUCHATTACKBACK1: 00594 case BOTH_ROLL_STAB: 00595 case BOTH_BUTTERFLY_LEFT: 00596 case BOTH_BUTTERFLY_RIGHT: 00597 case BOTH_BUTTERFLY_FL1: 00598 case BOTH_BUTTERFLY_FR1: 00599 case BOTH_FJSS_TR_BL: 00600 case BOTH_FJSS_TL_BR: 00601 case BOTH_LUNGE2_B__T_: 00602 case BOTH_FORCELEAP2_T__B_: 00603 case BOTH_JUMPFLIPSLASHDOWN1://# 00604 case BOTH_JUMPFLIPSTABDOWN://# 00605 case BOTH_JUMPATTACK6: 00606 case BOTH_JUMPATTACK7: 00607 case BOTH_SPINATTACK6: 00608 case BOTH_SPINATTACK7: 00609 case BOTH_FORCELONGLEAP_ATTACK: 00610 case BOTH_VS_ATR_S: 00611 case BOTH_VS_ATL_S: 00612 case BOTH_VT_ATR_S: 00613 case BOTH_VT_ATL_S: 00614 case BOTH_A7_KICK_F: 00615 case BOTH_A7_KICK_B: 00616 case BOTH_A7_KICK_R: 00617 case BOTH_A7_KICK_L: 00618 case BOTH_A7_KICK_S: 00619 case BOTH_A7_KICK_BF: 00620 case BOTH_A7_KICK_RL: 00621 case BOTH_A7_KICK_F_AIR: 00622 case BOTH_A7_KICK_B_AIR: 00623 case BOTH_A7_KICK_R_AIR: 00624 case BOTH_A7_KICK_L_AIR: 00625 case BOTH_STABDOWN: 00626 case BOTH_STABDOWN_STAFF: 00627 case BOTH_STABDOWN_DUAL: 00628 case BOTH_A6_SABERPROTECT: 00629 case BOTH_A7_SOULCAL: 00630 case BOTH_A1_SPECIAL: 00631 case BOTH_A2_SPECIAL: 00632 case BOTH_A3_SPECIAL: 00633 case BOTH_FLIP_ATTACK7: 00634 case BOTH_PULL_IMPALE_STAB: 00635 case BOTH_PULL_IMPALE_SWING: 00636 case BOTH_ALORA_SPIN_SLASH: 00637 case BOTH_A6_FB: 00638 case BOTH_A6_LR: 00639 case BOTH_A7_HILT: 00640 return qtrue; 00641 } 00642 return qfalse; 00643 } 00644 00645 qboolean BG_KickingAnim( int anim ) 00646 { 00647 switch ( anim ) 00648 { 00649 case BOTH_A7_KICK_F: 00650 case BOTH_A7_KICK_B: 00651 case BOTH_A7_KICK_R: 00652 case BOTH_A7_KICK_L: 00653 case BOTH_A7_KICK_S: 00654 case BOTH_A7_KICK_BF: 00655 case BOTH_A7_KICK_RL: 00656 case BOTH_A7_KICK_F_AIR: 00657 case BOTH_A7_KICK_B_AIR: 00658 case BOTH_A7_KICK_R_AIR: 00659 case BOTH_A7_KICK_L_AIR: 00660 case BOTH_A7_HILT: 00661 //NOT kicks, but do kick traces anyway 00662 case BOTH_GETUP_BROLL_B: 00663 case BOTH_GETUP_BROLL_F: 00664 case BOTH_GETUP_FROLL_B: 00665 case BOTH_GETUP_FROLL_F: 00666 return qtrue; 00667 break; 00668 } 00669 return qfalse; 00670 } 00671 00672 int BG_InGrappleMove(int anim) 00673 { 00674 switch (anim) 00675 { 00676 case BOTH_KYLE_GRAB: 00677 case BOTH_KYLE_MISS: 00678 return 1; //grabbing at someone 00679 case BOTH_KYLE_PA_1: 00680 case BOTH_KYLE_PA_2: 00681 return 2; //beating the shit out of someone 00682 case BOTH_PLAYER_PA_1: 00683 case BOTH_PLAYER_PA_2: 00684 case BOTH_PLAYER_PA_FLY: 00685 return 3; //getting the shit beaten out of you 00686 break; 00687 } 00688 00689 return 0; 00690 } 00691 00692 int BG_BrokenParryForAttack( int move ) 00693 { 00694 //Our attack was knocked away by a knockaway parry 00695 //FIXME: need actual anims for this 00696 //FIXME: need to know which side of the saber was hit! For now, we presume the saber gets knocked away from the center 00697 switch ( saberMoveData[move].startQuad ) 00698 { 00699 case Q_B: 00700 return LS_V1_B_; 00701 break; 00702 case Q_BR: 00703 return LS_V1_BR; 00704 break; 00705 case Q_R: 00706 return LS_V1__R; 00707 break; 00708 case Q_TR: 00709 return LS_V1_TR; 00710 break; 00711 case Q_T: 00712 return LS_V1_T_; 00713 break; 00714 case Q_TL: 00715 return LS_V1_TL; 00716 break; 00717 case Q_L: 00718 return LS_V1__L; 00719 break; 00720 case Q_BL: 00721 return LS_V1_BL; 00722 break; 00723 } 00724 return LS_NONE; 00725 } 00726 00727 int BG_BrokenParryForParry( int move ) 00728 { 00729 //FIXME: need actual anims for this 00730 //FIXME: need to know which side of the saber was hit! For now, we presume the saber gets knocked away from the center 00731 switch ( move ) 00732 { 00733 case LS_PARRY_UP: 00734 //Hmm... since we don't know what dir the hit came from, randomly pick knock down or knock back 00735 if ( Q_irand( 0, 1 ) ) 00736 { 00737 return LS_H1_B_; 00738 } 00739 else 00740 { 00741 return LS_H1_T_; 00742 } 00743 break; 00744 case LS_PARRY_UR: 00745 return LS_H1_TR; 00746 break; 00747 case LS_PARRY_UL: 00748 return LS_H1_TL; 00749 break; 00750 case LS_PARRY_LR: 00751 return LS_H1_BR; 00752 break; 00753 case LS_PARRY_LL: 00754 return LS_H1_BL; 00755 break; 00756 case LS_READY: 00757 return LS_H1_B_;//??? 00758 break; 00759 } 00760 return LS_NONE; 00761 } 00762 00763 int BG_KnockawayForParry( int move ) 00764 { 00765 //FIXME: need actual anims for this 00766 //FIXME: need to know which side of the saber was hit! For now, we presume the saber gets knocked away from the center 00767 switch ( move ) 00768 { 00769 case BLOCKED_TOP://LS_PARRY_UP: 00770 return LS_K1_T_;//push up 00771 break; 00772 case BLOCKED_UPPER_RIGHT://LS_PARRY_UR: 00773 default://case LS_READY: 00774 return LS_K1_TR;//push up, slightly to right 00775 break; 00776 case BLOCKED_UPPER_LEFT://LS_PARRY_UL: 00777 return LS_K1_TL;//push up and to left 00778 break; 00779 case BLOCKED_LOWER_RIGHT://LS_PARRY_LR: 00780 return LS_K1_BR;//push down and to left 00781 break; 00782 case BLOCKED_LOWER_LEFT://LS_PARRY_LL: 00783 return LS_K1_BL;//push down and to right 00784 break; 00785 } 00786 //return LS_NONE; 00787 } 00788 00789 qboolean BG_InRoll( playerState_t *ps, int anim ) 00790 { 00791 switch ( (anim) ) 00792 { 00793 case BOTH_GETUP_BROLL_B: 00794 case BOTH_GETUP_BROLL_F: 00795 case BOTH_GETUP_BROLL_L: 00796 case BOTH_GETUP_BROLL_R: 00797 case BOTH_GETUP_FROLL_B: 00798 case BOTH_GETUP_FROLL_F: 00799 case BOTH_GETUP_FROLL_L: 00800 case BOTH_GETUP_FROLL_R: 00801 case BOTH_ROLL_F: 00802 case BOTH_ROLL_B: 00803 case BOTH_ROLL_R: 00804 case BOTH_ROLL_L: 00805 if ( ps->legsTimer > 0 ) 00806 { 00807 return qtrue; 00808 } 00809 break; 00810 } 00811 return qfalse; 00812 } 00813 00814 qboolean BG_InSpecialDeathAnim( int anim ) 00815 { 00816 switch( anim ) 00817 { 00818 case BOTH_DEATH_ROLL: //# Death anim from a roll 00819 case BOTH_DEATH_FLIP: //# Death anim from a flip 00820 case BOTH_DEATH_SPIN_90_R: //# Death anim when facing 90 degrees right 00821 case BOTH_DEATH_SPIN_90_L: //# Death anim when facing 90 degrees left 00822 case BOTH_DEATH_SPIN_180: //# Death anim when facing backwards 00823 case BOTH_DEATH_LYING_UP: //# Death anim when lying on back 00824 case BOTH_DEATH_LYING_DN: //# Death anim when lying on front 00825 case BOTH_DEATH_FALLING_DN: //# Death anim when falling on face 00826 case BOTH_DEATH_FALLING_UP: //# Death anim when falling on back 00827 case BOTH_DEATH_CROUCHED: //# Death anim when crouched 00828 return qtrue; 00829 break; 00830 default: 00831 return qfalse; 00832 break; 00833 } 00834 } 00835 00836 qboolean BG_InDeathAnim ( int anim ) 00837 {//Purposely does not cover stumbledeath and falldeath... 00838 switch( anim ) 00839 { 00840 case BOTH_DEATH1: //# First Death anim 00841 case BOTH_DEATH2: //# Second Death anim 00842 case BOTH_DEATH3: //# Third Death anim 00843 case BOTH_DEATH4: //# Fourth Death anim 00844 case BOTH_DEATH5: //# Fifth Death anim 00845 case BOTH_DEATH6: //# Sixth Death anim 00846 case BOTH_DEATH7: //# Seventh Death anim 00847 case BOTH_DEATH8: //# 00848 case BOTH_DEATH9: //# 00849 case BOTH_DEATH10: //# 00850 case BOTH_DEATH11: //# 00851 case BOTH_DEATH12: //# 00852 case BOTH_DEATH13: //# 00853 case BOTH_DEATH14: //# 00854 case BOTH_DEATH14_UNGRIP: //# Desann's end death (cin #35) 00855 case BOTH_DEATH14_SITUP: //# Tavion sitting up after having been thrown (cin #23) 00856 case BOTH_DEATH15: //# 00857 case BOTH_DEATH16: //# 00858 case BOTH_DEATH17: //# 00859 case BOTH_DEATH18: //# 00860 case BOTH_DEATH19: //# 00861 case BOTH_DEATH20: //# 00862 case BOTH_DEATH21: //# 00863 case BOTH_DEATH22: //# 00864 case BOTH_DEATH23: //# 00865 case BOTH_DEATH24: //# 00866 case BOTH_DEATH25: //# 00867 00868 case BOTH_DEATHFORWARD1: //# First Death in which they get thrown forward 00869 case BOTH_DEATHFORWARD2: //# Second Death in which they get thrown forward 00870 case BOTH_DEATHFORWARD3: //# Tavion's falling in cin# 23 00871 case BOTH_DEATHBACKWARD1: //# First Death in which they get thrown backward 00872 case BOTH_DEATHBACKWARD2: //# Second Death in which they get thrown backward 00873 00874 case BOTH_DEATH1IDLE: //# Idle while close to death 00875 case BOTH_LYINGDEATH1: //# Death to play when killed lying down 00876 case BOTH_STUMBLEDEATH1: //# Stumble forward and fall face first death 00877 case BOTH_FALLDEATH1: //# Fall forward off a high cliff and splat death - start 00878 case BOTH_FALLDEATH1INAIR: //# Fall forward off a high cliff and splat death - loop 00879 case BOTH_FALLDEATH1LAND: //# Fall forward off a high cliff and splat death - hit bottom 00880 //# #sep case BOTH_ DEAD POSES # Should be last frame of corresponding previous anims 00881 case BOTH_DEAD1: //# First Death finished pose 00882 case BOTH_DEAD2: //# Second Death finished pose 00883 case BOTH_DEAD3: //# Third Death finished pose 00884 case BOTH_DEAD4: //# Fourth Death finished pose 00885 case BOTH_DEAD5: //# Fifth Death finished pose 00886 case BOTH_DEAD6: //# Sixth Death finished pose 00887 case BOTH_DEAD7: //# Seventh Death finished pose 00888 case BOTH_DEAD8: //# 00889 case BOTH_DEAD9: //# 00890 case BOTH_DEAD10: //# 00891 case BOTH_DEAD11: //# 00892 case BOTH_DEAD12: //# 00893 case BOTH_DEAD13: //# 00894 case BOTH_DEAD14: //# 00895 case BOTH_DEAD15: //# 00896 case BOTH_DEAD16: //# 00897 case BOTH_DEAD17: //# 00898 case BOTH_DEAD18: //# 00899 case BOTH_DEAD19: //# 00900 case BOTH_DEAD20: //# 00901 case BOTH_DEAD21: //# 00902 case BOTH_DEAD22: //# 00903 case BOTH_DEAD23: //# 00904 case BOTH_DEAD24: //# 00905 case BOTH_DEAD25: //# 00906 case BOTH_DEADFORWARD1: //# First thrown forward death finished pose 00907 case BOTH_DEADFORWARD2: //# Second thrown forward death finished pose 00908 case BOTH_DEADBACKWARD1: //# First thrown backward death finished pose 00909 case BOTH_DEADBACKWARD2: //# Second thrown backward death finished pose 00910 case BOTH_LYINGDEAD1: //# Killed lying down death finished pose 00911 case BOTH_STUMBLEDEAD1: //# Stumble forward death finished pose 00912 case BOTH_FALLDEAD1LAND: //# Fall forward and splat death finished pose 00913 //# #sep case BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses 00914 case BOTH_DEADFLOP1: //# React to being shot from First Death finished pose 00915 case BOTH_DEADFLOP2: //# React to being shot from Second Death finished pose 00916 case BOTH_DISMEMBER_HEAD1: //# 00917 case BOTH_DISMEMBER_TORSO1: //# 00918 case BOTH_DISMEMBER_LLEG: //# 00919 case BOTH_DISMEMBER_RLEG: //# 00920 case BOTH_DISMEMBER_RARM: //# 00921 case BOTH_DISMEMBER_LARM: //# 00922 return qtrue; 00923 break; 00924 default: 00925 return BG_InSpecialDeathAnim( anim ); 00926 break; 00927 } 00928 } 00929 00930 qboolean BG_InKnockDownOnly( int anim ) 00931 { 00932 switch ( anim ) 00933 { 00934 case BOTH_KNOCKDOWN1: 00935 case BOTH_KNOCKDOWN2: 00936 case BOTH_KNOCKDOWN3: 00937 case BOTH_KNOCKDOWN4: 00938 case BOTH_KNOCKDOWN5: 00939 return qtrue; 00940 } 00941 return qfalse; 00942 } 00943 00944 qboolean BG_InSaberLockOld( int anim ) 00945 { 00946 switch ( anim ) 00947 { 00948 case BOTH_BF2LOCK: 00949 case BOTH_BF1LOCK: 00950 case BOTH_CWCIRCLELOCK: 00951 case BOTH_CCWCIRCLELOCK: 00952 return qtrue; 00953 } 00954 return qfalse; 00955 } 00956 00957 qboolean BG_InSaberLock( int anim ) 00958 { 00959 switch ( anim ) 00960 { 00961 case BOTH_LK_S_DL_S_L_1: //lock if I'm using single vs. a dual 00962 case BOTH_LK_S_DL_T_L_1: //lock if I'm using single vs. a dual 00963 case BOTH_LK_S_ST_S_L_1: //lock if I'm using single vs. a staff 00964 case BOTH_LK_S_ST_T_L_1: //lock if I'm using single vs. a staff 00965 case BOTH_LK_S_S_S_L_1: //lock if I'm using single vs. a single and I initiated 00966 case BOTH_LK_S_S_T_L_1: //lock if I'm using single vs. a single and I initiated 00967 case BOTH_LK_DL_DL_S_L_1: //lock if I'm using dual vs. dual and I initiated 00968 case BOTH_LK_DL_DL_T_L_1: //lock if I'm using dual vs. dual and I initiated 00969 case BOTH_LK_DL_ST_S_L_1: //lock if I'm using dual vs. a staff 00970 case BOTH_LK_DL_ST_T_L_1: //lock if I'm using dual vs. a staff 00971 case BOTH_LK_DL_S_S_L_1: //lock if I'm using dual vs. a single 00972 case BOTH_LK_DL_S_T_L_1: //lock if I'm using dual vs. a single 00973 case BOTH_LK_ST_DL_S_L_1: //lock if I'm using staff vs. dual 00974 case BOTH_LK_ST_DL_T_L_1: //lock if I'm using staff vs. dual 00975 case BOTH_LK_ST_ST_S_L_1: //lock if I'm using staff vs. a staff and I initiated 00976 case BOTH_LK_ST_ST_T_L_1: //lock if I'm using staff vs. a staff and I initiated 00977 case BOTH_LK_ST_S_S_L_1: //lock if I'm using staff vs. a single 00978 case BOTH_LK_ST_S_T_L_1: //lock if I'm using staff vs. a single 00979 case BOTH_LK_S_S_S_L_2: 00980 case BOTH_LK_S_S_T_L_2: 00981 case BOTH_LK_DL_DL_S_L_2: 00982 case BOTH_LK_DL_DL_T_L_2: 00983 case BOTH_LK_ST_ST_S_L_2: 00984 case BOTH_LK_ST_ST_T_L_2: 00985 return qtrue; 00986 break; 00987 default: 00988 return BG_InSaberLockOld( anim ); 00989 break; 00990 } 00991 //return qfalse; 00992 } 00993 00994 //Called only where pm is valid (not all require pm, but some do): 00995 qboolean PM_InCartwheel( int anim ) 00996 { 00997 switch ( anim ) 00998 { 00999 case BOTH_ARIAL_LEFT: 01000 case BOTH_ARIAL_RIGHT: 01001 case BOTH_ARIAL_F1: 01002 case BOTH_CARTWHEEL_LEFT: 01003 case BOTH_CARTWHEEL_RIGHT: 01004 return qtrue; 01005 break; 01006 } 01007 return qfalse; 01008 } 01009 01010 qboolean BG_InKnockDownOnGround( playerState_t *ps ) 01011 { 01012 switch ( ps->legsAnim ) 01013 { 01014 case BOTH_KNOCKDOWN1: 01015 case BOTH_KNOCKDOWN2: 01016 case BOTH_KNOCKDOWN3: 01017 case BOTH_KNOCKDOWN4: 01018 case BOTH_KNOCKDOWN5: 01019 case BOTH_RELEASED: 01020 //if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->legsAnimTimer > 300 ) 01021 {//at end of fall down anim 01022 return qtrue; 01023 } 01024 break; 01025 case BOTH_GETUP1: 01026 case BOTH_GETUP2: 01027 case BOTH_GETUP3: 01028 case BOTH_GETUP4: 01029 case BOTH_GETUP5: 01030 case BOTH_GETUP_CROUCH_F1: 01031 case BOTH_GETUP_CROUCH_B1: 01032 case BOTH_FORCE_GETUP_F1: 01033 case BOTH_FORCE_GETUP_F2: 01034 case BOTH_FORCE_GETUP_B1: 01035 case BOTH_FORCE_GETUP_B2: 01036 case BOTH_FORCE_GETUP_B3: 01037 case BOTH_FORCE_GETUP_B4: 01038 case BOTH_FORCE_GETUP_B5: 01039 case BOTH_FORCE_GETUP_B6: 01040 if ( BG_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->legsTimer < 500 ) 01041 {//at beginning of getup anim 01042 return qtrue; 01043 } 01044 break; 01045 case BOTH_GETUP_BROLL_B: 01046 case BOTH_GETUP_BROLL_F: 01047 case BOTH_GETUP_BROLL_L: 01048 case BOTH_GETUP_BROLL_R: 01049 case BOTH_GETUP_FROLL_B: 01050 case BOTH_GETUP_FROLL_F: 01051 case BOTH_GETUP_FROLL_L: 01052 case BOTH_GETUP_FROLL_R: 01053 if ( BG_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->legsTimer < 500 ) 01054 {//at beginning of getup anim 01055 return qtrue; 01056 } 01057 break; 01058 case BOTH_LK_DL_ST_T_SB_1_L: 01059 if ( ps->legsTimer < 1000 ) 01060 { 01061 return qtrue; 01062 } 01063 break; 01064 case BOTH_PLAYER_PA_3_FLY: 01065 if ( ps->legsTimer < 300 ) 01066 { 01067 return qtrue; 01068 } 01069 break; 01070 } 01071 return qfalse; 01072 } 01073 01074 qboolean BG_StabDownAnim( int anim ) 01075 { 01076 switch ( anim ) 01077 { 01078 case BOTH_STABDOWN: 01079 case BOTH_STABDOWN_STAFF: 01080 case BOTH_STABDOWN_DUAL: 01081 return qtrue; 01082 } 01083 return qfalse; 01084 } 01085 01086 int PM_SaberBounceForAttack( int move ) 01087 { 01088 switch ( saberMoveData[move].startQuad ) 01089 { 01090 case Q_B: 01091 case Q_BR: 01092 return LS_B1_BR; 01093 break; 01094 case Q_R: 01095 return LS_B1__R; 01096 break; 01097 case Q_TR: 01098 return LS_B1_TR; 01099 break; 01100 case Q_T: 01101 return LS_B1_T_; 01102 break; 01103 case Q_TL: 01104 return LS_B1_TL; 01105 break; 01106 case Q_L: 01107 return LS_B1__L; 01108 break; 01109 case Q_BL: 01110 return LS_B1_BL; 01111 break; 01112 } 01113 return LS_NONE; 01114 } 01115 01116 int PM_SaberDeflectionForQuad( int quad ) 01117 { 01118 switch ( quad ) 01119 { 01120 case Q_B: 01121 return LS_D1_B_; 01122 break; 01123 case Q_BR: 01124 return LS_D1_BR; 01125 break; 01126 case Q_R: 01127 return LS_D1__R; 01128 break; 01129 case Q_TR: 01130 return LS_D1_TR; 01131 break; 01132 case Q_T: 01133 return LS_D1_T_; 01134 break; 01135 case Q_TL: 01136 return LS_D1_TL; 01137 break; 01138 case Q_L: 01139 return LS_D1__L; 01140 break; 01141 case Q_BL: 01142 return LS_D1_BL; 01143 break; 01144 } 01145 return LS_NONE; 01146 } 01147 01148 qboolean PM_SaberInDeflect( int move ) 01149 { 01150 if ( move >= LS_D1_BR && move <= LS_D1_B_ ) 01151 { 01152 return qtrue; 01153 } 01154 return qfalse; 01155 } 01156 01157 qboolean PM_SaberInParry( int move ) 01158 { 01159 if ( move >= LS_PARRY_UP && move <= LS_PARRY_LL ) 01160 { 01161 return qtrue; 01162 } 01163 return qfalse; 01164 } 01165 01166 qboolean PM_SaberInKnockaway( int move ) 01167 { 01168 if ( move >= LS_K1_T_ && move <= LS_K1_BL ) 01169 { 01170 return qtrue; 01171 } 01172 return qfalse; 01173 } 01174 01175 qboolean PM_SaberInReflect( int move ) 01176 { 01177 if ( move >= LS_REFLECT_UP && move <= LS_REFLECT_LL ) 01178 { 01179 return qtrue; 01180 } 01181 return qfalse; 01182 } 01183 01184 qboolean PM_SaberInStart( int move ) 01185 { 01186 if ( move >= LS_S_TL2BR && move <= LS_S_T2B ) 01187 { 01188 return qtrue; 01189 } 01190 return qfalse; 01191 } 01192 01193 qboolean PM_SaberInReturn( int move ) 01194 { 01195 if ( move >= LS_R_TL2BR && move <= LS_R_T2B ) 01196 { 01197 return qtrue; 01198 } 01199 return qfalse; 01200 } 01201 01202 qboolean BG_SaberInReturn( int move ) 01203 { 01204 return PM_SaberInReturn( move ); 01205 } 01206 01207 qboolean PM_InSaberAnim( int anim ) 01208 { 01209 if ( (anim) >= BOTH_A1_T__B_ && (anim) <= BOTH_H1_S1_BR ) 01210 { 01211 return qtrue; 0