tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Combat/humanstate.cpp

1512 lines
46 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando *
* *
* $Archive:: /Commando/Code/Combat/humanstate.cpp $*
* *
* $Author:: Patrick $*
* *
* $Modtime:: 2/26/02 11:47a $*
* *
* $Revision:: 169 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
** Includes
*/
#include "humanstate.h"
#include "debug.h"
#include "animcontrol.h"
#include "humanphys.h"
#include "weapons.h"
#include "assets.h"
#include "combat.h"
#include "combat.h"
#include "physcoltest.h"
#include "pscene.h"
#include <stdio.h>
#include "timemgr.h"
#include "definitionclassids.h"
#include "pathfind.h"
#include "encoderlist.h"
#include "bitpackids.h"
#include "humanrecoil.h"
#include "globalsettings.h"
#include "combatchunkid.h"
#include "wwprofile.h"
#include "surfaceeffects.h"
#include "crandom.h"
#include "gametype.h"
#include "soldier.h"
#include "damage.h"
#include "transitioneffect.h"
#include "combatmaterialeffectmanager.h"
/*
** Static instance of HumanRecoilClass for recoil calculations
*/
static HumanRecoilClass _TheRecoiler;
/******************************************************************************************
**
** HumanStateClass Implementation
**
******************************************************************************************/
HumanStateClass::HumanStateClass( void ) :
State( UPRIGHT ),
StateFlags( 0 ),
StateTimer( 0 ),
SubState( 0 ),
StateLocked( false ),
AnimControl( NULL ),
WeaponHoldStyle(WEAPON_HOLD_STYLE_EMPTY_HANDS),
HumanPhys( NULL ),
TurnVelocity( 0 ),
AimingTilt( 0 ),
AimingTurn( 0 ),
RecoilTimer( 0.0f ),
RecoilScale( 1.0f ),
LoiterDelay( 0 ),
LoitersAllowed( true ),
LegRotation( 0 ),
WeaponHoldTimer( 0 ),
NoAnimBlend( false ),
HumanAnimOverride( NULL ),
HumanLoiterCollection( NULL ),
WeaponFired( false )
{
Reset_Loiter_Delay();
}
HumanStateClass::~HumanStateClass( void )
{
if ( HumanPhys != NULL ) {
HumanPhys->Release_Ref();
HumanPhys = NULL;
}
}
void HumanStateClass::Init( HumanPhysClass * human_phys )
{
WWASSERT( HumanPhys == NULL );
WWASSERT( human_phys != NULL );
HumanPhys = human_phys;
HumanPhys->Add_Ref();
}
void HumanStateClass::Reset( void )
{
REF_PTR_RELEASE( HumanPhys );
// Clear the sniping flag
if ( Get_State_Flag( SNIPING_FLAG ) ) {
Toggle_State_Flag( SNIPING_FLAG );
}
}
void HumanStateClass::Set_Anim_Control( HumanAnimControlClass * anim_control )
{
WWASSERT( AnimControl == NULL || AnimControl == anim_control );
WWASSERT( anim_control != NULL );
AnimControl = anim_control;
AnimControl->Set_Model( HumanPhys->Peek_Model() );
}
void HumanStateClass::Set_Human_Anim_Override( const char * name )
{
HumanAnimOverride = (HumanAnimOverrideDef *)DefinitionMgrClass::Find_Typed_Definition( name,
CLASSID_GLOBAL_SETTINGS_DEF_HUMAN_ANIM_OVERRIDE );
}
void HumanStateClass::Set_Human_Anim_Override( int def_id )
{
HumanAnimOverride = (HumanAnimOverrideDef *)DefinitionMgrClass::Find_Definition( def_id );
}
void HumanStateClass::Set_Human_Loiter_Collection( int def_id )
{
HumanLoiterCollection = (HumanLoiterGlobalSettingsDef *)DefinitionMgrClass::Find_Definition( def_id );
}
/*
** CommandoHumanState Save and Load
*/
enum {
CHUNKID_VARIABLES = 915991207,
XXX_CHUNKID_ANIM_CONTROL,
MICROCHUNKID_STATE = 1,
MICROCHUNKID_SUB_STATE,
MICROCHUNKID_STATE_LOCKED,
MICROCHUNKID_WEAPON_HOLD_STYLE,
XXXMICROCHUNKID_WEAPON_STATE,
MICROCHUNKID_AIMING_TILT,
MICROCHUNKID_AIMING_TURN,
MICROCHUNKID_TURN_VELOCITY,
MICROCHUNKID_PHYSOBJ,
MICROCHUNKID_LOITER_DELAY,
MICROCHUNKID_STATE_FLAGS,
MICROCHUNKID_JUMP_TM,
MICROCHUNKID_STATE_TIMER,
MICROCHUNKID_LOITERS_ALLOWED,
MICROCHUNKID_WEAPON_HOLD_TIMER,
MICROCHUNKID_HUMAN_ANIM_OVERRIDE_DEF_ID,
MICROCHUNKID_HUMAN_LOITER_COLLECTION_DEF_ID,
};
bool HumanStateClass::Save( ChunkSaveClass & csave )
{
csave.Begin_Chunk( CHUNKID_VARIABLES );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_STATE, State );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_STATE_FLAGS, StateFlags );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_SUB_STATE, SubState );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_STATE_LOCKED, StateLocked );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_WEAPON_HOLD_STYLE, WeaponHoldStyle );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_AIMING_TILT, AimingTilt );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_AIMING_TURN, AimingTurn );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TURN_VELOCITY, TurnVelocity );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_PHYSOBJ, HumanPhys );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LOITER_DELAY, LoiterDelay );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LOITERS_ALLOWED, LoitersAllowed );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_JUMP_TM, JumpTM );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_STATE_TIMER, StateTimer );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_WEAPON_HOLD_TIMER, WeaponHoldTimer );
if ( HumanAnimOverride != NULL ) {
int id = HumanAnimOverride->Get_ID();
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_HUMAN_ANIM_OVERRIDE_DEF_ID, id );
}
if ( HumanLoiterCollection != NULL ) {
int id = HumanLoiterCollection->Get_ID();
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_HUMAN_LOITER_COLLECTION_DEF_ID, id );
}
csave.End_Chunk();
// Don't need to save AnimControl, it gets set externally
// We don't save recoil states
return true;
}
bool HumanStateClass::Load( ChunkLoadClass &cload )
{
int human_anim_override_def_id = 0;
int human_loiter_collection_def_id = 0;
WWASSERT( HumanPhys == NULL );
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_VARIABLES:
WWASSERT( HumanPhys == NULL );
while (cload.Open_Micro_Chunk()) {
WWASSERT(SubState >= 0 && SubState <= HIGHEST_HUMAN_SUB_STATE);
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_STATE, State );
READ_MICRO_CHUNK( cload, MICROCHUNKID_STATE_FLAGS, StateFlags );
READ_MICRO_CHUNK( cload, MICROCHUNKID_SUB_STATE, SubState );
READ_MICRO_CHUNK( cload, MICROCHUNKID_STATE_LOCKED, StateLocked );
READ_MICRO_CHUNK( cload, MICROCHUNKID_WEAPON_HOLD_STYLE, WeaponHoldStyle );
READ_MICRO_CHUNK( cload, MICROCHUNKID_AIMING_TILT, AimingTilt );
READ_MICRO_CHUNK( cload, MICROCHUNKID_AIMING_TURN, AimingTurn );
READ_MICRO_CHUNK( cload, MICROCHUNKID_TURN_VELOCITY, TurnVelocity );
READ_MICRO_CHUNK( cload, MICROCHUNKID_PHYSOBJ, HumanPhys );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LOITER_DELAY, LoiterDelay );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LOITERS_ALLOWED, LoitersAllowed );
READ_MICRO_CHUNK( cload, MICROCHUNKID_JUMP_TM, JumpTM );
READ_MICRO_CHUNK( cload, MICROCHUNKID_STATE_TIMER, StateTimer );
READ_MICRO_CHUNK( cload, MICROCHUNKID_WEAPON_HOLD_TIMER, WeaponHoldTimer );
READ_MICRO_CHUNK( cload, MICROCHUNKID_HUMAN_ANIM_OVERRIDE_DEF_ID, human_anim_override_def_id );
READ_MICRO_CHUNK( cload, MICROCHUNKID_HUMAN_LOITER_COLLECTION_DEF_ID, human_loiter_collection_def_id );
default:
Debug_Say(( "Unrecognized Human Variable chunkID\n" ));
break;
}
cload.Close_Micro_Chunk();
}
WWASSERT( HumanPhys != NULL );
if ( HumanPhys != NULL ) {
REQUEST_REF_COUNTED_POINTER_REMAP( (RefCountClass **)&HumanPhys );
}
break;
default:
Debug_Say(( "Unrecognized Human chunkID\n" ));
break;
}
cload.Close_Chunk();
}
if ( human_anim_override_def_id != 0 ) {
Set_Human_Anim_Override( human_anim_override_def_id );
}
if ( human_loiter_collection_def_id != 0 ) {
Set_Human_Loiter_Collection( human_loiter_collection_def_id );
}
return true;
}
/*
**
*/
void HumanStateClass::Update_Weapon( WeaponClass * weapon, bool new_weapon )
{
WWPROFILE( "Human Weapon" );
Update_Recoil(weapon);
int new_hold_style = WeaponHoldStyle;
WeaponFired = false;
if ( weapon ) {
if ( weapon->Is_Reloading() ) {
Raise_Weapon();
}
weapon->Set_Safety( WeaponHoldStyle > WEAPON_HOLD_STYLE_EMPTY_HANDS );
// Only humans can cansider weapons firing in state
if ( weapon->Get_Owner() &&
weapon->Get_Owner()->As_SoldierGameObj() &&
weapon->Get_Owner()->As_SoldierGameObj()->Is_Human_Controlled() ) {
WeaponFired = weapon->Is_Firing();
}
if ( weapon->Is_Triggered() || new_weapon || Get_State_Flag( CROUCHED_FLAG ) ) {
if ( weapon->Is_Safety_Set() ) { // Don't blend anim when un-safetying
NoAnimBlend = true;
}
Raise_Weapon(); // Reset the drop timer
new_hold_style = weapon->Get_Style(); // Take the new style
}
if ( WeaponHoldTimer > 0 ) {
if ( WeaponHoldStyle > WEAPON_HOLD_STYLE_EMPTY_HANDS ) {
new_hold_style = weapon->Get_Style(); // Take the new style
}
}
} else {
new_hold_style = WEAPON_HOLD_STYLE_EMPTY_HANDS;
}
if ( new_hold_style == WeaponHoldStyle ) {
return;
}
WeaponHoldStyle = new_hold_style;
if ( !StateLocked ) {
Update_Animation();
}
}
void HumanStateClass::Update_Aiming( float tilt, float turn )
{
if ( (AimingTilt == tilt) && (AimingTurn == turn) ) {
return;
}
AimingTilt = tilt;
AimingTurn = turn;
if ( !StateLocked ) {
Update_Animation();
}
}
void HumanStateClass::Update_Recoil(WeaponClass * weapon)
{
// Programatic Recoil System. This code needs to run once per frame.
if ((weapon != NULL) && (weapon->Is_Firing())) {
// Set our recoil timer and capture all of the necessary bones
// I'm copying all necessary data out of the weapon in case the weapon goes
// away before our recoil is finished.
RecoilTimer = weapon->Get_Recoil_Time();
RecoilScale = weapon->Get_Recoil_Scale();
if (RecoilTimer > 0.0f) {
RecoilScale *= 1.0f / RecoilTimer;
_TheRecoiler.Capture_Bones(HumanPhys->Peek_Model());
}
}
if (RecoilTimer > 0.0f) {
// Apply the recoil effect.
Matrix3D recoil_tm(1);
recoil_tm.Rotate_Z( HumanPhys->Get_Facing() );
recoil_tm.Rotate_Y( -AimingTilt );
float recoil_scale = RecoilScale * RecoilTimer;
_TheRecoiler.Apply_Recoil( recoil_tm,HumanPhys->Peek_Model(),recoil_scale);
// Decrement the recoil timer and release the bones if it expires
RecoilTimer -= TimeManager::Get_Frame_Seconds();
if (RecoilTimer <= 0.0f) {
RecoilTimer = 0.0f;
_TheRecoiler.Release_Bones(HumanPhys->Peek_Model());
}
}
}
void HumanStateClass::Set_State( HumanStateType state, int sub_state )
{
// Special case for death
if (( State == DEATH ) || ( State == DESTROY )) {
if ( state != DESTROY ) {
return;
}
}
if ( ( State != DEATH ) && ( state == DEATH ) ) {
StateLocked = false;
}
if ( StateLocked ) {
if ( state != DEATH ) {
// Temp Test
// Debug_Say(( "State is Locked. Can't change from %d to %d\n", State, state ));
// return;
}
#pragma MESSAGE( "StateLocked Hack" )
if ( !IS_SOLOPLAY ) { // E3 HACK
StateLocked = false;
}
}
if ( State == state && SubState == sub_state ) {
if (CombatManager::I_Am_Server()) {
Debug_Say(( "Already in this state\n" ));
}
return;
}
// Debug_Say(( "%p Set State %d, %x from %d\n", this, state, sub_state, State ));
State = state;
SubState = sub_state;
StateTimer = 0;
if (( State == LADDER ) || ( State == IN_VEHICLE ) ||
( State == TRANSITION ) || ( State == TRANSITION_COMPLETE ) ||
( State == DEBUG_FLY ) ) {
HumanPhys->Enable_User_Control( true );
} else {
HumanPhys->Enable_User_Control( false );
}
// Turn off shadows in vehicles
#pragma message ("(gth) shadow review hacking")
#if 0
if ( State == IN_VEHICLE ) {
HumanPhys->Enable_Shadow_Generation( false );
} else {
HumanPhys->Enable_Shadow_Generation( true );
}
#endif
if ( ( State == IN_VEHICLE ) || ( State == TRANSITION ) || ( State == TRANSITION_COMPLETE ) ) {
HumanPhys->Set_Collision_Group( BULLET_ONLY_COLLISION_GROUP );
HumanPhys->Set_Immovable( true );
} else if ( ( State == DESTROY ) || ( State == DEATH ) ) {
HumanPhys->Set_Collision_Group( TERRAIN_ONLY_COLLISION_GROUP );
HumanPhys->Set_Immovable( true );
} else {
HumanPhys->Set_Collision_Group( SOLDIER_COLLISION_GROUP );
HumanPhys->Set_Immovable( false );
}
Update_Animation();
}
bool HumanStateClass::Is_State_Interruptable( void )
{
return (State == UPRIGHT) || (State == WOUNDED) || (State == LAND) || (State == LOITER) || (State == ANIMATION);
}
#define ADD_CASE(exp) case exp: return #exp; break;
const char * HumanStateClass::Get_State_Name( void )
{
switch (State) {
ADD_CASE(UPRIGHT);
ADD_CASE(LAND);
ADD_CASE(ANIMATION);
ADD_CASE(WOUNDED);
ADD_CASE(LOITER);
ADD_CASE(AIRBORNE);
ADD_CASE(DIVE);
ADD_CASE(DEATH);
ADD_CASE(LADDER);
ADD_CASE(IN_VEHICLE);
ADD_CASE(TRANSITION);
ADD_CASE(TRANSITION_COMPLETE);
ADD_CASE(DESTROY);
ADD_CASE(DEBUG_FLY);
ADD_CASE(ON_FIRE);
ADD_CASE(ON_CHEM);
ADD_CASE(ON_ELECTRIC);
ADD_CASE(ON_CNC_FIRE);
ADD_CASE(ON_CNC_CHEM);
ADD_CASE(LOCKED_ANIMATION);
default:
WWASSERT(0);
return ""; // to avoid compiler warning
}
}
void HumanStateClass::Set_Sub_State( int sub_state )
{
if ( Is_Sub_State_Adjustable() ) {
if ( SubState != sub_state ) {
WWASSERT(sub_state >= 0 && sub_state <= HIGHEST_HUMAN_SUB_STATE);
SubState = sub_state;
Update_Animation();
}
} else {
Debug_Say(( "Can't adjust state %s", Get_State_Name() ));
}
}
bool HumanStateClass::Is_Sub_State_Adjustable( void )
{
return (State == UPRIGHT) || (State == LADDER);
}
void HumanStateClass::Start_Transition_Animation( const char * anim_name, bool blend )
{
if ( StateLocked ) {
Debug_Say(( "State is Locked. Can't Start Transition Anim %s\n", anim_name ));
return;
}
//Debug_Say(("Start_Transition_Animation %s\n", anim_name));
if (( Get_State() == DEATH ) || ( Get_State() == DESTROY ) ) {
return;
}
Set_State( TRANSITION );
float blend_time = blend ? 0.2 : 0;
AnimControl->Set_Animation( anim_name, blend_time );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
AnimControl->Update( 0 ); // update
StateLocked = true;
}
void HumanStateClass::Start_Scripted_Animation( const char * anim_name, bool blend, bool looping )
{
#if 0
if ( StateLocked ) {
Debug_Say(( "State is Locked. Can't Start Transition Anim %s\n", anim_name ));
return;
}
#endif
//Debug_Say(("Start_Scripted_Animation %s\n", anim_name));
// We used to not start a scripted anim when wounded, but then the scripts couldn't set
// up custom events well. So I am gonna try to remove the wounded check
// 8/17/01 Byon
// if (( Get_State() == DEATH ) || ( Get_State() == DESTROY ) || ( Get_State() == WOUNDED )) {
if (( Get_State() == DEATH ) || ( Get_State() == DESTROY ) ) {
return;
}
Set_State( ANIMATION );
float blend_time = blend ? 0.2 : 0;
AnimControl->Set_Animation( anim_name, blend_time );
AnimControl->Set_Mode( looping ? ANIM_MODE_LOOP : ANIM_MODE_ONCE );
AnimControl->Update( 0 ); // update
StateLocked = true;
}
void HumanStateClass::Stop_Scripted_Animation( void )
{
if ( State != ANIMATION && State != LOCKED_ANIMATION ) {
// Debug_Say(( "Not in a Scripted Animation to stop\n" ));
// Better clear the locked state. This was keeping us in the place beacon mode
StateLocked = false;
return;
}
StateLocked = false;
Set_State( UPRIGHT );
// AnimControl->Lock_Animation();
}
void HumanStateClass::Force_Animation( const char * anim_name, bool blend )
{
//Debug_Say(( "Forcing Animation to %s\n", anim_name ));
float blend_time = blend ? 0.2 : 0;
AnimControl->Set_Animation( anim_name, blend_time );
AnimControl->Update( 0 ); // update
}
/*
**
*/
typedef enum {
LEG_STYLE_STAND, // A0
LEG_STYLE_RUN_FORWARD, // A1
LEG_STYLE_RUN_BACKWARD, // A2
LEG_STYLE_RUN_LEFT, // A3
LEG_STYLE_RUN_RIGHT, // A4
LEG_STYLE_TURN_LEFT, // A5
LEG_STYLE_TURN_RIGHT, // A6
LEG_STYLE_WALK_FORWARD, // B1
LEG_STYLE_WALK_BACKWARD, // B2
LEG_STYLE_WALK_LEFT, // B3
LEG_STYLE_WALK_RIGHT, // B4
LEG_STYLE_CROUCH, // C0
LEG_STYLE_CROUCH_MOVE_FORWARD, // C1
LEG_STYLE_CROUCH_MOVE_BACKWARD, // C2
LEG_STYLE_CROUCH_MOVE_LEFT, // C3
LEG_STYLE_CROUCH_MOVE_RIGHT, // C4
LEG_STYLE_CROUCH_TURN_LEFT, // C3
LEG_STYLE_CROUCH_TURN_RIGHT, // C4
LEG_STYLE_JUMP_UP, // D0
LEG_STYLE_JUMP_FORWARD, // D1
LEG_STYLE_JUMP_BACKWARD, // D2
LEG_STYLE_JUMP_LEFT, // D3
LEG_STYLE_JUMP_RIGHT, // D4
} HUMAN_ANIM_LEG_STYLE;
static const char * LegAnimNames[] = {
"A0", // LEG_STYLE_STAND,
"A1", // LEG_STYLE_RUN_FORWARD,
"A2", // LEG_STYLE_RUN_BACKWARD,
"A3", // LEG_STYLE_RUN_LEFT,
"A4", // LEG_STYLE_RUN_RIGHT,
"A5", // LEG_STYLE_TURN_LEFT,
"A6", // LEG_STYLE_TURN_RIGHT,
"B1", // LEG_STYLE_WALK_FORWARD,
"B2", // LEG_STYLE_WALK_BACKWARD,
"B3", // LEG_STYLE_WALK_LEFT,
"B4", // LEG_STYLE_WALK_RIGHT,
"C0", // LEG_STYLE_CROUCH,
"C1", // LEG_STYLE_CROUCH_MOVE_FORWARD,
"C2", // LEG_STYLE_CROUCH_MOVE_BACKWARD,
"C3", // LEG_STYLE_CROUCH_MOVE_LEFT,
"C4", // LEG_STYLE_CROUCH_MOVE_RIGHT,
"C5", // LEG_STYLE_CROUCH_TURN_LEFT,
"C6", // LEG_STYLE_CROUCH_TURN_RIGHT,
"J0", // LEG_STYLE_JUMP_UP,
"J1", // LEG_STYLE_JUMP_FORWARD,
"J2", // LEG_STYLE_JUMP_BACKWARD,
"J3", // LEG_STYLE_JUMP_LEFT,
"J4", // LEG_STYLE_JUMP_RIGHT,
};
static const char * _weapon_style_names[ NUM_WEAPON_HOLD_STYLES ] = {
"A0", //WEAPON_HOLD_STYLE_C4 = 0,
"A0", //WEAPON_HOLD_STYLE_NOT_USED,
"C2", //WEAPON_HOLD_STYLE_AT_SHOULDER, // 2
"D2", //WEAPON_HOLD_STYLE_AT_HIP,
"E2", //WEAPON_HOLD_STYLE_LAUNCHER,
"F2", //WEAPON_HOLD_STYLE_HANDGUN,
"A0", //WEAPON_HOLD_STYLE_BEACON
"A0", //WEAPON_HOLD_STYLE_EMPTY_HANDS,
"B0", //WEAPON_HOLD_STYLE_AT_CHEST,
"A0", //WEAPON_HOLD_STYLE_HANDS_DOWN,
};
static const char * _dive_anims[ 4 * 2 ] = {
// Forwrd Anims
"S_A_HUMAN.H_A_SLD1_01",
"S_A_HUMAN.H_A_SLD1_02",
// Backward anims
"S_A_HUMAN.H_A_SLD2_01",
"S_A_HUMAN.H_A_SLD2_02",
// Left anims
"S_A_HUMAN.H_A_SLD3_01",
"S_A_HUMAN.H_A_SLD3_02",
// Right Anims
"S_A_HUMAN.H_A_SLD4_01",
"S_A_HUMAN.H_A_SLD4_02",
};
// Weapons style, weapon action, recoil, blend, vehicle, mix/math, aiming tilt
void HumanStateClass::Update_Animation( void )
{
WWPROFILE( "Human Animation" );
// no updates for visceroids
if ( AnimControl->Get_Skeleton() == 'V' ) {
StateLocked = true;
return;
}
if ( StateLocked ) {
// Debug_Say(( "ERROR: updating animation when locked\n" ));
return;
// if you change your animn when locked, death state may clear a scripted anim
}
int hold_style = WeaponHoldStyle;
// Setup animation for state, substate, weapon, tilt, etc.
if ( (State == UPRIGHT) || (State == AIRBORNE) ) {
// determine leg style
int leg_style = LEG_STYLE_STAND;
if ( State == AIRBORNE ) {
leg_style = LEG_STYLE_JUMP_UP;
if ( SubState & SUB_STATE_LEFT ) leg_style = LEG_STYLE_JUMP_LEFT;
if ( SubState & SUB_STATE_RIGHT ) leg_style = LEG_STYLE_JUMP_RIGHT;
if ( SubState & SUB_STATE_FORWARD ) leg_style = LEG_STYLE_JUMP_FORWARD;
if ( SubState & SUB_STATE_BACKWARD ) leg_style = LEG_STYLE_JUMP_BACKWARD;
} else {
if ( SubState & SUB_STATE_TURN_LEFT ) leg_style = LEG_STYLE_TURN_LEFT;
if ( SubState & SUB_STATE_TURN_RIGHT ) leg_style = LEG_STYLE_TURN_RIGHT;
if ( SubState & SUB_STATE_LEFT ) leg_style = LEG_STYLE_RUN_LEFT;
if ( SubState & SUB_STATE_RIGHT ) leg_style = LEG_STYLE_RUN_RIGHT;
if ( SubState & SUB_STATE_FORWARD ) leg_style = LEG_STYLE_RUN_FORWARD;
if ( SubState & SUB_STATE_BACKWARD ) leg_style = LEG_STYLE_RUN_BACKWARD;
if ( Get_State_Flag( CROUCHED_FLAG ) ) {
// Tend to hold at chest when crouched
if ( ( hold_style == WEAPON_HOLD_STYLE_HANDS_DOWN ) ||
( hold_style == WEAPON_HOLD_STYLE_C4 ) ||
( hold_style == WEAPON_HOLD_STYLE_BEACON ) ) {
hold_style = WEAPON_HOLD_STYLE_AT_CHEST;
}
leg_style += LEG_STYLE_CROUCH - LEG_STYLE_STAND;
} else if ( SubState & SUB_STATE_SLOW ) {
if ( ( leg_style >= LEG_STYLE_RUN_FORWARD ) &&
( leg_style <= LEG_STYLE_RUN_RIGHT ) ) {
leg_style += LEG_STYLE_WALK_FORWARD - LEG_STYLE_RUN_FORWARD;
}
}
}
const char * leg_anim_name = LegAnimNames[ leg_style ];
const char * torso_anim_name = _weapon_style_names[hold_style];
bool single_anim = true;
float blend_time = 0.2f;
if ( NoAnimBlend ) {
blend_time = 0;
NoAnimBlend = false;
}
if ( torso_anim_name[1] == '2' ) {
// Lets try aiming
StringClass anim1_name(0,true);
StringClass anim2_name(0,true);
StringClass anim3_name(0,true);
anim1_name.Format( "S_A_HUMAN.H_A_%c1%s", 'A' + hold_style, leg_anim_name );
anim2_name.Format( "S_A_HUMAN.H_A_%c2%s", 'A' + hold_style, leg_anim_name );
anim3_name.Format( "S_A_HUMAN.H_A_%c3%s", 'A' + hold_style, leg_anim_name );
// See if we have the tilting data
HAnimClass * anim = WW3DAssetManager::Get_Instance()->Get_HAnim( anim3_name );
if ( anim != NULL ) {
anim->Release_Ref();
single_anim = false;
float tilt_blend = WWMath::Clamp( (AimingTilt / DEG_TO_RADF( 65 )), -1, 1 );
float frame = AnimControl->Get_Frame(); // Maintain the frame number for moving
if ( tilt_blend < 0 ) {
AnimControl->Set_Animation( anim1_name, anim2_name, 1+tilt_blend, blend_time );
} else {
AnimControl->Set_Animation( anim3_name, anim2_name, 1-tilt_blend, blend_time );
}
AnimControl->Set_Mode( ANIM_MODE_LOOP, frame );
}
}
if ( single_anim ) {
StringClass anim_name(0,true);
anim_name.Format( "S_A_HUMAN.H_A_%s%s", torso_anim_name, leg_anim_name );
// Human Anim Override
if ( HumanAnimOverride != NULL ) {
if ( hold_style == WEAPON_HOLD_STYLE_EMPTY_HANDS ) {
if ( leg_style == LEG_STYLE_RUN_FORWARD ) {
anim_name = HumanAnimOverride->RunEmptyHands;
}
if ( leg_style == LEG_STYLE_WALK_FORWARD ) {
anim_name = HumanAnimOverride->WalkEmptyHands;
}
}
if ( hold_style == WEAPON_HOLD_STYLE_AT_CHEST ) {
if ( leg_style == LEG_STYLE_RUN_FORWARD ) {
anim_name = HumanAnimOverride->RunAtChest;
}
if ( leg_style == LEG_STYLE_WALK_FORWARD ) {
anim_name = HumanAnimOverride->WalkAtChest;
}
}
if ( hold_style == WEAPON_HOLD_STYLE_AT_HIP ) {
if ( leg_style == LEG_STYLE_RUN_FORWARD ) {
anim_name = HumanAnimOverride->RunAtHip;
}
if ( leg_style == LEG_STYLE_WALK_FORWARD ) {
anim_name = HumanAnimOverride->WalkAtHip;
}
}
}
// Saftey check anim
// Debug_Say(( "Anim name %s\n", (const char *)anim_name ));
// float frame = AnimControl->Get_Frame(); // Maintain the frame number for moving
AnimControl->Set_Animation( anim_name, blend_time );
// AnimControl->Set_Mode( ANIM_MODE_LOOP, frame );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
}
} else if ( State == DIVE ) {
const char * anim_name = NULL;
#if 0
if ( SubState & SUB_STATE_LEFT ) anim_name = "S_A_HUMAN.H_A_DIV3";
if ( SubState & SUB_STATE_RIGHT ) anim_name = "S_A_HUMAN.H_A_DIV4";
if ( SubState & SUB_STATE_FORWARD ) anim_name = "S_A_HUMAN.H_A_DIV1";
if ( SubState & SUB_STATE_BACKWARD ) anim_name = "S_A_HUMAN.H_A_DIV2";
#else
int offset = FreeRandom.Get_Int( 2 );
if ( !IS_SOLOPLAY ) {
offset = 0;
}
if ( SubState & SUB_STATE_FORWARD ) offset += 0;
if ( SubState & SUB_STATE_BACKWARD ) offset += 2;
if ( SubState & SUB_STATE_LEFT ) offset += 4;
if ( SubState & SUB_STATE_RIGHT ) offset += 6;
anim_name = _dive_anims[offset];
#endif
AnimControl->Set_Animation( anim_name, 0.2f );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
StateLocked = true;
} else if ( State == LAND ) {
int dir = 0;
if ( SubState & SUB_STATE_LEFT ) dir = 3;
if ( SubState & SUB_STATE_RIGHT ) dir = 4;
if ( SubState & SUB_STATE_FORWARD ) dir = 1;
if ( SubState & SUB_STATE_BACKWARD ) dir = 2;
StringClass anim_name(0,true);
anim_name.Format( "S_A_HUMAN.H_A_A0L%d", dir );
AnimControl->Set_Animation( anim_name, 0.2f );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
} else if ( State == WOUNDED ) {
AnimControl->Set_Animation( Get_Wound_Anim( SubState ), 0.2f );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
} else if ( State == DEATH ) {
AnimControl->Set_Animation( Get_Death_Anim( SubState ), 0.2f );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
StateLocked = true;
} else if ( State == LADDER ) {
const char * anim_name = "S_A_HUMAN.H_A_412A";
if ( SubState & SUB_STATE_UP ) anim_name = "S_A_HUMAN.H_A_422A";
if ( SubState & SUB_STATE_DOWN ) anim_name = "S_A_HUMAN.H_A_432A";
AnimControl->Set_Animation( anim_name, 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == ANIMATION ) {
} else if ( State == LOITER ) {
} else if ( State == DESTROY ) {
} else if ( State == TRANSITION ) {
} else if ( State == TRANSITION_COMPLETE ) {
} else if ( State == ON_FIRE ) {
AnimControl->Set_Animation( "S_A_HUMAN.H_A_FLMA", 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == ON_CHEM ) {
AnimControl->Set_Animation( "S_A_HUMAN.h_a_6x01", 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == ON_CNC_FIRE ) {
AnimControl->Set_Animation( "S_A_HUMAN.H_A_FLMA", 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == ON_CNC_CHEM ) {
AnimControl->Set_Animation( "S_A_HUMAN.h_a_6x01", 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == ON_ELECTRIC ) {
AnimControl->Set_Animation( "S_A_HUMAN.h_a_6x05", 0.2f );
AnimControl->Set_Mode( ANIM_MODE_LOOP );
} else if ( State == DEBUG_FLY ) {
} else {
Debug_Say(( "Uncoded Human State %d\n", State ));
AnimControl->Set_Animation( (const char *)NULL );
}
}
#define MOVING_THRESHHOLD 0.2
//#define WALKING_THRESHHOLD 4.5
#define WALKING_THRESHHOLD 3.21f
void HumanStateClass::Reset_Loiter_Delay( void )
{
LoiterDelay = FreeRandom.Get_Float( 6 ) - 3;
}
// Must deal with LAND, ANIMATIONS, DEATH, WOUNDS, TRANSITIONS, JUMP, DEATH FALLS, LADDER
void HumanStateClass::Update_State( void )
{
WWPROFILE( "Human State" );
StateTimer += TimeManager::Get_Frame_Seconds();
if ( AnimControl && AnimControl->Get_Skeleton() == 'V' ) {
LoitersAllowed = false;
}
if ( State == UPRIGHT && LoitersAllowed ) {
// Don't loiter when crouched or moving
if ( SubState != 0 ) {
Reset_Loiter_Delay();
}
LoiterDelay += TimeManager::Get_Frame_Seconds();
HumanLoiterGlobalSettingsDef * loiter_def = HumanLoiterCollection;
if ( loiter_def == NULL ) {
loiter_def = HumanLoiterGlobalSettingsDef::Get_Default_Loiters();
}
#if 0
// loiter based on holding a weapon
if ( WeaponHoldStyle == WEAPON_HOLD_STYLE_EMPTY_HANDS ) {
loiter_def = HumanLoiterGlobalSettingsDef::Get_Weaponless_Loiters();
} else {
loiter_def = HumanLoiterGlobalSettingsDef::Get_Weapon_Loiters();
}
#endif
if ( loiter_def != NULL ) {
if ( LoiterDelay > loiter_def->Get_Activation_Delay() ) {
Set_State( LOITER, Get_Sub_State() );
StringClass anim(loiter_def->Pick_Animation(),true);
// Debug_Say(( "Start loiter %s\n", anim ));
if ( !anim.Is_Empty() ) {
StringClass new_anim(true);
::Strip_Path_From_Filename( new_anim, anim );
// remove the .W3D
if ( new_anim.Get_Length() >= 5 ) {
new_anim.Erase( new_anim.Get_Length()-4, 4 );
}
AnimControl->Set_Animation( new_anim, 0.2f );
AnimControl->Set_Mode( ANIM_MODE_ONCE );
AnimControl->Update( 0 ); // update
}
}
} else {
Debug_Say(( "Failed to find Loiter Def\n" ));
}
} else {
Reset_Loiter_Delay();
}
// Get out of locked states
if ( AnimControl->Is_Complete() ) { // Time to unlock
// if ( StateLocked && State != LOCKED_ANIMATION ) {
if ( (StateLocked && State != LOCKED_ANIMATION) || (State == DEATH) ) {
StateLocked = false;
if ( State == DIVE ) {
Set_State( UPRIGHT );
} else if ( State == ANIMATION ) {
Set_State( UPRIGHT );
} else if ( State == DEATH ) {
Set_State( DESTROY );
TransitionEffectClass * effect = CombatMaterialEffectManager::Get_Death_Effect();
this->HumanPhys->Add_Effect_To_Me(effect);
REF_PTR_RELEASE(effect);
} else if ( State == TRANSITION ) {
Set_State( TRANSITION_COMPLETE );
} else if ( State != LOCKED_ANIMATION ) {
Debug_Say(( "Unsupported locked state %s\n", Get_State_Name() ));
}
} else {
// Debug_Say(( "Anim Complete %s\n", Get_State_Name() ));
if ( State == LOITER ) {
Set_State( UPRIGHT );
} else if ( State == LAND ) {
Set_State( UPRIGHT, Get_Sub_State() );
} else if ( State == WOUNDED ) {
Set_State( UPRIGHT );
}
}
}
/*
** Handle Jump and landing
*/
if ( !HumanPhys->Is_In_Contact() ) { // If I am not in contact with the ground
if ( State == UPRIGHT ) { // If I am currently UPRIGHT
Begin_Jump(); // Begin a jump
}
} else if ( State == AIRBORNE ) { // If I am in contact, and in the , I just landed
Complete_Jump(); // So complete the jump
}
if ( WeaponHoldTimer > 0 && !Get_State_Flag( CROUCHED_FLAG ) ) {
Reset_Loiter_Delay();
WeaponHoldTimer -= TimeManager::Get_Frame_Seconds();
if ( WeaponHoldTimer <= 0 ) {
if ( WeaponHoldStyle == WEAPON_HOLD_STYLE_HANDGUN ||
WeaponHoldStyle == WEAPON_HOLD_STYLE_C4 ||
WeaponHoldStyle == WEAPON_HOLD_STYLE_BEACON )
{
WeaponHoldStyle = WEAPON_HOLD_STYLE_HANDS_DOWN; // Lower the weapon
} else {
WeaponHoldStyle = WEAPON_HOLD_STYLE_AT_CHEST; // Lower the weapon
}
Update_Animation();
}
}
}
/*
**
*/
void HumanStateClass::Post_Think( void )
{
// Update sub_state per movement
// do it for upright, land, ladder, airborne,
if ( Is_Sub_State_Adjustable() || Is_State_Interruptable() ) {
// Update the SubState
int new_sub_state = 0;
// Get our current move vector
Vector3 move_vector;
HumanPhys->Get_Animation_Move( &move_vector );
if ( TimeManager::Get_Frame_Seconds() > 0 ) {
move_vector /= TimeManager::Get_Frame_Seconds();
}
move_vector = HumanPhys->Get_Transform().Inverse_Rotate_Vector( move_vector );
// When walking running diagonally, use forward/backward legs.
// Unless you are crouched, then use straffe legs
float direction_ratio = 0.75f;
if ( Get_State_Flag( CROUCHED_FLAG ) ) {
direction_ratio = 2;
}
// Convert to SubMode
if ( WWMath::Fabs( move_vector[0] ) > direction_ratio * WWMath::Fabs( move_vector[1] ) ) {
if ( move_vector[0] > MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_FORWARD;
else if ( move_vector[0] < -MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_BACKWARD;
} else {
if ( move_vector[1] > MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_LEFT;
else if ( move_vector[1] < -MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_RIGHT;
}
if ( new_sub_state == 0 ) {
if ( move_vector[2] > MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_UP;
else if ( move_vector[2] < -MOVING_THRESHHOLD ) new_sub_state |= SUB_STATE_DOWN;
}
if ( new_sub_state != 0 ) {
if ( move_vector.Length() < WALKING_THRESHHOLD ) new_sub_state |= SUB_STATE_SLOW;
//Debug_Say(( "%f %f\n", move_vector.Length(), WALKING_THRESHHOLD ));
}
#if 0 // No turn anims!!!
// Get our current turn vector
if ( TurnVelocity > 0 ) new_sub_state |= SUB_STATE_TURN_LEFT;
else if ( TurnVelocity < 0 ) new_sub_state |= SUB_STATE_TURN_RIGHT;
TurnVelocity = 0;
#endif
// Get him out of WOUNDED, LAND, LOITER states if moving or shooting
if ( Is_State_Interruptable() && Get_State() != UPRIGHT ) {
// if ( new_sub_state != 0 || WeaponState > WeaponClass::STATE_READY ) {
if ( new_sub_state != 0 || WeaponFired ) {
if ( Get_State() == LAND && Get_Sub_State() == new_sub_state ) {
// don't interrupt lands for the same direction
} else {
// Debug_Say(( "Interrupt State %s\n", Get_State_Name() ));
Set_State( UPRIGHT );
}
}
}
if ( Is_Sub_State_Adjustable() ) {
if ( new_sub_state != Get_Sub_State() ) {
Set_Sub_State( (HumanSubStateType)new_sub_state );
}
#if 0 // Disable all leg twisting
// =================================================================== // LEG TWIST!!!!!
// Don't leg twist for crouched
if ( Get_State() == UPRIGHT && !Get_State_Flag( CROUCHED_FLAG ) ) {
float legs_rotation = 0;
// Compare the facing to the motion, set leg_racing to the difference
if ( move_vector.Length() > 0 ) {
float move_direction = WWMath::Atan2( -move_vector.Y, move_vector.X );
if ( new_sub_state & SUB_STATE_FORWARD ) {
legs_rotation = -move_direction;
} else if ( new_sub_state & SUB_STATE_BACKWARD ) {
legs_rotation = -move_direction + DEG_TO_RAD( 180 );
} else if ( new_sub_state & SUB_STATE_LEFT ) {
legs_rotation = -move_direction + DEG_TO_RAD( 270 );
} else if ( new_sub_state & SUB_STATE_RIGHT ) {
legs_rotation = -move_direction + DEG_TO_RAD( 90 );
}
legs_rotation = WWMath::Wrap( legs_rotation, DEG_TO_RADF( -180 ), DEG_TO_RADF( 180 ) );
// legs_rotation = WWMath::Clamp( legs_rotation, DEG_TO_RADF( -45 ), DEG_TO_RADF( 45 ) );
legs_rotation = WWMath::Clamp( legs_rotation, DEG_TO_RADF( -30 ), DEG_TO_RADF( 30 ) );
if ( WWMath::Fabs( legs_rotation ) < DEG_TO_RAD( 25 ) ) {
legs_rotation = 0;
}
}
// Move LegRotation toward leg_rotation
float rot_diff = legs_rotation - LegRotation;
float max_mov = DEG_TO_RAD( 180 ) * TimeManager::Get_Frame_Seconds();
// float max_mov = DEG_TO_RAD( 90 ) * TimeManager::Get_Frame_Seconds();
rot_diff = WWMath::Clamp( rot_diff, -max_mov, max_mov );
LegRotation += rot_diff;
legs_rotation = LegRotation;
// I'm making this staic for now, because all human
// skeletons have the bone at the same index
static int root_bone = -1;
if ( root_bone == -1 ) { // Get root bone index
root_bone = HumanPhys->Peek_Model()->Get_Bone_Index( "c spine" );
}
static int torso_bone = -1;
if ( torso_bone == -1 ) { // Get torso bone index
torso_bone = HumanPhys->Peek_Model()->Get_Bone_Index( "c spine1" );
}
if ( legs_rotation != 0 ) {
WWASSERT( root_bone != -1 );
WWASSERT( torso_bone != -1 );
if ( !HumanPhys->Peek_Model()->Is_Bone_Captured( root_bone ) ) {
HumanPhys->Peek_Model()->Capture_Bone( root_bone );
}
if ( !HumanPhys->Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
HumanPhys->Peek_Model()->Capture_Bone( torso_bone );
}
Matrix3D root_adjust(1); // adjust it
root_adjust.Rotate_X( legs_rotation );
HumanPhys->Peek_Model()->Control_Bone( root_bone, root_adjust );
Matrix3D legs_adjust(1); // adjust it
legs_adjust.Rotate_X( -legs_rotation );
HumanPhys->Peek_Model()->Control_Bone( torso_bone, legs_adjust );
} else { // no adjustment, release
if ( HumanPhys->Peek_Model()->Is_Bone_Captured( root_bone ) ) {
HumanPhys->Peek_Model()->Release_Bone( root_bone );
}
if ( HumanPhys->Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
HumanPhys->Peek_Model()->Release_Bone( torso_bone );
}
}
}
#endif
}
// Scale animation speed
float ideal_speed = 0;
if ( !(new_sub_state & SUB_STATE_SLOW) ) {
if ( new_sub_state & SUB_STATE_FORWARD ) ideal_speed = 5.5f;
if ( new_sub_state & SUB_STATE_BACKWARD ) ideal_speed = 4.5f;
if ( new_sub_state & SUB_STATE_LEFT ) ideal_speed = 4.5f;
if ( new_sub_state & SUB_STATE_RIGHT ) ideal_speed = 5.5f;
} else {
if ( new_sub_state & SUB_STATE_FORWARD ) ideal_speed = 1.6f;
if ( new_sub_state & SUB_STATE_BACKWARD ) ideal_speed = 1.5f;
if ( new_sub_state & SUB_STATE_LEFT ) ideal_speed = 1.5f;
if ( new_sub_state & SUB_STATE_RIGHT ) ideal_speed = 1.6f;
}
if ( State == LADDER ) {
if ( new_sub_state & SUB_STATE_UP ) ideal_speed = 0.15f;
if ( new_sub_state & SUB_STATE_DOWN ) ideal_speed = 0.15f;
}
// Turning is at speed 1
bool turning = ( new_sub_state & (SUB_STATE_TURN_LEFT | SUB_STATE_TURN_RIGHT ) &&
!( new_sub_state & (SUB_STATE_FORWARD | SUB_STATE_BACKWARD )));
if ( !turning && ideal_speed != 0 ) {
// Get Anim_Speed_Scale
Vector3 vel;
HumanPhys->Get_Animation_Move( &vel );
if ( TimeManager::Get_Frame_Seconds() > 0 ) {
vel /= TimeManager::Get_Frame_Seconds();
}
float speed = WWMath::Clamp( vel.Length() / ideal_speed, 0.33f, 3 );
AnimControl->Set_Anim_Speed_Scale( speed );
} else {
AnimControl->Set_Anim_Speed_Scale( 1 );
}
HumanPhys->Reset_Animation_Move();
}
}
/*
**
*/
bool HumanStateClass::Get_Leg_Mode( void )
{
return AnimControl->Get_Progress() > 0.5f;
}
/*
**
*/
struct BoneToOuchType {
const char * bone_name;
int ouch_type;
};
BoneToOuchType _BoneToOuchTypeList[] = {
{ "K_HEAD", HumanStateClass::HEAD_FROM_BEHIND },
{ "K_NECK", HumanStateClass::HEAD_FROM_BEHIND },
{ "K_CHEST", HumanStateClass::HEAD_FROM_BEHIND },
{ "K_ABDOMEN", HumanStateClass::TORSO_FROM_BEHIND },
{ "K_PELVIS", HumanStateClass::GROIN },
{ "K_L THIGH", HumanStateClass::LEFT_LEG_FROM_BEHIND },
{ "K_L CALF", HumanStateClass::LEFT_LEG_FROM_BEHIND },
{ "K_L FOOT", HumanStateClass::LEFT_LEG_FROM_BEHIND },
{ "K_L HAND", HumanStateClass::LEFT_ARM_FROM_BEHIND },
{ "K_L FOREARM", HumanStateClass::LEFT_ARM_FROM_BEHIND },
{ "K_L UPPERARM", HumanStateClass::LEFT_ARM_FROM_BEHIND },
{ "K_R THIGH", HumanStateClass::RIGHT_LEG_FROM_BEHIND },
{ "K_R CALF", HumanStateClass::RIGHT_LEG_FROM_BEHIND },
{ "K_R FOOT", HumanStateClass::RIGHT_LEG_FROM_BEHIND },
{ "K_R HAND", HumanStateClass::RIGHT_ARM_FROM_BEHIND },
{ "K_R FOREARM", HumanStateClass::RIGHT_ARM_FROM_BEHIND },
{ "K_R UPPERARM", HumanStateClass::RIGHT_ARM_FROM_BEHIND },
};
#define BONE_LIST_COUNT ( sizeof(_BoneToOuchTypeList) / sizeof(_BoneToOuchTypeList[0]) )
int HumanStateClass::Get_Ouch_Type( const Vector3 & direction, const char * collision_box_name )
{
// Initialize ouch_type to a default value
int ouch_type = TORSO_FROM_FRONT;
const char * base_name = NULL;
if ( collision_box_name != NULL ) {
base_name = ::strchr( collision_box_name, '.' );
} else {
return ouch_type;
}
if ( base_name != NULL ) {
base_name++;
for ( int i = 0; i < BONE_LIST_COUNT; i++ ) {
if ( ::strcmp( _BoneToOuchTypeList[i].bone_name, base_name ) == 0 ) {
ouch_type = _BoneToOuchTypeList[i].ouch_type;
}
}
}
if ( ouch_type != -1 ) {
// Set direction
Vector3 relative_direction = HumanPhys->Get_Transform().Inverse_Rotate_Vector( direction );
if ( ouch_type != HumanStateClass::GROIN ) { // but not for the groin shot
if ( relative_direction.X < 0 ) {
ouch_type += 1;
}
}
} else {
Debug_Say(( "Bad human collision box name %s\n", collision_box_name ));
}
return ouch_type;
}
/*
**
*/
const char * _WoundAnims[] =
{
"S_A_HUMAN.H_A_811A", // HEAD_FROM_BEHIND,
"S_A_HUMAN.H_A_812A", // HEAD_FROM_FRONT,
"S_A_HUMAN.H_A_821A", // TORSO_FROM_BEHIND,
"S_A_HUMAN.H_A_822A", // TORSO_FROM_FRONT,
"S_A_HUMAN.H_A_831A", // LEFT_ARM_FROM_BEHIND,
"S_A_HUMAN.H_A_832A", // LEFT_ARM_FROM_FRONT,
"S_A_HUMAN.H_A_841A", // RIGHT_ARM_FROM_BEHIND,
"S_A_HUMAN.H_A_842A", // RIGHT_ARM_FROM_FRONT,
"S_A_HUMAN.H_A_851A", // LEFT_LEG_FROM_BEHIND,
"S_A_HUMAN.H_A_852A", // LEFT_LEG_FROM_FRONT,
"S_A_HUMAN.H_A_861A", // RIGHT_LEG_FROM_BEHIND,
"S_A_HUMAN.H_A_862A", // RIGHT_LEG_FROM_FRONT,
"S_A_HUMAN.H_A_871A", // GROIN,
};
const char * HumanStateClass::Get_Wound_Anim( int ouch_type )
{
return _WoundAnims[ ouch_type ];
}
/*
**
*/
const char * _DeathAnims[] =
{
"S_A_HUMAN.H_A_622A", // HEAD_FROM_BEHIND,
"S_A_HUMAN.H_A_635A", // HEAD_FROM_FRONT,
"S_A_HUMAN.H_A_622A", // TORSO_FROM_BEHIND,
"S_A_HUMAN.H_A_632A", // TORSO_FROM_FRONT,
"S_A_HUMAN.H_A_623A", // LEFT_ARM_FROM_BEHIND,
"S_A_HUMAN.H_A_634A", // LEFT_ARM_FROM_FRONT,
"S_A_HUMAN.H_A_624A", // RIGHT_ARM_FROM_BEHIND,
"S_A_HUMAN.H_A_633A", // RIGHT_ARM_FROM_FRONT,
"S_A_HUMAN.H_A_623A", // LEFT_LEG_FROM_BEHIND,
"S_A_HUMAN.H_A_634A", // LEFT_LEG_FROM_FRONT,
"S_A_HUMAN.H_A_624A", // RIGHT_LEG_FROM_BEHIND,
"S_A_HUMAN.H_A_633A", // RIGHT_LEG_FROM_FRONT,
"S_A_HUMAN.H_A_612A", // GROIN,
"S_A_HUMAN.H_A_FLMB", // ON_FIRE,
"S_A_HUMAN.H_A_FLMB", // ON_CHEM,
"S_A_HUMAN.H_A_FLMB", // ON_ELECTRIC,
"S_A_HUMAN.H_A_FLMB", // ON_CNC_FIRE,
"S_A_HUMAN.H_A_FLMB", // ON_CNC_CHEM,
};
const char * HumanStateClass::Get_Death_Anim( int ouch_type )
{
WWASSERT( ouch_type <= OUCH_SUPER_FIRE );
return _DeathAnims[ ouch_type ];
}
/*
**
*/
void HumanStateClass::Set_Precision(void)
{
cEncoderList::Set_Precision(BITPACK_HUMAN_STATE, 0, (int) HIGHEST_HUMAN_STATE);
cEncoderList::Set_Precision(BITPACK_HUMAN_SUB_STATE, 0, (int) HIGHEST_HUMAN_SUB_STATE);
}
/*
**
*/
void HumanStateClass::Get_Information( StringClass & string )
{
StringClass temp(0,true);
temp.Format( "%s\n", Get_State_Name() );
string += temp;
AnimControl->Get_Information( string );
}
/*
** Begin_Jump is called when we first become airborne
*/
void HumanStateClass::Begin_Jump( void )
{
// Store some information about the jump
JumpTM = HumanPhys->Get_Transform();
// Set my state to Jump, with a direction of my current relative velocity
Vector3 move_vector;
HumanPhys->Get_Velocity( &move_vector );
move_vector = HumanPhys->Get_Transform().Inverse_Rotate_Vector( move_vector );
int sub_state = 0;
if ( move_vector[0] > MOVING_THRESHHOLD ) sub_state |= SUB_STATE_FORWARD;
else if ( move_vector[0] < -MOVING_THRESHHOLD ) sub_state |= SUB_STATE_BACKWARD;
if ( move_vector[1] > MOVING_THRESHHOLD ) sub_state |= SUB_STATE_LEFT;
else if ( move_vector[1] < -MOVING_THRESHHOLD ) sub_state |= SUB_STATE_RIGHT;
Set_State( AIRBORNE, sub_state );
// Whenever a jump starts, play a jump surface effect
Matrix3D tm = HumanPhys->Get_Transform();
int ground_type = HumanPhys->Get_Contact_Surface_Type();
SurfaceEffectsManager::Apply_Effect( ground_type, SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_JUMP, tm );
}
/*
** Complete_Jump is called when we land
*/
void HumanStateClass::Complete_Jump( void )
{
Vector3 fall = JumpTM.Get_Translation() - HumanPhys->Get_Transform().Get_Translation();
GlobalSettingsDef * settings = GlobalSettingsDef::Get_Global_Settings();
// Debug_Say(( "Fall Distance %f\n", fall.Z ));
bool add_portal = true;
//
// Don't do this in the level editor
//
#ifndef PARAM_EDITING_ON
if ( fall.Z > settings->Get_Falling_Damage_Min_Distance() ) {
add_portal = false;
float scale = (fall.Z - settings->Get_Falling_Damage_Min_Distance()) /
(settings->Get_Falling_Damage_Max_Distance() - settings->Get_Falling_Damage_Min_Distance());
scale = WWMath::Clamp( scale, 0, 1 );
// (gth) don't take damage when falling onto an elevator (because we have
// super-fast elevators...)
if ( (HumanPhys->Peek_Ground_Object() != NULL) &&
(HumanPhys->Peek_Ground_Object()->As_ElevatorPhysClass() != NULL))
{
Debug_Say(( "Fell onto an elevator, no damage!\n", scale ));
scale = 0.0f;
}
Debug_Say(( "Fall Damage Scale %f\n", scale ));
SoldierGameObj * owner = (SoldierGameObj *)HumanPhys->Get_Observer();
if ( owner != NULL ) {
DefenseObjectClass * defense = owner->Get_Defense_Object();
float damage = defense->Get_Health_Max();
// AI's get notified
// if ( !owner->Is_Human_Controlled() ) {
const GameObjObserverList & observer_list = owner->Get_Observers();
for( int index = 0; index < observer_list.Count(); index++ ) {
observer_list[ index ]->Custom( owner, CUSTOM_EVENT_FALLING_DAMAGE, damage*scale, NULL );
}
// }
// All get the damage
OffenseObjectClass offense( damage, settings->Get_Falling_Damage_Warhead(), NULL );
owner->Apply_Damage_Extended( offense, scale, fall, NULL );
}
}
#endif // PARAM_EDITING_ON
// Find the sector the human jumped from and the sector the human jumped to.
/*Vector3 curr_pos = HumanPhys->Get_Position ();
PathfindSectorClass *start_sector = PathfindClass::Get_Instance ()->Find_Sector (JumpTM.Get_Translation (), 2.0F);
PathfindSectorClass *end_sector = PathfindClass::Get_Instance ()->Find_Sector (curr_pos, 2.0F);
// Make a temporary pathfind connection between these sectors (if necessary)
if (add_portal && start_sector != NULL && end_sector != NULL && start_sector != end_sector) {
PathfindClass::Get_Instance ()->Add_Temporary_Portal (start_sector, end_sector, JumpTM.Get_Translation (), curr_pos);
}*/
// Set me state to Land, with a direction of my current velocity
Vector3 move_vector;
HumanPhys->Get_Velocity( &move_vector );
move_vector = HumanPhys->Get_Transform().Inverse_Rotate_Vector( move_vector );
int sub_state = 0;
if ( move_vector[0] > MOVING_THRESHHOLD ) sub_state |= SUB_STATE_FORWARD;
else if ( move_vector[0] < -MOVING_THRESHHOLD ) sub_state |= SUB_STATE_BACKWARD;
if ( move_vector[1] > MOVING_THRESHHOLD ) sub_state |= SUB_STATE_LEFT;
else if ( move_vector[1] < -MOVING_THRESHHOLD ) sub_state |= SUB_STATE_RIGHT;
Set_State( LAND, sub_state );
// Whenever a jump ends, play a land surface effect
Matrix3D tm = HumanPhys->Get_Transform();
int ground_type = HumanPhys->Get_Contact_Surface_Type();
SurfaceEffectsManager::Apply_Effect( ground_type, SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_LAND, tm );
}
Reference in a new issue Copy permalink