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/soldier.cpp

5309 lines
152 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/soldier.cpp $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 3/29/02 4:58p $*
* *
* $Revision:: 570 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "soldier.h"
#include "debug.h"
#include "pscene.h"
#include "combat.h"
#include "weapons.h"
#include "damage.h"
#include "humanphys.h"
#include "animcontrol.h"
#include "rendobj.h"
#include "wwpacket.h"
#include "assets.h"
#include "gameobjmanager.h"
#include "vehicle.h"
#include "c4.h"
#include "objlibrary.h"
#include "physicalgameobj.h"
#include "persistfactory.h"
#include "combatchunkid.h"
#include "definition.h"
#include "simpledefinitionfactory.h"
#include "wwhack.h"
#include "surfaceeffects.h"
#include "weaponmanager.h"
#include "weaponbag.h"
#include "physcoltest.h"
#include "htree.h"
#include "animobj.h"
#include "wwaudio.h"
#include "soldierobserver.h"
#include "playertype.h"
#include "crandom.h"
#include "ccamera.h"
#include "bitpackids.h"
#include "translatedb.h"
#include "translateobj.h"
#include "hlod.h"
#include "audiblesound.h"
#include "wwprofile.h"
#include "globalsettings.h"
#include "colors.h"
#include "input.h"
#include "gametype.h"
#include "messagewindow.h"
#include "conversationmgr.h"
#include "activeconversation.h"
#include "bones.h"
#include "dynamicspeechanim.h"
#include "hudinfo.h"
#include "powerup.h"
#include "diaglog.h"
#include "vistable.h"
#include "crandom.h"
#include "transitioneffect.h"
#include "combatmaterialeffectmanager.h"
#include "explosion.h"
#include "playerdata.h"
#include "encyclopediamgr.h"
#include "apppackettypes.h"
#include "hud.h"
#include "unitcoordinationzonemgr.h"
#include "specialbuilds.h"
#include "weaponview.h"
#include "ffactory.h"
#include "realcrc.h"
/*
**
*/
#define GUN_BONE_NAME "GUNBONE"
#define BACK_GUN_BONE_NAME "BACKGUNBONE"
#define POKE_ANGLE DEG_TO_RAD( 22 )
#define AMBUSH_DAMAGE_SCALE 1
const float EMOT_ICON_HEIGHT = 2.0F;
/*
** SoldierGameObjDef
*/
DECLARE_FORCE_LINK( Soldier )
SimplePersistFactoryClass<SoldierGameObjDef, CHUNKID_GAME_OBJECT_DEF_SOLDIER> _SoldierGameObjDefPersistFactory;
DECLARE_DEFINITION_FACTORY(SoldierGameObjDef, CLASSID_GAME_OBJECT_DEF_SOLDIER, "Soldier") _SoldierGameObjDefDefFactory;
SoldierGameObjDef::SoldierGameObjDef( void ) :
TurnRate( DEG_TO_RADF( 360.0f ) ),
JumpVelocity( 2 ),
SkeletonHeight( 0 ),
SkeletonWidth( 0 ),
UseInnateBehavior( true ),
InnateAggressiveness( 0.5f ),
InnateTakeCoverProbability( 0.5f ),
InnateIsStationary( false ),
HumanAnimOverrideDefID( 0 ),
HumanLoiterCollectionDefID( 0 ),
DeathSoundPresetID( 0 )
{
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_ANGLE, TurnRate );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FLOAT, JumpVelocity );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FLOAT, SkeletonHeight );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FLOAT, SkeletonWidth );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_BOOL, UseInnateBehavior );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FLOAT, InnateAggressiveness );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FLOAT, InnateTakeCoverProbability );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_BOOL, InnateIsStationary );
EDITABLE_PARAM( SoldierGameObjDef, ParameterClass::TYPE_FILENAME, FirstPersonHands );
GENERIC_DEFID_PARAM( SoldierGameObjDef, HumanAnimOverrideDefID, CLASSID_GLOBAL_SETTINGS_DEF_HUMAN_ANIM_OVERRIDE );
GENERIC_DEFID_PARAM( SoldierGameObjDef, HumanLoiterCollectionDefID, CLASSID_GLOBAL_SETTINGS_DEF_HUMAN_LOITER );
GENERIC_DEFID_PARAM( SoldierGameObjDef, DeathSoundPresetID, CLASSID_SOUND );
MODEL_DEF_PARAM( SoldierGameObjDef, PhysDefID, "HumanPhysDef" );
//
// We want soldiers to use innate conversations by default
//
AllowInnateConversations = true;
return ;
}
uint32 SoldierGameObjDef::Get_Class_ID (void) const
{
return CLASSID_GAME_OBJECT_DEF_SOLDIER;
}
PersistClass * SoldierGameObjDef::Create( void ) const
{
SoldierGameObj * obj = new SoldierGameObj;
obj->Init( *this );
return obj;
}
enum {
CHUNKID_DEF_PARENT = 909991656,
CHUNKID_DEF_VARIABLES,
CHUNKID_DEF_DIALOG_ENTRY,
MICROCHUNKID_DEF_TURN_RATE = 1,
MICROCHUNKID_DEF_JUMP_VELOCITY,
MICROCHUNKID_DEF_SKELETON_HEIGHT,
MICROCHUNKID_DEF_SKELETON_WIDTH,
MICROCHUNKID_DEF_USE_INNATE_BEHAVIOR,
MICROCHUNKID_DEF_INNATE_AGGRESSIVENESS,
MICROCHUNKID_DEF_INNATE_TAKE_COVER_PROB,
XXXMICROCHUNKID_DEF_INNATE_ESCORT_ID,
XXXMICROCHUNKID_DEF_INNATE_ESCORT_RANGE,
MICROCHUNKID_DEF_FIRST_PERSON_HANDS,
XXXMICROCHUNKID_DEF_CORPSE_PERSIST_TIME,
MICROCHUNKID_DEF_USE_INNATE_CONVERSATIONS,
MICROCHUNKID_DEF_INNATE_IS_STATIONARY,
MICROCHUNKID_DEF_ORATOR_TYPE,
MICROCHUNKID_DEF_HUMAN_ANIM_OVERRIDE_DEF_ID,
MICROCHUNKID_DEF_DEATH_SOUND_PRESET,
MICROCHUNKID_DEF_HUMAN_LOITER_COLLECTION_DEF_ID,
};
bool SoldierGameObjDef::Save( ChunkSaveClass & csave )
{
csave.Begin_Chunk( CHUNKID_DEF_PARENT );
SmartGameObjDef::Save( csave );
csave.End_Chunk();
//
// Save the dialog entries
//
for (int index = 0; index < DIALOG_MAX; index ++) {
csave.Begin_Chunk( CHUNKID_DEF_DIALOG_ENTRY );
DialogList[index].Save (csave);
csave.End_Chunk();
}
csave.Begin_Chunk( CHUNKID_DEF_VARIABLES );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_TURN_RATE, TurnRate );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_JUMP_VELOCITY, JumpVelocity );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_SKELETON_HEIGHT, SkeletonHeight );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_SKELETON_WIDTH, SkeletonWidth );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_USE_INNATE_BEHAVIOR, UseInnateBehavior );
//WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_USE_INNATE_CONVERSATIONS, UseInnateConversations );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_INNATE_AGGRESSIVENESS, InnateAggressiveness );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_INNATE_TAKE_COVER_PROB, InnateTakeCoverProbability );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_INNATE_IS_STATIONARY, InnateIsStationary );
WRITE_MICRO_CHUNK_WWSTRING( csave, MICROCHUNKID_DEF_FIRST_PERSON_HANDS, FirstPersonHands );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_HUMAN_ANIM_OVERRIDE_DEF_ID, HumanAnimOverrideDefID );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_HUMAN_LOITER_COLLECTION_DEF_ID, HumanLoiterCollectionDefID );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_DEATH_SOUND_PRESET, DeathSoundPresetID );
csave.End_Chunk();
return true;
}
bool SoldierGameObjDef::Load( ChunkLoadClass &cload )
{
int dialog_index = 0;
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_DEF_PARENT:
SmartGameObjDef::Load( cload );
break;
case CHUNKID_DEF_DIALOG_ENTRY:
if (dialog_index < DIALOG_MAX) {
DialogList[dialog_index++].Load (cload);
}
break;
case CHUNKID_DEF_VARIABLES:
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_TURN_RATE, TurnRate );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_JUMP_VELOCITY, JumpVelocity );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_SKELETON_HEIGHT, SkeletonHeight );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_SKELETON_WIDTH, SkeletonWidth );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_USE_INNATE_BEHAVIOR, UseInnateBehavior );
//READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_USE_INNATE_CONVERSATIONS, UseInnateConversations );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_INNATE_AGGRESSIVENESS, InnateAggressiveness );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_INNATE_TAKE_COVER_PROB, InnateTakeCoverProbability );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_INNATE_IS_STATIONARY, InnateIsStationary );
READ_MICRO_CHUNK_WWSTRING( cload, MICROCHUNKID_DEF_FIRST_PERSON_HANDS, FirstPersonHands );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_ORATOR_TYPE, OratorType );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_HUMAN_ANIM_OVERRIDE_DEF_ID, HumanAnimOverrideDefID );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_HUMAN_LOITER_COLLECTION_DEF_ID, HumanLoiterCollectionDefID );
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_DEATH_SOUND_PRESET, DeathSoundPresetID );
default:
//Debug_Say(( "Unrecognized SoldierDef Variable chunkID\n" ));
break;
}
cload.Close_Micro_Chunk();
}
break;
default:
Debug_Say(( "Unrecognized SoldierDef chunkID\n" ));
break;
}
cload.Close_Chunk();
}
return true;
}
const PersistFactoryClass & SoldierGameObjDef::Get_Factory (void) const
{
return _SoldierGameObjDefPersistFactory;
}
/*
** SolderGameObj
*/
SimplePersistFactoryClass<SoldierGameObj, CHUNKID_GAME_OBJECT_SOLDIER> _SoldierGameObjPersistFactory;
const PersistFactoryClass & SoldierGameObj::Get_Factory (void) const
{
return _SoldierGameObjPersistFactory;
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::DisplayDebugBoxForGhostCollision = false;
//------------------------------------------------------------------------------------
SoldierGameObj::SoldierGameObj() :
WeaponRenderModel( NULL ),
BackWeaponRenderModel( NULL ),
BackFlagRenderModel( NULL ),
WeaponAnimControl( NULL ),
TransitionCompletionData( NULL ),
Vehicle( NULL ),
LegFacing( 0 ),
SyncLegs( false ),
LastLegMode( 0 ),
HeadLookDuration( 0 ),
HeadRotation( 0,0,0 ),
HeadLookTarget( 0,0,0 ),
HeadLookAngle( 0,0,0 ),
HeadLookAngleTimer( 0 ),
InnateEnableBits( 0xFFFFFFFF ),
InnateObserver( NULL ),
// FlameTimer( 0 ),
SpecialDamageMode(ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE),
SpecialDamageTimer( 0 ),
GenerateIdleFacialAnimTimer( 0 ),
KeyRing( 0 ),
InFlyMode( false ),
IsVisible( true ),
CurrentSpeech( NULL ),
AIState( AI_STATE_IDLE ),
SpeechAnim( NULL ),
HeadModel( NULL ),
EmotIconModel( NULL ),
EmotIconTimer( 0 ),
LadderUpMask( false ),
LadderDownMask( false ),
SpecialDamageEffect( NULL ),
HealingEffect( NULL ),
ReloadingTilt(0),
WaterWake(NULL),
WeaponChanged( false )
{
// All Humans need a HuamnAnimControl
Set_Anim_Control( new HumanAnimControlClass );
Set_App_Packet_Type(APPPACKETTYPE_SOLDIER);
// create a water wake object
WaterWake = SurfaceEffectsManager::Create_Persistant_Emitter();
}
//------------------------------------------------------------------------------------
SoldierGameObj::~SoldierGameObj()
{
if ( HealingEffect != NULL ) {
Peek_Human_Phys()->Remove_Effect_From_Me( HealingEffect );
REF_PTR_RELEASE( HealingEffect );
}
Set_Special_Damage_Mode( ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE );
Set_Emot_Icon (NULL, 0);
REF_PTR_RELEASE( HeadModel );
REF_PTR_RELEASE( SpeechAnim );
REF_PTR_RELEASE( CurrentSpeech );
if (CombatManager::I_Am_Server()) {
CombatManager::On_Soldier_Death(this);
}
Set_Weapon_Model( NULL );
if ( BackWeaponRenderModel != NULL ) {
Peek_Model()->Remove_Sub_Object(BackWeaponRenderModel);
BackWeaponRenderModel->Release_Ref();
BackWeaponRenderModel = NULL;
}
if ( BackFlagRenderModel != NULL ) {
Peek_Model()->Remove_Sub_Object(BackFlagRenderModel);
BackFlagRenderModel->Release_Ref();
BackFlagRenderModel = NULL;
}
if ( WeaponAnimControl != NULL ) {
delete WeaponAnimControl;
WeaponAnimControl = NULL;
}
if (Vehicle != NULL) {
// Remove myself from the vehicle !
Vehicle->Remove_Occupant(this);
}
COMBAT_SCENE->Remove_Object( Peek_Physical_Object() );
if ( Is_Human_Controlled() ) {
GameObjManager::Remove_Star( this );
}
Reset_RenderObjs();
if (WaterWake != NULL) {
SurfaceEffectsManager::Destroy_Persistant_Emitter( WaterWake );
WaterWake = NULL;
}
return ;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Init( void )
{
Re_Init( Get_Definition() );
return ;
}
void SoldierGameObj::Init( const SoldierGameObjDef & definition )
{
SmartGameObj::Init( definition );
Copy_Settings( definition );
return ;
}
void SoldierGameObj::Copy_Settings( const SoldierGameObjDef & definition )
{
HumanState.Init( Peek_Human_Phys() );
HumanState.Set_Anim_Control( (HumanAnimControlClass *)Get_Anim_Control() ); // Must set the anim control after the phys object
//HumanState.Set_Human_Anim_Override( "HAO Test" );
if ( Get_Definition().HumanAnimOverrideDefID != 0 ) {
HumanState.Set_Human_Anim_Override( Get_Definition().HumanAnimOverrideDefID );
}
if ( Get_Definition().HumanLoiterCollectionDefID != 0 ) {
HumanState.Set_Human_Loiter_Collection( Get_Definition().HumanLoiterCollectionDefID );
}
Adjust_Skeleton( definition.SkeletonHeight, definition.SkeletonWidth );
// All characters force their heads and hands to use the same LOD level as their body.
RenderObjClass * model = Peek_Human_Phys()->Peek_Model();
if (model != NULL) {
model->Set_Sub_Objects_Match_LOD(true);
}
if ( InnateObserver == NULL &&
Get_Definition().UseInnateBehavior &&
Is_Controlled_By_Me () == false ) {
InnateObserver = new SoldierObserverClass;
Insert_Observer( InnateObserver );
}
//
// Copy the dialog entries from the definition
//
for( int index = 0; index < DIALOG_MAX; index ++ ) {
DialogList[index] = definition.DialogList[index];
}
//
// Put the soldier in its own collision group
//
Peek_Physical_Object ()->Set_Collision_Group( SOLDIER_COLLISION_GROUP );
Prepare_Speech_Framework ();
return ;
}
void SoldierGameObj::Prepare_Speech_Framework( void )
{
//
// Make sure we have an allocated animation to use for speech
//
if ( SpeechAnim == NULL) {
HeadModel = Find_Head_Model();
//
// Dig out the skeleton name for the head model
//
if (HeadModel != NULL) {
const HTreeClass *htree = HeadModel->Get_HTree ();
if (htree != NULL) {
StringClass skeleton_name = htree->Get_Name ();
//
// Generate the animation
//
SpeechAnim = new DynamicSpeechAnimClass (skeleton_name);
GenerateIdleFacialAnimTimer = 0;
}
}
}
return ;
}
void SoldierGameObj::Re_Init( const SoldierGameObjDef & definition )
{
if ( this == COMBAT_STAR ) {
HUDClass::Force_Weapon_Chart_Update();
WeaponViewClass::Reset();
}
//
// Remove the object from the world (just to be safe)
//
COMBAT_SCENE->Remove_Object( Peek_Physical_Object() );
//
// Reset the weapon model
//
Set_Weapon_Model( NULL );
if ( BackWeaponRenderModel != NULL ) {
Peek_Model()->Remove_Sub_Object(BackWeaponRenderModel);
BackWeaponRenderModel->Release_Ref();
BackWeaponRenderModel = NULL;
}
if ( BackFlagRenderModel != NULL ) {
Peek_Model()->Remove_Sub_Object(BackFlagRenderModel);
BackFlagRenderModel->Release_Ref();
BackFlagRenderModel = NULL;
}
if ( WeaponAnimControl != NULL ) {
delete WeaponAnimControl;
WeaponAnimControl = NULL;
}
//
// Re-initialize the base class
//
SmartGameObj::Re_Init( definition );
//
// Free some of the data we will be re-initializing
//
REF_PTR_RELEASE( HeadModel );
REF_PTR_RELEASE( SpeechAnim );
REF_PTR_RELEASE( CurrentSpeech );
HumanState.Reset();
//
// Copy any internal settings from the definition
//
Copy_Settings( definition );
//
// "Dirty" the object for networking
//
Set_Object_Dirty_Bit( NetworkObjectClass::BIT_RARE, true );
// When class changes, update for new weapon
if ( this == COMBAT_STAR ) {
HUDClass::Reset();
}
return ;
}
//------------------------------------------------------------------------------------
const SoldierGameObjDef & SoldierGameObj::Get_Definition( void ) const
{
return (const SoldierGameObjDef &)BaseGameObj::Get_Definition();
}
void SoldierGameObj::Set_Control_Owner(int control_owner)
{
if ( Is_Human_Controlled() ) {
GameObjManager::Remove_Star( this );
}
SmartGameObj::Set_Control_Owner(control_owner);
if ( Is_Human_Controlled() ) {
GameObjManager::Add_Star( this );
}
}
/*
** Soldier Save and Load
*/
enum {
CHUNKID_PARENT = 909991656,
CHUNKID_VARIABLES,
CHUNKID_WEAPON_ANIM,
CHUNKID_HUMAN_STATE,
XXXCHUNKID_C4_TIMER,
XXXCHUNKID_WEAPON_MODEL,
CHUNKID_TRANSITION_COMPLETION_DATA,
CHUNKID_DIALOG_ENTRY,
CHUNKID_RENDER_OBJS,
CHUNKID_SPECIAL_DAMAGE_DAMAGER,
MICROCHUNKID_DETONATE_C4 = 1,
MICROCHUNKID_LEG_FACING,
MICROCHUNKID_SYNC_LEGS,
MICROCHUNKID_ANIMATION_NAME,
MICROCHUNKID_VEHICLE,
XXX_MICROCHUNKID_TRANSITION,
XXX_MICROCHUNKID_FORCE_FACING,
MICROCHUNKID_INNATE_ENABLE_BITS,
MICROCHUNKID_INNATE_OBSERVER_PTR,
MICROCHUNKID_LAST_LEG_MODE,
MICROCHUNKID_HEAD_LOOK_DURATION,
MICROCHUNKID_HEAD_ROTATION,
MICROCHUNKID_LOOK_TARGET,
XXXMICROCHUNKID_FLAME_TIMER,
MICROCHUNKID_KEY_RING,
MICROCHUNKID_AI_STATE,
XXX_MICROCHUNKID_IN_CONVERSATION,
MICROCHUNKID_LOOK_ANGLE,
MICROCHUNKID_LOOK_ANGLE_TIMER,
XXX_MICROCHUNKID_ACTIVE_CONVERSATION,
MICROCHUNKID_WEAPON_MODEL,
MICROCHUNKID_SPECIAL_DAMAGE_MODE,
MICROCHUNKID_SPECIAL_DAMAGE_TIMER,
MICROCHUNKID_IS_USING_GHOST_COLLISION
};
//------------------------------------------------------------------------------------
bool SoldierGameObj::Save( ChunkSaveClass & csave )
{
csave.Begin_Chunk( CHUNKID_PARENT );
SmartGameObj::Save( csave );
csave.End_Chunk();
//
// Save the dialog entries
//
for (int index = 0; index < DIALOG_MAX; index ++) {
csave.Begin_Chunk( CHUNKID_DIALOG_ENTRY );
DialogList[index].Save (csave);
csave.End_Chunk();
}
csave.Begin_Chunk( CHUNKID_VARIABLES );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DETONATE_C4, DetonateC4 );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LEG_FACING, LegFacing );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_SYNC_LEGS, SyncLegs );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_KEY_RING, KeyRing );
// WRITE_MICRO_CHUNK( csave, MICROCHUNKID_FORCE_FACING, ForceFacing );
if ( Vehicle != NULL ) {
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_VEHICLE, Vehicle );
}
csave.Begin_Micro_Chunk( MICROCHUNKID_ANIMATION_NAME );
char anim_string[80];
strcpy( anim_string, AnimationName );
csave.Write( anim_string, strlen( anim_string ) + 1);
csave.End_Micro_Chunk();
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_INNATE_ENABLE_BITS, InnateEnableBits );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_INNATE_OBSERVER_PTR, InnateObserver );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LAST_LEG_MODE, LastLegMode );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_HEAD_LOOK_DURATION, HeadLookDuration );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_HEAD_ROTATION, HeadRotation );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LOOK_TARGET, HeadLookTarget );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LOOK_ANGLE, HeadLookAngle );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_LOOK_ANGLE_TIMER, HeadLookAngleTimer );
// WRITE_MICRO_CHUNK( csave, MICROCHUNKID_FLAME_TIMER, FlameTimer );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_SPECIAL_DAMAGE_MODE, SpecialDamageMode );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_SPECIAL_DAMAGE_TIMER, SpecialDamageTimer );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_AI_STATE, AIState );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_WEAPON_MODEL, WeaponRenderModel );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_IS_USING_GHOST_COLLISION, IsUsingGhostCollision );
csave.End_Chunk();
if ( WeaponAnimControl ) {
csave.Begin_Chunk( CHUNKID_WEAPON_ANIM );
WeaponAnimControl->Save( csave );
csave.End_Chunk();
}
csave.Begin_Chunk( CHUNKID_HUMAN_STATE );
HumanState.Save( csave );
csave.End_Chunk();
if ( TransitionCompletionData ) {
csave.Begin_Chunk( CHUNKID_TRANSITION_COMPLETION_DATA );
TransitionCompletionData->Save( csave );
csave.End_Chunk();
}
for ( int i = 0; i < RenderObjList.Count(); i++ ) {
csave.Begin_Chunk( CHUNKID_RENDER_OBJS );
csave.Begin_Chunk(RenderObjList[i]->Get_Factory().Chunk_ID());
RenderObjList[i]->Get_Factory().Save( csave, RenderObjList[i] );
csave.End_Chunk();
csave.End_Chunk();
}
if ( SpecialDamageDamager.Get_Ptr() != NULL ) {
csave.Begin_Chunk( CHUNKID_SPECIAL_DAMAGE_DAMAGER );
SpecialDamageDamager.Save( csave );
csave.End_Chunk();
}
return true;
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::Load( ChunkLoadClass &cload )
{
char anim_string[80];
int dialog_index = 0;
WWASSERT( Vehicle == NULL );
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_PARENT:
SmartGameObj::Load( cload );
break;
case CHUNKID_DIALOG_ENTRY:
if (dialog_index < DIALOG_MAX) {
DialogList[dialog_index++].Load (cload);
}
break;
case CHUNKID_VARIABLES:
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_DETONATE_C4, DetonateC4 );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LEG_FACING, LegFacing );
READ_MICRO_CHUNK( cload, MICROCHUNKID_SYNC_LEGS, SyncLegs );
READ_MICRO_CHUNK( cload, MICROCHUNKID_VEHICLE, Vehicle );
READ_MICRO_CHUNK( cload, MICROCHUNKID_KEY_RING, KeyRing );
// READ_MICRO_CHUNK( cload, MICROCHUNKID_FORCE_FACING, ForceFacing );
case MICROCHUNKID_ANIMATION_NAME:
cload.Read( anim_string, cload.Cur_Micro_Chunk_Length() );
AnimationName = anim_string;
break;
case MICROCHUNKID_INNATE_OBSERVER_PTR:
cload.Read( &InnateObserver, sizeof (InnateObserver) );
if ( InnateObserver != NULL ) {
REQUEST_POINTER_REMAP( (void **)&InnateObserver );
}
break;
READ_MICRO_CHUNK( cload, MICROCHUNKID_INNATE_ENABLE_BITS, InnateEnableBits );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LAST_LEG_MODE, LastLegMode );
READ_MICRO_CHUNK( cload, MICROCHUNKID_HEAD_LOOK_DURATION, HeadLookDuration );
READ_MICRO_CHUNK( cload, MICROCHUNKID_HEAD_ROTATION, HeadRotation );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LOOK_TARGET, HeadLookTarget );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LOOK_ANGLE, HeadLookAngle );
READ_MICRO_CHUNK( cload, MICROCHUNKID_LOOK_ANGLE_TIMER, HeadLookAngleTimer );
// READ_MICRO_CHUNK( cload, MICROCHUNKID_FLAME_TIMER, FlameTimer );
READ_MICRO_CHUNK( cload, MICROCHUNKID_SPECIAL_DAMAGE_MODE, SpecialDamageMode );
READ_MICRO_CHUNK( cload, MICROCHUNKID_SPECIAL_DAMAGE_TIMER, SpecialDamageTimer );
READ_MICRO_CHUNK( cload, MICROCHUNKID_AI_STATE, AIState );
READ_MICRO_CHUNK( cload, MICROCHUNKID_WEAPON_MODEL, WeaponRenderModel );
READ_MICRO_CHUNK( cload, MICROCHUNKID_IS_USING_GHOST_COLLISION, IsUsingGhostCollision );
default:
Debug_Say(( "Unrecognized Soldier Variable chunkID\n" ));
break;
}
cload.Close_Micro_Chunk();
}
if ( Vehicle != NULL ) {
REQUEST_POINTER_REMAP( (void **)&Vehicle );
}
break;
case CHUNKID_WEAPON_ANIM:
Set_Weapon_Animation( NULL ); // Get the anim control built
WeaponAnimControl->Load( cload );
break;
case CHUNKID_HUMAN_STATE:
HumanState.Load( cload );
break;
case CHUNKID_RENDER_OBJS:
cload.Open_Chunk();
PersistFactoryClass * factory;
factory = SaveLoadSystemClass::Find_Persist_Factory(cload.Cur_Chunk_ID());
WWASSERT(factory != NULL);
if (factory != NULL) {
RenderObjClass * robj = (RenderObjClass *)factory->Load(cload);
Add_RenderObj( robj );
robj->Release_Ref();
}
cload.Close_Chunk();
break;
case CHUNKID_TRANSITION_COMPLETION_DATA:
WWASSERT( TransitionCompletionData == NULL );
TransitionCompletionData = new TransitionCompletionDataStruct();
TransitionCompletionData->Load( cload );
break;
case CHUNKID_SPECIAL_DAMAGE_DAMAGER:
SpecialDamageDamager.Load( cload );
break;
default:
Debug_Say(( "Unrecognized SoldierGameObj chunkID\n" ));
break;
}
cload.Close_Chunk();
}
if ( WeaponRenderModel != NULL ) {
REQUEST_REF_COUNTED_POINTER_REMAP( (RefCountClass **)&WeaponRenderModel );
}
SaveLoadSystemClass::Register_Post_Load_Callback(this);
return true;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::On_Post_Load( void )
{
HumanState.Set_Anim_Control( (HumanAnimControlClass *)Get_Anim_Control() ); // Must set the anim control after the phys object
SmartGameObj::On_Post_Load();
if ( Peek_Model() && (WeaponRenderModel != NULL) ) {
Peek_Model()->Add_Sub_Object_To_Bone( WeaponRenderModel, GUN_BONE_NAME );
}
Adjust_Skeleton( Get_Definition().SkeletonHeight, Get_Definition().SkeletonWidth );
// Fixup BackWeaponRenderModel
Update_Back_Gun();
// Hide if in vehicle
if ( Is_In_Vehicle() && Peek_Model() != NULL ) {
Peek_Model()->Set_Hidden( true );
}
//
// Make sure we have an allocated animation to use for speech
//
Prepare_Speech_Framework ();
return ;
}
//-----------------------------------------------------------------------------
CollisionReactionType SoldierGameObj::Collision_Occurred(const CollisionEventClass & event)
{
// Debug_Say(( "Soldier Collision %p %p\n", this, event.OtherObj ));
// Detect squishing...
if ( event.OtherObj != NULL && event.OtherObj->Get_Observer() != NULL ) {
PhysicalGameObj * obj = ((CombatPhysObserverClass *)event.OtherObj->Get_Observer())->As_PhysicalGameObj();
if ( obj && obj->As_VehicleGameObj() ) {
// if ( !Is_Teammate( obj ) ) { // never squish teammates
if ( Is_Enemy( obj ) ) { // only squish enemies
Vector3 vel;
if ( event.OtherObj->As_MoveablePhysClass() != NULL ) {
event.OtherObj->As_MoveablePhysClass()->Get_Velocity( &vel );
Vector3 my_pos;
Vector3 vehicle_pos;
Get_Position(&my_pos);
obj->Get_Position(&vehicle_pos);
// only squish if velocity is high enough, and velocity is towards the soldier
if ( (vel.Length() > obj->As_VehicleGameObj()->Get_Squish_Velocity() ) &&
(Vector3::Dot_Product(vel,my_pos - vehicle_pos) > 0.0f) )
{
if ( HumanState.Get_State() != HumanStateClass::DEATH ) {
// We need to pick a better warhead to damage with
SmartGameObj * damager = obj->As_VehicleGameObj()->Get_Driver();
if ( damager == NULL ) {
damager = obj->As_VehicleGameObj();
}
OffenseObjectClass offense( 10000, 1, damager );
Apply_Damage_Extended( offense, 10000.0f, vel, NULL );
// Play the squish sound
// Stats
if (( obj->As_VehicleGameObj()->Get_Driver() != NULL ) &&
( obj->As_VehicleGameObj()->Get_Driver()->Get_Player_Data() != NULL ) ) {
obj->As_VehicleGameObj()->Get_Driver()->Get_Player_Data()->Stats_Add_Squish();
}
}
}
}
}
}
}
return COLLISION_REACTION_DEFAULT;
}
/*
**
*/
void SoldierGameObj::Export_Creation( BitStreamClass &packet )
{
//TSS091001
//WWDEBUG_SAY((">>>>> SoldierGameObj::Export_Creation id %d\n", Get_ID()));
SmartGameObj::Export_Creation( packet );
return ;
}
/*
**
*/
void SoldierGameObj::Import_Creation( BitStreamClass &packet )
{
SmartGameObj::Import_Creation( packet );
//TSS091001
//WWDEBUG_SAY((">>>>> SoldierGameObj::Import_Creation id %d\n", Get_ID()));
/*
//
// Setup the speed settings for this soldier
//
float speed_factor = CombatManager::Get_Max_Speed_Pc( this ) / 100.0f;
Set_Max_Speed( speed_factor * Get_Max_Speed() );
*/
return ;
}
/*
**
*/
void SoldierGameObj::Export_Rare( BitStreamClass &packet )
{
SmartGameObj::Export_Rare( packet );
//
// Add our definition ID to the packet
//
uint32 definition_id = Get_Definition ().Get_ID ();
packet.Add( definition_id );
}
/*
**
*/
void SoldierGameObj::Import_Rare( BitStreamClass &packet )
{
Set_Weapon_Model (NULL);
// If we are changing to the same def, the above line made us lose our weapon model, and we won't get it back.
// The next line makes us get it back.
Get_Weapon_Bag()->Force_Changed();
SmartGameObj::Import_Rare( packet );
//
// Read the definition ID from the packet
//
uint32 definition_id = 0;
packet.Get( definition_id );
//
// Did our definition change?
//
if (definition_id != Get_Definition ().Get_ID ()) {
DefinitionClass *definition = DefinitionMgrClass::Find_Definition (definition_id);
//
// Did we find the right definition?
//
if (definition != NULL && definition->Get_Class_ID() == CLASSID_GAME_OBJECT_DEF_SOLDIER) {
SoldierGameObjDef *soldier_def = reinterpret_cast<SoldierGameObjDef *> (definition);
//
// Re-initialize ourselves
//
Re_Init (*soldier_def);
}
}
return ;
}
/*
**
*/
void SoldierGameObj::Export_Occasional( BitStreamClass &packet )
{
SmartGameObj::Export_Occasional( packet );
//
// What weapon is being held?
//
#if 0 //(gth) moving this back to Frequent to fix the game, re-optimize later...
WeaponClass * p_weapon = Get_Weapon();
bool has_weapon = (p_weapon != NULL);
packet.Add(has_weapon);
if (has_weapon) {
packet.Add(p_weapon->Get_ID());
packet.Add(p_weapon->Get_Total_Rounds());
}
#endif
WWASSERT(WeaponBag != NULL);
WeaponBag->Export_Weapon_List(packet);
//packet.Add(CtfTeamFlag, BITPACK_CTF_TEAM_FLAG);
}
/*
**
*/
void SoldierGameObj::Import_Occasional( BitStreamClass &packet )
{
WWASSERT(CombatManager::I_Am_Only_Client());
SmartGameObj::Import_Occasional( packet );
//
// Held weapon
//
#if 0 // (gth) moving back to "Frequent" to fix the game, re-optimize later?
bool has_weapon = packet.Get(has_weapon);
if (has_weapon) {
WWASSERT(!packet.Is_Flushed());
int weapon_id = packet.Get(weapon_id);
int rounds = packet.Get(rounds);
if ((Get_Weapon() == NULL) || (weapon_id != Get_Weapon()->Get_ID())) {
WeaponBag->Select_Weapon_ID(weapon_id);
}
if (Get_Weapon() != NULL) {
// If this weapon is currently being fired, ignore the server rounds count packet
// This should help the jittery rounds count
if ( !Get_Weapon()->Is_Triggered() ) {
Get_Weapon()->Set_Total_Rounds( rounds );
}
}
} else {
if (Get_Weapon() != NULL) {
Get_Weapon_Bag()->Deselect();
}
}
#endif
//
// Weapon list
//
WWASSERT(WeaponBag != NULL);
WeaponBag->Import_Weapon_List(packet);
/*
//
// Flag pickup/drop
//
int ctf_team_flag = packet.Get(ctf_team_flag, BITPACK_CTF_TEAM_FLAG);
if (CtfTeamFlag != ctf_team_flag) {
CombatManager::Change_Flag_Status(this, ctf_team_flag);
}
*/
}
/*
**
*/
void SoldierGameObj::Export_Frequent(BitStreamClass & packet)
{
/**/
//TSS101601
bool in_vehicle = (Get_State() == HumanStateClass::IN_VEHICLE);
packet.Add(in_vehicle);
if (in_vehicle)
{
// Just do the control info
SmartGameObj::Export_Frequent(packet);
return;
}
/**/
//
// What weapon is being held?
// (gth) moved this back into frequent to fix the game, re-optimize later
//
WeaponClass * p_weapon = Get_Weapon();
bool has_weapon = (p_weapon != NULL);
packet.Add(has_weapon);
if (has_weapon) {
packet.Add(p_weapon->Get_ID());
packet.Add(p_weapon->Get_Total_Rounds());
}
//
// Export Position and state
//
Vector3 position;
Get_Position(&position);
#ifdef MULTIPLAYERDEMO
//
// Mix up the packet order to make demo/non-demo code more incompatible.
//
packet.Add(position.Y, BITPACK_WORLD_POSITION_Y);
packet.Add(position.Z, BITPACK_WORLD_POSITION_Z);
packet.Add(position.X, BITPACK_WORLD_POSITION_X);
#else
packet.Add(position.X, BITPACK_WORLD_POSITION_X);
packet.Add(position.Y, BITPACK_WORLD_POSITION_Y);
packet.Add(position.Z, BITPACK_WORLD_POSITION_Z);
#endif
packet.Add((int) HumanState.Get_State(), BITPACK_HUMAN_STATE);
packet.Add(HumanState.Get_Sub_State(), BITPACK_HUMAN_SUB_STATE);
if (HumanState.Get_State() == HumanStateClass::AIRBORNE) {
// velocity is only needed for jumping
Vector3 velocity;
Get_Velocity(velocity);
packet.Add(velocity.X);
packet.Add(velocity.Y);
packet.Add(velocity.Z);
}
if ((Get_State() == HumanStateClass::TRANSITION) ||
(Get_State() == HumanStateClass::ANIMATION) ||
(Get_State() == HumanStateClass::IN_VEHICLE)) {
packet.Add_Terminated_String(AnimationName);
// Debug_Say(( "In Transition %s\n", TransitionName ));
}
bool is_special_damage = SpecialDamageMode != ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE;
packet.Add(is_special_damage);
if ( is_special_damage ) {
packet.Add( SpecialDamageMode );
}
SmartGameObj::Export_Frequent(packet);
}
/*
**
*/
void SoldierGameObj::Import_Frequent( BitStreamClass & packet )
{
WWASSERT(CombatManager::I_Am_Only_Client());
/**/
//TSS101601
bool in_vehicle = packet.Get(in_vehicle);
if (in_vehicle)
{
// Just get control info
SmartGameObj::Import_Frequent(packet);
return;
}
/**/
//
// What weapon is being held?
// (gth) moved this back into frequent to fix the game, re-optimize later
//
bool has_weapon = packet.Get(has_weapon);
if (has_weapon) {
WWASSERT(!packet.Is_Flushed());
int weapon_id = packet.Get(weapon_id);
int rounds = packet.Get(rounds);
if ((Get_Weapon() == NULL) || (weapon_id != Get_Weapon()->Get_ID())) {
WeaponBag->Select_Weapon_ID(weapon_id);
}
if (Get_Weapon() != NULL) {
// If this weapon is currently being fired, ignore the server rounds count packet
// This should help the jittery rounds count
if ( !Get_Weapon()->Is_Triggered() ) {
Get_Weapon()->Set_Total_Rounds( rounds );
}
}
} else {
if (Get_Weapon() != NULL) {
Get_Weapon_Bag()->Deselect();
}
}
//
// Position
//
Vector3 sc_position;
#ifdef MULTIPLAYERDEMO
//
// Mix up the packet order to make demo/non-demo code more incompatible.
//
packet.Get(sc_position.Y, BITPACK_WORLD_POSITION_Y);
packet.Get(sc_position.Z, BITPACK_WORLD_POSITION_Z);
packet.Get(sc_position.X, BITPACK_WORLD_POSITION_X);
#else
packet.Get(sc_position.X, BITPACK_WORLD_POSITION_X);
packet.Get(sc_position.Y, BITPACK_WORLD_POSITION_Y);
packet.Get(sc_position.Z, BITPACK_WORLD_POSITION_Z);
#endif
// Bump Z up to the top of the possible values due to packing
// we assume the max error is half of the resolution
float max_error = cEncoderList::Get_Encoder_Type_Entry( BITPACK_WORLD_POSITION_Z ).Get_Resolution() / 2.0f;
sc_position.Z += max_error;
Interpret_Sc_Position_Data(sc_position);
//
// State and substate
//
int h_state = packet.Get(h_state, BITPACK_HUMAN_STATE);
HumanStateClass::HumanStateType state =
(HumanStateClass::HumanStateType) h_state;
int sub_state = packet.Get(sub_state, BITPACK_HUMAN_SUB_STATE);
//
// Velocity (if airborne)
//
Vector3 velocity;
if (state == HumanStateClass::AIRBORNE) {
packet.Get(velocity.X);
packet.Get(velocity.Y);
packet.Get(velocity.Z);
}
if (HumanState.Is_Locked()) {
packet.Flush();
return;
}
#if 0
if ( Get_State() == HumanStateClass::TRANSITION ) {
Debug_Say(( "Ignoring Transitioning!\n" ));
packet.Flush();
return;
}
#endif
char trans_name[80] = "";
if ( ( state == HumanStateClass::TRANSITION ) ||
( state == HumanStateClass::ANIMATION ) ||
( state == HumanStateClass::IN_VEHICLE ) ) {
packet.Get_Terminated_String(trans_name, sizeof(trans_name));
}
Interpret_Sc_State_Data(state, sub_state, trans_name, velocity, sc_position);
bool is_special_damage;
packet.Get(is_special_damage);
int mode = ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE;
if ( is_special_damage ) {
packet.Get(mode);
}
if ( mode != SpecialDamageMode ) {
Set_Special_Damage_Mode( (ArmorWarheadManager::SpecialDamageType)mode );
}
if (Get_State() == HumanStateClass::DIVE) {
packet.Flush();
} else {
SmartGameObj::Import_Frequent(packet);
}
WWASSERT(packet.Is_Flushed());
}
//-----------------------------------------------------------------------------
void SoldierGameObj::Import_State_Cs(BitStreamClass & packet)
{
bool is_sniping = packet.Get( is_sniping );
if ( is_sniping != Is_Sniping() ) {
// Take sniping state from client
// Debug_Say(( "Fixing Sniper State\n" ));
HumanState.Toggle_State_Flag( HumanStateClass::SNIPING_FLAG );
}
bool checking = packet.Get( checking );
if ( checking ) {
int check = packet.Get( check );
if ( check != Check() ) {
// React to cheating
if ( Get_Player_Data() ) {
Get_Player_Data()->Inc_Punish_Timer( TimeManager::Get_Frame_Seconds() ) ;
}
}
}
SmartGameObj::Import_State_Cs(packet);
}
//-----------------------------------------------------------------------------
void SoldierGameObj::Export_State_Cs(BitStreamClass & packet)
{
bool is_sniping = Is_Sniping();
packet.Add( is_sniping );
bool checking = Control.Get_Boolean( ControlClass::BOOLEAN_ACTION );
packet.Add( checking );
if ( checking ) {
int check = Check();
packet.Add( check );
}
SmartGameObj::Export_State_Cs(packet);
}
//-----------------------------------------------------------------------------
int SoldierGameObj::Check(void)
{
Matrix3D tm(1);
#define UNINITIALLIZED_CRC 0x78629140
static int crc = UNINITIALLIZED_CRC;
tm.Rotate_X( 1.4f );
if ( crc == UNINITIALLIZED_CRC ) {
char * filelist[] = {
"laif`wp-gga", //"objects.ddb",
"bqnlq-jmj", //"armor.ini",
"almfp-jmj", //"bones.ini",
"pvqeb`ffeef`wp-jmj", //"surfaceeffects.ini",
"`bnfqbp-jmj", //"cameras.ini",
"`\\mlg\\nd\\o3-t0g", //"c_nod_mg_l0.w3d",
"`\\mlg\\qh\\o3-t0g", //"c_nod_rk_l0.w3d",
"`\\mlg\\eo\\o3-t0g", //"c_nod_fl_l0.w3d",
"`\\mlg\\fm\\o3-t0g", //"c_nod_en_l0.w3d",
"`\\mlg\\ndl\\o3-t0g", //"c_nod_mgo_l0.w3d",
"`\\mlg\\qhl\\o3-t0g", //"c_nod_rko_l0.w3d",
"`\\mlg\\`kfnw\\o3-t0g", //"c_nod_chemt_l0.w3d",
"`\\mlg\\pmjsfq\\o3-t0g", //"c_nod_sniper_l0.w3d",
"`\\mlg\\qplog\\o3-t0g", //"c_nod_rsold_l0.w3d",
"`\\mlg\\pwowk\\o3-t0g", //"c_nod_stlth_l0.w3d",
"`\\mlg\\pbhv\\o3-t0g", //"c_nod_saku_l0.w3d",
"`\\mlg\\pbhv1\\o3-t0g", //"c_nod_saku2_l0.w3d",
"`\\mlg\\qbu\\o3-t0g", //"c_nod_rav_l0.w3d",
"`\\mlg\\nqbu\\o3-t0g", //"c_nod_mrav_l0.w3d",
"`\\mlg\\ngy\\o3-t0g", //"c_nod_mdz_l0.w3d",
"`\\mlg\\ngy1\\o3-t0g", //"c_nod_mdz2_l0.w3d",
"`\\mlg\\w`\\o3-t0g", //"c_nod_tc_l0.w3d",
"`\\mlg\\nvwbmw\\o3-t0g", //"c_nod_mutant_l0.w3d",
"`\\mlg\\npog\\o3-t0g", //"c_nod_msld_l0.w3d",
"`\\mlg\\pplog\\o3-t0g", //"c_nod_ssold_l0.w3d",
"`\\mlg\\sfwn\\o3-t0g", //"c_nod_petm_l0.w3d",
"`\\mlg\\hbmf\\o3-t0g", //"c_nod_kane_l0.w3d",
"`\\dgj\\nd\\o3-t0g", //"c_gdi_mg_l0.w3d",
"`\\dgj\\qh\\o3-t0g", //"c_gdi_rk_l0.w3d",
"`\\dgj\\dq\\o3-t0g", //"c_gdi_gr_l0.w3d",
"`\\dgj\\fm\\o3-t0g", //"c_gdi_en_l0.w3d",
"`\\dgj\\ndl\\o3-t0g", //"c_gdi_mgo_l0.w3d",
"`\\dgj\\qhl\\o3-t0g", //"c_gdi_rko_l0.w3d",
"`\\dgj\\pzg\\o3-t0g", //"c_gdi_syd_l0.w3d",
"`\\dgj\\gfbg\\o3-t0g", //"c_gdi_dead_l0.w3d",
"`\\dgj\\dvm\\o3-t0g", //"c_gdi_gun_l0.w3d",
"`\\dgj\\sw`k\\o3-t0g", //"c_gdi_ptch_l0.w3d",
"`\\kbul`\\o3-t0g", //"c_havoc_l0.w3d",
"`\\kbul`m\\o3-t0g", //"c_havocn_l0.w3d",
"`\\kbul`t\\o3-t0g", //"c_havocw_l0.w3d",
"`\\kbul`g\\o3-t0g", //"c_havocd_l0.w3d",
"`\\dgj\\pzg\\o3-t0g", //"c_gdi_syd_l0.w3d",
"`\\dgj\\pzg1\\o3-t0g", //"c_gdi_syd2_l0.w3d",
"`\\dgj\\nlaj\\o3-t0g", //"c_gdi_mobi_l0.w3d",
"`\\dgj\\klwt\\o3-t0g", //"c_gdi_hotw_l0.w3d",
"`\\dgj\\ow\\o3-t0g", //"c_gdi_lt_l0.w3d",
"`\\mlg\\sfwq\\o3-t0g", //"c_nod_petr_l0.w3d",
"`\\oldbm\\o3-t0g", //"c_logan_l0.w3d",
"`\\dgj\\ol`hf\\o3-t0g", //"c_gdi_locke_l0.w3d",
"u\\mlg\\avddz-t0g", //"v_nod_buggy.w3d",
"u\\mlg\\bs`\\n-t0g", //"v_nod_apc_m.w3d",
"u\\mlg\\bqwoqz-t0g", //"v_nod_artlry.w3d",
"u\\mlg\\eobnf-t0g", //"v_nod_flame.w3d",
"u\\mlg\\owbmh-t0g", //"v_nod_ltank.w3d",
"u\\mlg\\pwowk-t0g", //"v_nod_stlth.w3d",
"u\\mlg\\wqmpsw\\n-t0g", //"v_nod_trnspt_m.w3d",
"u\\mlg\\bsb`kf\\n-t0g", //"v_nod_apache_m.w3d",
"u\\`kbnfoflm-t0g", //"v_chameleon.w3d",
"u\\dgj\\kvnuff-t0g", //"v_gdi_humvee.w3d",
"u\\dgj\\bs`\\n-t0g", //"v_gdi_apc_m.w3d",
"u\\dgj\\nqop-t0g", //"v_gdi_mrls.w3d",
"u\\dgj\\nfgwmh-t0g", //"v_gdi_medtnk.w3d",
"u\\dgj\\nbnnwk-t0g", //"v_gdi_mammth.w3d",
"u\\sj`hvs32-t0g", //"v_pickup01.w3d",
"u\\pfgbm32-t0g", //"v_sedan01.w3d",
"u\\dgj\\lq`b\\n-t0g", //"v_gdi_orca_m.w3d",
"u\\dgj\\wqmpsw\\n-t0g", //"v_gdi_trnspt_m.w3d",
};
#define NUM_CRC_FILES (sizeof( filelist ) / sizeof( filelist[0] ) )
crc = 0;
tm.Rotate_Y( 2.8f );
for ( int i = 0; i < NUM_CRC_FILES; i++ ) {
StringClass name = filelist[i];
// Obfuscate name
char * n = &name[0];
while ( *n ) *n++ ^= 0x3;
tm.Rotate_Z( 3.6f );
// Debug_Say(( " \"%s\",\n", name ));
FileClass * file = _TheFileFactory->Get_File( name );
tm.Pre_Rotate_X( 0.3f );
if ( file && file->Is_Available() ) {
int size = file->Size();
tm.Pre_Rotate_Y( 0.4f );
file->Open();
tm.Pre_Rotate_Z( 0.5f );
while ( size > 0 ) {
unsigned char buffer[ 4096 ];
int amount = min( (int)size, (int)sizeof(buffer) );
tm.Translate_X( 3.1f );
amount = file->Read( buffer, amount );
tm.Translate_Y( 4.6f );
crc = CRC_Memory( buffer, amount, crc );
tm.Translate_Z( 8.2f );
size -= amount;
}
file->Close();
} else {
// Debug_Say(( "***%s not found\n", name ));
}
tm.Rotate_X( 1.4f );
}
}
return crc;
}
//-----------------------------------------------------------------------------
/*
**
*/
bool _UseLatencyInterpret = true;
//-----------------------------------------------------------------------------
void SoldierGameObj::Interpret_Sc_Position_Data( const Vector3 & sc_position)
{
Vector3 position = sc_position;
// Only use the latency code for the star
if ( _UseLatencyInterpret && (this == COMBAT_STAR) ) {
Peek_Human_Phys()->Network_Latency_State_Update(sc_position,Vector3(0,0,0));
return;
}
WWASSERT(CombatManager::I_Am_Only_Client());
if (Get_State() == HumanStateClass::TRANSITION) {
//
// Pop
//
// Set_Position(sc_position);
Peek_Human_Phys()->Network_State_Update(sc_position,Vector3(0,0,0));
} else {
Vector3 current_position;
Get_Position(&current_position);
Vector3 pos_error = current_position - sc_position;
//TSS081501
if (Is_In_Elevator()) {
position.Z = current_position.Z;
}
// Set_Position(sc_position);
Peek_Human_Phys()->Network_State_Update(position,Vector3(0,0,0));
}
}
//-----------------------------------------------------------------------------
void SoldierGameObj::Interpret_Sc_State_Data(
HumanStateClass::HumanStateType state, int sub_state,
LPCSTR trans_name, const Vector3 & velocity, const Vector3 & sc_position)
{
WWASSERT(CombatManager::I_Am_Only_Client());
if ( ( Get_State() != state ) || ( Get_Sub_State() != sub_state ) ){
if ( ( Get_State() == HumanStateClass::TRANSITION ) && // If in TRANSITION, don't switch to TRANSITION_COMPLETE
( state == HumanStateClass::TRANSITION_COMPLETE ) ) {
// do nothing
} else if ( ( Get_State() == HumanStateClass::UPRIGHT ) && // If UPRIGHT, don't switch to LAND
( state == HumanStateClass::LAND ) ) {
// do nothing
} else {
if (Is_Controlled_By_Me() &&
((( Get_State() == HumanStateClass::UPRIGHT ) || ( Get_State() == HumanStateClass::AIRBORNE ) || ( Get_State() == HumanStateClass::LAND )) &&
(( state == HumanStateClass::UPRIGHT ) || ( state == HumanStateClass::AIRBORNE ) || ( state == HumanStateClass::LAND )) )) {
// do nothing
// } else if (Is_Controlled_By_Me() == false) {
} else {
// take the new state
if (state == HumanStateClass::TRANSITION) {
Start_Transition_Animation( trans_name, NULL );
AnimationName = trans_name;
} else if (state == HumanStateClass::ANIMATION) {
AnimationName = trans_name;
HumanState.Start_Scripted_Animation( AnimationName, true, false );
} else if (state == HumanStateClass::IN_VEHICLE) {
HumanState.Force_Animation( trans_name, false );
AnimationName = trans_name;
}
//TSS2001
// if (state != HumanStateClass::IN_VEHICLE) {
HumanState.Set_State( state, sub_state );
// }
}
}
}
if (( state == HumanStateClass::AIRBORNE ) && ( this != COMBAT_STAR ) ) {
Peek_Human_Phys()->Set_In_Contact( false );
Peek_Human_Phys()->Set_Velocity( velocity );
Peek_Human_Phys()->Set_Position( sc_position );
}
}
//-----------------------------------------------------------------------------
int SoldierGameObj::Tally_Vis_Visible_Soldiers( void )
{
int retcode = -1;
Vector3 position;
Get_Position(&position);
position.Z += 1.5f;
WWASSERT(COMBAT_SCENE != NULL);
VisTableClass * pvs = COMBAT_SCENE->Get_Vis_Table(position);
if (pvs != NULL) {
retcode = 0;
for (
SLNode<SmartGameObj> * smart_objnode = GameObjManager::Get_Smart_Game_Obj_List()->Head();
smart_objnode != NULL;
smart_objnode = smart_objnode->Next()) {
SoldierGameObj * p_soldier = smart_objnode->Data()->As_SoldierGameObj();
if (p_soldier != NULL) {
PhysClass * phys_obj = p_soldier->Peek_Physical_Object();
if (phys_obj != NULL && pvs->Get_Bit(phys_obj->Get_Vis_Object_ID())) {
retcode++;
}
}
}
}
return retcode;
}
//-----------------------------------------------------------------------------
bool SoldierGameObj::Is_In_Elevator( void )
{
HumanPhysClass * p_human_phys = Peek_Human_Phys();
return
p_human_phys != NULL &&
p_human_phys->Peek_Carrier_Object() != NULL &&
p_human_phys->Peek_Carrier_Object()->As_ElevatorPhysClass() != NULL;
}
//-----------------------------------------------------------------------------
float SoldierGameObj::Get_Max_Speed( void )
{
return Peek_Human_Phys()->Get_Normalized_Speed();
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Max_Speed( float speed )
{
Peek_Human_Phys()->Set_Normalized_Speed( speed );
}
//------------------------------------------------------------------------------------
float SoldierGameObj::Get_Turn_Rate( void )
{
return Get_Definition().TurnRate;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Generate_Control( void )
{
switch( Get_State() ) {
case HumanStateClass::DEATH:
// case HumanStateClass::WOUNDED:
// case HumanStateClass::DESTROY:
Clear_Control();
break;
default:
SmartGameObj::Generate_Control();
break;
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Apply_Control( void )
{
// if gameplay not permitted, skip
if ( !CombatManager::Is_Gameplay_Permitted() ) {
Clear_Control();
Controller.Reset();
return;
}
#ifdef WWDEBUG
// Change the control before applying
if ( IS_SOLOPLAY && Is_Human_Controlled() && Input::Get_State( INPUT_FUNCTION_DEBUG_RAPID_MOVE ) ) {
if ( InFlyMode ) {
Control.Set_Analog( ControlClass::ANALOG_MOVE_UP,
Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) );
Control.Set_Analog( ControlClass::ANALOG_MOVE_FORWARD, 0 );
} else {
Control.Set_Analog( ControlClass::ANALOG_MOVE_FORWARD,
Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) * 10 );
}
}
#endif
if ( Get_State() == HumanStateClass::IN_VEHICLE ) {
// Handle Vehicle Gunner Toggle
if ( Get_Vehicle() && Get_Vehicle()->Get_Driver() == this ) {
if ( Control.Get_Boolean( ControlClass::BOOLEAN_VEHICLE_TOGGLE_GUNNER ) ) {
Get_Vehicle()->Toggle_Driver_Is_Gunner();
}
}
if ( CombatManager::I_Am_Server() ) // Server authoritative
// if ( CombatManager::I_Am_Server() ||
// (Is_Controlled_By_Me() && TransitionCompletionData == NULL) )
{
if ( Control.Get_Boolean( ControlClass::BOOLEAN_ACTION ) ) {
TransitionManager::Check( this, true );
}
}
return;
}
if ( ( Get_State() == HumanStateClass::TRANSITION ) ||
( Get_State() == HumanStateClass::ANIMATION ) ||
( Get_State() == HumanStateClass::DESTROY ) ||
( Get_State() == HumanStateClass::DEATH ) ||
( Get_State() == HumanStateClass::ON_FIRE ) ||
( Get_State() == HumanStateClass::ON_CHEM ) ||
( Get_State() == HumanStateClass::ON_CNC_FIRE ) ||
( Get_State() == HumanStateClass::ON_CNC_CHEM ) ||
( Get_State() == HumanStateClass::ON_ELECTRIC ) ) {
// Force exit of the corpse mode
if ( Get_State() == HumanStateClass::DESTROY && Is_Human_Controlled() ) {
if ( Control.Get_Boolean( ControlClass::BOOLEAN_WEAPON_FIRE_PRIMARY ) ) {
HumanState.Set_State_Timer( 1000 ); // Done!
}
}
// Debug_Say(( "No Control in transition\n" ));
Clear_Control();
// Controller.Reset();
// return;
}
if ( Get_State() == HumanStateClass::DIVE ) {
Clear_Control();
SmartGameObj::Apply_Control();
Vector3 forced_move(0,0,0);
int sub_state = HumanState.Get_Sub_State();
if ( sub_state & HumanStateClass::SUB_STATE_FORWARD ) forced_move = Vector3( 0.5f,0,0 );
if ( sub_state & HumanStateClass::SUB_STATE_BACKWARD ) forced_move = Vector3( -0.5f,0,0 );
if ( sub_state & HumanStateClass::SUB_STATE_LEFT ) forced_move = Vector3( 0,0.5f,0 );
if ( sub_state & HumanStateClass::SUB_STATE_RIGHT ) forced_move = Vector3( 0,-0.5f,0 );
Controller.Set_Move_Forward( forced_move.X );
Controller.Set_Move_Left( forced_move.Y );
Controller.Set_Move_Up( forced_move.Z );
return;
}
#define CLIMB_SCALE 0.3f
// Skip all this if control is clear?!?!?!
if ( Get_State() == HumanStateClass::LADDER ) {
// Convert Forward motion to Up motion
float up_down = CLIMB_SCALE * Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD );
if ( Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) == 0 ) {
LadderUpMask = false;
LadderDownMask = false;
}
if ( LadderUpMask ) {
up_down = MIN( up_down, 0 );
}
if ( LadderDownMask ) {
up_down = MAX( up_down, 0 );
}
// when on ladder, clear all velocity
Control.Set_Analog( ControlClass::ANALOG_MOVE_UP, up_down );
// Can't clear this, or we wont be able to climb next net frame!!!
// Control.Set_Analog( ControlClass::ANALOG_MOVE_FORWARD, 0 );
Control.Set_Analog( ControlClass::ANALOG_MOVE_LEFT, 0 );
Control.Set_Analog( ControlClass::ANALOG_TURN_LEFT, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_JUMP, 0 );
} else {
LadderUpMask = false;
LadderDownMask = false;
// no move up
if ( !InFlyMode ) {
Control.Set_Analog( ControlClass::ANALOG_MOVE_UP, 0 );
}
}
#if 0
if ( Control.Get_Boolean( ControlClass::BOOLEAN_CROUCH ) ) {
if ( HumanState.Is_Sub_State_Adjustable() ) {
// HumanState.Set_Sub_State( Get_Sub_State() ^ HumanStateClass::CROUCHED );
HumanState.Toggle_State_Flag( HumanStateClass::CROUCHED_FLAG );
if ( this == COMBAT_STAR ) {
Vector3 pos;
Get_Position( &pos );
if ( Is_Crouched() ) {
DIAG_LOG(( "COEN", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
} else {
DIAG_LOG(( "COEX", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
}
}
}
#else
if ( HumanState.Is_Sub_State_Adjustable() ) {
bool new_state = Control.Get_Boolean( ControlClass::BOOLEAN_CROUCH );
bool old_state = HumanState.Get_State_Flag( HumanStateClass::CROUCHED_FLAG );
if ( new_state != old_state ) {
HumanState.Toggle_State_Flag( HumanStateClass::CROUCHED_FLAG );
if ( this == COMBAT_STAR ) {
Vector3 pos;
Get_Position( &pos );
if ( Is_Crouched() ) {
DIAG_LOG(( "COEN", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
} else {
DIAG_LOG(( "COEX", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
}
}
}
#endif
/*
if ( CombatManager::I_Am_Server() &&
Control.Get_Boolean(ControlClass::BOOLEAN_DROP_FLAG) ) {
CombatManager::Soldier_Drops_Flag(this);
}
*/
DetonateC4 = false;
if ( Get_Weapon() && Control.Get_Boolean( ControlClass::BOOLEAN_WEAPON_USE ) ) {
if ( Get_Weapon()->Get_Style() == WEAPON_HOLD_STYLE_C4 ) {
DetonateC4 = true;
}
if ( Get_Weapon()->Get_Can_Snipe() ) {
if ( HumanState.Is_Sub_State_Adjustable() ) {
HumanState.Toggle_State_Flag( HumanStateClass::SNIPING_FLAG );
}
}
}
#if 0
if ( Is_Sniping() ) {
// No motion for snipers (I don't know if this should be in Soldier.cpp)
// (But then, Sniper mode means nothing for plain soldiers, only for players)
// Don't clear the move forward, just don't allow the controller to have
// any move forward. This was not alowing sniper zoom
// Control.Set_Analog( ControlClass::ANALOG_MOVE_FORWARD, 0 );
Control.Set_Analog( ControlClass::ANALOG_MOVE_LEFT, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_JUMP, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_CROUCH, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_FORWARD, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_BACKWARD, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_LEFT, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_RIGHT, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_ACTION, 0 ); // stop ladder
}
#endif
if ( Is_Sniping() || Is_On_Ladder() ) {
// No diving for snipers or on ladders
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_FORWARD, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_BACKWARD, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_LEFT, 0 );
Control.Set_Boolean( ControlClass::BOOLEAN_DIVE_RIGHT, 0 );
}
bool dove = false;
// Can only dive if upright
if ( Get_State() == HumanStateClass::UPRIGHT ) {
if ( Control.Get_Boolean( ControlClass::BOOLEAN_DIVE_FORWARD ) ) {
HumanState.Set_State( HumanStateClass::DIVE, HumanStateClass::SUB_STATE_FORWARD );
dove = true;
}
if ( Control.Get_Boolean( ControlClass::BOOLEAN_DIVE_BACKWARD ) ) {
HumanState.Set_State( HumanStateClass::DIVE, HumanStateClass::SUB_STATE_BACKWARD );
dove = true;
}
if ( Control.Get_Boolean( ControlClass::BOOLEAN_DIVE_LEFT ) ) {
HumanState.Set_State( HumanStateClass::DIVE, HumanStateClass::SUB_STATE_LEFT );
dove = true;
}
if ( Control.Get_Boolean( ControlClass::BOOLEAN_DIVE_RIGHT ) ) {
HumanState.Set_State( HumanStateClass::DIVE, HumanStateClass::SUB_STATE_RIGHT );
dove = true;
}
if ( dove && this == COMBAT_STAR ) {
Vector3 pos;
Get_Position( &pos );
DefenseObjectClass * defense = Get_Defense_Object();
const char * weapon_name = "";
int ammo = 0;
if ( Get_Weapon() != NULL ) {
weapon_name = Get_Weapon()->Get_Definition()->Get_Name();
ammo = Get_Weapon()->Get_Total_Rounds();
}
DIAG_LOG(( "ROUS", "%1.2f; %1.2f; %1.2f; %1.2f; %1.2f; %s; %d", pos.X, pos.Y, pos.Z, defense->Get_Shield_Strength(), defense->Get_Health(), weapon_name, ammo ));
}
}
// Handle facing
float amount = Control.Get_Analog( ControlClass::ANALOG_TURN_LEFT );
if ( COMBAT_STAR == this ) { // Star gets turning from the camera
amount = 0;
}
if ( amount != 0 ) {
float heading = Peek_Human_Phys()->Get_Heading();
heading += amount * Get_Turn_Rate() * TimeManager::Get_Frame_Seconds();
heading = WWMath::Wrap( heading, DEG_TO_RADF( -180.0f ), DEG_TO_RADF( 180.0f ) );
Peek_Human_Phys()->Set_Heading(heading);
Control.Set_Analog(ControlClass::ANALOG_TURN_LEFT,0.0f);
if ( !Is_Human_Controlled() ) { // human players don't use turn anims
HumanState.Set_Turn_Velocity( amount ); // play the leg turning anim
}
}
// Let parent class handle the rest
SmartGameObj::Apply_Control();
#if 01
// Have to Move_Up after after Apply control, but BOOLEAN_JUMP is cleared
if ( Control.Get_Boolean( ControlClass::BOOLEAN_JUMP ) ) {
if ( Get_State() != HumanStateClass::AIRBORNE ) {
Controller.Set_Move_Up( Get_Definition().JumpVelocity );
}
if ( this == COMBAT_STAR ) {
Vector3 pos;
Get_Position( &pos );
DefenseObjectClass * defense = Get_Defense_Object();
const char * weapon_name = "";
int ammo = 0;
if ( Get_Weapon() != NULL ) {
weapon_name = Get_Weapon()->Get_Definition()->Get_Name();
ammo = Get_Weapon()->Get_Total_Rounds();
}
DIAG_LOG(( "JUUS", "%1.2f; %1.2f; %1.2f; %1.2f; %1.2f; %s; %d", pos.X, pos.Y, pos.Z, defense->Get_Shield_Strength(), defense->Get_Health(), weapon_name, ammo ));
}
}
#else
static float jump_timer = 0;
// Have to Move_Up after after Apply control, but BOOLEAN_JUMP is cleared
if ( Control.Get_Boolean( ControlClass::BOOLEAN_JUMP ) ) {
if ( Get_State() != HumanStateClass::AIRBORNE ) {
HumanState.Set_State( HumanStateClass::AIRBORNE, HumanState.Get_Sub_State() );
jump_timer = 0.2f;
}
}
if ( jump_timer > 0 ) {
jump_timer -= TimeManager::Get_Frame_Seconds();
if ( jump_timer <= 0 ) {
Controller.Set_Move_Up( Get_Definition().JumpVelocity );
}
}
#endif
#if 0
if ( Is_Sniping() ) {
// Dont allow move forward. It may have been requested by the
// Control, because we can't clear it if it must persist for
// network sniper zoom. So just clear it here.
Controller.Set_Move_Forward( 0 );
}
#else
if ( Is_Sniping() ) {
// Dont allow move forward. It may have been requested by the
// Control, because we can't clear it if it must persist for
// network sniper zoom. So just clear it here.
Controller.Set_Move_Forward( WWMath::Clamp( Controller.Get_Move_Forward(), -0.25f, 0.25f ) );
Controller.Set_Move_Left( WWMath::Clamp( Controller.Get_Move_Left(), -0.25f, 0.25f ) );
}
#endif
if ( Get_State() == HumanStateClass::LADDER ) {
// When on ladder, you can't move forward
// Same rules as above wrt the network persistence
Controller.Set_Move_Forward( 0 );
}
if ( ( Get_State() == HumanStateClass::UPRIGHT ) && Is_Crouched() ) {
float crouch_speed = GlobalSettingsDef::Get_Global_Settings ()->Get_Soldier_Crouch_Speed();
Controller.Set_Move_Forward( Controller.Get_Move_Forward() * crouch_speed );
Controller.Set_Move_Left( Controller.Get_Move_Left() * crouch_speed );
} else if ( Control.Get_Boolean( ControlClass::BOOLEAN_WALK ) ) {
float walk_speed = GlobalSettingsDef::Get_Global_Settings ()->Get_Soldier_Walk_Speed();
Controller.Set_Move_Forward( Controller.Get_Move_Forward() * walk_speed );
Controller.Set_Move_Left( Controller.Get_Move_Left() * walk_speed );
}
if ( this == COMBAT_STAR ) {
static bool was_walking = false;
if ( Control.Get_Boolean( ControlClass::BOOLEAN_WALK ) != was_walking ) {
Vector3 pos;
Get_Position( &pos );
if ( !was_walking ) {
DIAG_LOG(( "WAEN", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
} else {
DIAG_LOG(( "WAEX", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
was_walking = Control.Get_Boolean( ControlClass::BOOLEAN_WALK );
}
}
if ( this == COMBAT_STAR && Control.Get_Boolean( ControlClass::BOOLEAN_ACTION ) ) {
Vector3 pos;
COMBAT_STAR->Get_Position( &pos );
DIAG_LOG(( "ACPR", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
if ( CombatManager::I_Am_Server() ||
(Is_Controlled_By_Me() && TransitionCompletionData == NULL) )
{
bool action_triggered = Control.Get_Boolean( ControlClass::BOOLEAN_ACTION );
/// Transitions only trigger on server
bool transition_triggered = false;
if ( CombatManager::I_Am_Server() ) {
transition_triggered = TransitionManager::Check( this, action_triggered );
}
if ( !transition_triggered ) {
if ( action_triggered ) {
//
// Lookup the current target
//
// DamageableGameObj *damageable_target = HUDInfo::Get_Weapon_Target_Object();
DamageableGameObj *damageable_target = HUDInfo::Get_Info_Object();
if ( damageable_target != NULL ) {
PhysicalGameObj *physical_target = damageable_target->As_PhysicalGameObj();
if ( physical_target != NULL ) {
Vector3 target_pos;
physical_target->Get_Position( &target_pos );
Vector3 my_pos;
Get_Position( &my_pos );
//
// Check to see if the target is within the "poke" range
//
if ( (target_pos - my_pos).Length() <= 2 ) {
//
// Notify all the observers
//
if ( CombatManager::I_Am_Server () ) {
const GameObjObserverList & observer_list = physical_target->Get_Observers();
for( int index = 0; index < observer_list.Count(); index++ ) {
observer_list[ index ]->Poked( physical_target, this );
}
}
//
// Was the player the soldier who did the poking?
//
if ( COMBAT_STAR == this ) {
//
// Display this object in the encyclopedia
//
EncyclopediaMgrClass::Reveal_Object( damageable_target );
//
// Check for player terminal access
//
if ( physical_target->As_SimpleGameObj () != NULL ) {
//
// Is this a player terminal?
//
PlayerTerminalClass::TYPE type = PlayerTerminalClass::TYPE_NONE;
type = (physical_target->As_SimpleGameObj())->Get_Definition().Get_Player_Terminal_Type();
if (type != PlayerTerminalClass::TYPE_NONE) {
//
// Show the player terminal
//
PlayerTerminalClass::Get_Instance()->Display_Terminal( this, type );
}
}
}
}
}
}
}
} else {
// We started a transition, clear the control
Controller.Reset();
}
}
// Override the following controls
if ( IS_SOLOPLAY && Is_Human_Controlled() && Input::Get_State( INPUT_FUNCTION_DEBUG_RAPID_MOVE ) ) {
if ( Control.Get_Boolean( ControlClass::BOOLEAN_JUMP ) ) {
Controller.Set_Move_Up( Get_Definition().JumpVelocity );
}
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Handle_Legs( void )
{
#if 0
if ( Get_State() != HumanStateClass::UPRIGHT ) {
LegFacing = Get_Facing();
SyncLegs = false;
}
// If Moving, clear LegFacing
if ((Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) != 0.0f ) ||
(Control.Get_Analog( ControlClass::ANALOG_MOVE_LEFT ) != 0.0f )) {
LegFacing = Get_Facing();
SyncLegs = false;
} else {
#define CLAMP_DEGREES 60
#define SYNC_DEGREES 35
#define SYNC_RATE 75
#define FLIP_RATE 720
// find the leg difference;
LegFacing = WWMath::Wrap( LegFacing, DEG_TO_RADF( -180 ), DEG_TO_RADF( 180 ) );
float legs_rotation = Get_Facing() - LegFacing;
legs_rotation = WWMath::Wrap( legs_rotation, DEG_TO_RADF( -180 ), DEG_TO_RADF( 180 ) );
// Clamp to with 90
legs_rotation = WWMath::Clamp( legs_rotation, DEG_TO_RADF( -CLAMP_DEGREES ), DEG_TO_RADF( CLAMP_DEGREES ) );
LegFacing = Get_Facing() - legs_rotation;
LegFacing = WWMath::Wrap( LegFacing, DEG_TO_RADF( -180 ), DEG_TO_RADF( 180 ) );
// if legs are more than 30 degrees off, start correcting
if ( WWMath::Fabs( legs_rotation ) > DEG_TO_RAD( SYNC_DEGREES ) ) {
SyncLegs = true;
}
SyncLegs = true;
// if syncing, start moving legs to match rotation
if ( SyncLegs ) {
float move = DEG_TO_RAD( SYNC_RATE ) * TimeManager::Get_Frame_Seconds() *
WWMath::Sign( legs_rotation );
if ( WWMath::Fabs( move ) >= WWMath::Fabs( legs_rotation ) ) {
move = legs_rotation; // Complete syncing
SyncLegs = false;
} else {
LegFacing += move;
if ( !Is_Human_Controlled() ) { // human players don't use turn anims
HumanState.Set_Turn_Velocity( move ); // Also, play the leg turning anim
}
}
}
}
if ( !SyncLegs ) {
HumanState.Set_Turn_Velocity( 0 );
}
// 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 = Peek_Model()->Get_Bone_Index( "root" );
}
static int torso_bone = -1;
if ( torso_bone == -1 ) { // Get torso bone index
torso_bone = Peek_Model()->Get_Bone_Index( "thorax" );
}
// Update the model
float legs_rotation = Get_Facing() - LegFacing;
if ( legs_rotation ) {
WWASSERT( root_bone != -1 );
WWASSERT( torso_bone != -1 );
if ( !Peek_Model()->Is_Bone_Captured( root_bone ) ) {
Peek_Model()->Capture_Bone( root_bone );
}
if ( !Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
Peek_Model()->Capture_Bone( torso_bone );
}
// LOOK INTO RELATIVE_CONTROL_BONE
Matrix3D root_adjust(1); // adjust it
root_adjust.Rotate_Z( -legs_rotation );
Peek_Model()->Control_Bone( root_bone, root_adjust );
Matrix3D legs_adjust(1); // adjust it
legs_adjust.Rotate_Z( legs_rotation );
Peek_Model()->Control_Bone( torso_bone, legs_adjust );
} else { // no adjustment, release
if ( Peek_Model()->Is_Bone_Captured( root_bone ) ) {
Peek_Model()->Release_Bone( root_bone );
}
if ( Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
Peek_Model()->Release_Bone( torso_bone );
}
}
#else
#if 0
float legs_rotation = 0;
// Compare the facing to the motion, set leg_racing to the difference
Vector3 move( Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ), Control.Get_Analog( ControlClass::ANALOG_MOVE_LEFT ), 0 );
if ( move.Length() > 0 ) {
float move_direction = ::WWMath::Atan2( -move.Y, move.X );
float diff = move_direction;
diff += 2*DEG_TO_RADF( 360 ) + DEG_TO_RADF( 45 );
diff -= WWMath::Floor( diff / DEG_TO_RADF( 90 ) ) * DEG_TO_RADF( 90 );
diff -= DEG_TO_RADF( 45 );
legs_rotation = diff;
Debug_Say(( "Move (%1.1f) %1.1f %1.1f %1.1f %1.1f\n", RAD_TO_DEG(diff), move.X, move.Y, move.Z, RAD_TO_DEG( move_direction ) ));
}
// 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 = Peek_Model()->Get_Bone_Index( "c spine" );
}
static int torso_bone = -1;
if ( torso_bone == -1 ) { // Get torso bone index
torso_bone = Peek_Model()->Get_Bone_Index( "c spine1" );
}
if ( legs_rotation ) {
WWASSERT( root_bone != -1 );
WWASSERT( torso_bone != -1 );
if ( !Peek_Model()->Is_Bone_Captured( root_bone ) ) {
Peek_Model()->Capture_Bone( root_bone );
}
if ( !Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
Peek_Model()->Capture_Bone( torso_bone );
}
Matrix3D root_adjust(1); // adjust it
root_adjust.Rotate_X( legs_rotation );
Peek_Model()->Control_Bone( root_bone, root_adjust );
Matrix3D legs_adjust(1); // adjust it
legs_adjust.Rotate_X( -legs_rotation );
Peek_Model()->Control_Bone( torso_bone, legs_adjust );
} else { // no adjustment, release
if ( Peek_Model()->Is_Bone_Captured( root_bone ) ) {
Peek_Model()->Release_Bone( root_bone );
}
if ( Peek_Model()->Is_Bone_Captured( torso_bone ) ) {
Peek_Model()->Release_Bone( torso_bone );
}
}
#endif
#endif
bool do_steps = false;
if ( Is_On_Ladder() ) {
do_steps = (Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) != 0.0f );
} else {
do_steps = ((Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) != 0.0f ) ||
(Control.Get_Analog( ControlClass::ANALOG_MOVE_LEFT ) != 0.0f ));
}
// Footsteps
if (!Is_Sniping() && !InFlyMode && CombatManager::Is_Gameplay_Permitted() && do_steps && Is_Control_Enabled() ) {
bool leg_mode = HumanState.Get_Leg_Mode();
// Watch for the legs to reach certain percentage completions
if ( leg_mode != LastLegMode ) {
int my_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_RUN;
if ( Is_Crouched() ) {
my_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_CROUCHED;
} else if ( HumanState.Get_Sub_State() & HumanStateClass::SUB_STATE_SLOW ) {
my_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_WALK;
}
int ground_type = Peek_Human_Phys()->Get_Contact_Surface_Type();
// Try effects on ladders again BMG
/**/if ( Is_On_Ladder() ) {
my_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_LADDER;
ground_type = SURFACE_TYPE_LIGHT_METAL;
}/**/
Matrix3D tm;
tm = Get_Transform();
if ( Control.Get_Analog( ControlClass::ANALOG_MOVE_FORWARD ) != 0.0f ) {
tm.Rotate_Z( DEG_TO_RAD( -90 ) );
}
float offset = leg_mode ? -0.15f : 0.1f;
tm.Translate( Vector3( offset, 0.3f, 0 ) );
bool allow_emitters = !Is_Stealthed();
SurfaceEffectsManager::Apply_Effect( ground_type, my_type, tm, NULL, this, true, allow_emitters);
LastLegMode = leg_mode;
}
}
}
static float _shake_delay = 0;
static float _cry_delay = 0;
static char * _profile_name = "Soldier Think";
//------------------------------------------------------------------------------------
void SoldierGameObj::Think( void )
{
{ WWPROFILE( _profile_name );
if ( this == COMBAT_STAR ) {
_shake_delay -= TimeManager::Get_Frame_Seconds();
_cry_delay -= TimeManager::Get_Frame_Seconds();
}
/*
ActionClass * p_action = Get_Action();
WWASSERT(p_action != NULL);
*/
//
// Simply check to see if this soldier has entered a coordination zone (which bound
// the entrances/exits of ladders and elevators). If so, then disable
// collision between them and all other soldiers.
//
Vector3 position;
{
WWPROFILE("Coordination Zone");
Get_Position( &position );
if ( UnitCoordinationZoneMgr::Is_Unit_In_Zone( position ) ) {
Enable_Ghost_Collision( true );
} else if ( Is_Safe_To_Disable_Ghost_Collision( position ) ) {
Enable_Ghost_Collision( false );
}
}
//
// Display a debug box to show the ghosted collision as ncessary
//
if ( DisplayDebugBoxForGhostCollision &&
(Peek_Physical_Object ()->Get_Collision_Group() == SOLDIER_GHOST_COLLISION_GROUP))
{
WWPROFILE("Add_Debug_AABox");
AABoxClass soldier_box;
soldier_box.Center = position + Vector3( 0, 0, 1.0F );
soldier_box.Extent.Set( 0.3F, 0.3F, 1.0F );
PhysicsSceneClass::Get_Instance ()->Add_Debug_AABox( soldier_box, Vector3( 1.0F, 0.0F, 0.25F ) );
}
// Stats
if ( Get_Player_Data() != NULL ) {
WWPROFILE("Stats");
Get_Player_Data()->Stats_Add_Game_Time( TimeManager::Get_Frame_Seconds() );
Get_Player_Data()->Stats_Set_Final_Health( Get_Defense_Object()->Get_Health() );
if ( Get_Vehicle() != NULL ) {
Get_Player_Data()->Stats_Add_Vehicle_Time( TimeManager::Get_Frame_Seconds() );
}
}
//
// Update the soldier's facing
//
{
WWPROFILE("Update_Locked_Facing");
Update_Locked_Facing();
}
/*
//
// In CTF a flag-bearer may not be permitted to use weapons
// This code will deselect the weapon if that is the case.
//
if (CombatManager::I_Am_Server() && Get_Weapon() != NULL &&
!CombatManager::Is_Firing_Enabled(this)) {
Get_Weapon_Bag()->Deselect();
}
*/
// Handle_Legs moved form Apply_Control because clients don't run it for server objects
{
WWPROFILE("Handle_Legs");
Handle_Legs();
}
/*
if (CombatManager::I_Am_Server()) {
TransitionManager::Check( this );
}*/
}
{
WWPROFILE( "Embedded smart think in soldier" );
SmartGameObj::Think(); // Perform smart object thinking ( apply controls )
}
{
WWPROFILE( _profile_name );
if ( CombatManager::I_Am_Server() ) {
WWPROFILE("Handle C4");
// Handle C4 in a special way. When C4 is fired, the human plays
// a crouching animation, and starts a c4 placement timer.
if ( Get_Weapon() &&
(Get_Weapon()->Get_Style() == WEAPON_HOLD_STYLE_C4) &&
(Get_Weapon()->Is_Firing()) &&
(Get_State() == HumanStateClass::UPRIGHT) ) {
AnimationName = "s_a_human.h_a_j12c";
HumanState.Start_Scripted_Animation( AnimationName, true, false );
}
}
if ( Get_State() != HumanStateClass::IN_VEHICLE ) {
WWPROFILE("Vehicle");
// This may try to change controls, so can't be in Post_Think
HumanState.Update_Weapon( Get_Weapon(), WeaponBag->Is_Changed() );
if ( WeaponBag->Is_Changed() ) {
WeaponChanged = true;
WeaponBag->Reset_Changed();
}
// HumanState.Update_Aiming( Get_Weapon_Tilt(), Get_Weapon_Turn() );
HumanState.Update_State();
// Remove C4 from hand if empty
if ( Get_Weapon() && WeaponRenderModel ) {
if ( Get_Weapon()->Get_Style() == WEAPON_HOLD_STYLE_C4 || Get_Weapon()->Get_Style() == WEAPON_HOLD_STYLE_BEACON ) {
WeaponRenderModel->Set_Hidden( !Get_Weapon()->Is_Loaded() );
} else {
WeaponRenderModel->Set_Hidden( false );
}
}
} else {
// Debug_Say(( "No state update in vehicle\n" ));
}
/*
** Special Death
*/
// ArmorWarheadManager::SpecialDamageType SpecialDamageMode;
// float SpecialDamageTimer;
if ( SpecialDamageMode != ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE &&
SpecialDamageTimer > 0 ) {
WWPROFILE("Special Damage");
float previous_timer = SpecialDamageTimer;
SpecialDamageTimer -= TimeManager::Get_Frame_Seconds();
// Once a second, make an explosion
if ( (int)SpecialDamageTimer != (int)previous_timer ) {
StringClass explosion_name = ArmorWarheadManager::Get_Special_Damage_Explosion( SpecialDamageMode );
if ( !explosion_name.Is_Empty() ) {
ExplosionDefinitionClass * def = (ExplosionDefinitionClass *)DefinitionMgrClass::Find_Typed_Definition( explosion_name, CLASSID_DEF_EXPLOSION );
if ( def != NULL) {
Vector3 pos = Get_Bullseye_Position();
ExplosionManager::Create_Explosion_At( def->Get_ID(), pos, NULL );
}
}
}
// Fix to allow taking fire damage in CNC
// if ( Get_Defense_Object()->Get_Health() > 0 && Allow_Special_Damage_State_Lock () ) {
if ( Get_Defense_Object()->Get_Health() > 0 &&
(Allow_Special_Damage_State_Lock () || Is_Human_Controlled() ) ) {
// do damage
WarheadType warhead = ArmorWarheadManager::Get_Special_Damage_Warhead( SpecialDamageMode );
float damage = ArmorWarheadManager::Get_Special_Damage_Scale( SpecialDamageMode ) *
TimeManager::Get_Frame_Seconds();
OffenseObjectClass off( damage, warhead, (ArmedGameObj*)SpecialDamageDamager.Get_Ptr() );
// Apply_Damage( off, 1 );
Apply_Damage_Extended( off, 1 );
}
if ( HumanState.Get_State() != HumanStateClass::DEATH ) {
// if dead, play death
if ( Get_Defense_Object()->Get_Health() <= 0 ) {
HumanState.Set_State( HumanStateClass::DEATH,
SpecialDamageMode - ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_FIRE + HumanStateClass::OUCH_FIRE );
}
if ( SpecialDamageTimer <= 0 ) { // Stop the flame
// HumanState.Set_State( HumanStateClass::UPRIGHT );
Set_Special_Damage_Mode( ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE );
}
}
}
if (Get_State() == HumanStateClass::DESTROY) {
if ( HumanState.Get_State_Timer() > CORPSE_PERSIST_TIME ) {
// If Human Controlled, drop a backpack
if ( Is_Human_Controlled() ) {
// PowerUpGameObj::Create_Backpack( this ); // No more backpacks
}
Set_Delete_Pending();
}
}
// ClientOnlys doen't handle TRANSITION_COMPLETE
if ( !CombatManager::I_Am_Only_Client() || Is_Controlled_By_Me()) {
if ( Get_State() == HumanStateClass::TRANSITION_COMPLETE ) {
if ( TransitionCompletionData != NULL ) {
// Debug_Say(( "Ended Transition %p\n", Transition ));
// We just completed a transition, notify
TransitionInstanceClass::End( this, TransitionCompletionData );
TransitionCompletionData = NULL;
} else {
// Debug_Say(( "Ended Unknown Transition %p\n", Transition ));
HumanState.Set_State( HumanStateClass::UPRIGHT );
}
}
}
//
// Remove the emot icon (if necessary)
//
{
WWPROFILE("EmotIcon");
EmotIconTimer -= TimeManager::Get_Frame_Seconds();
if ( EmotIconTimer <= 0 ) {
//
// Remove the emoticon
//
if ( EmotIconModel != NULL && EmotIconModel->Is_In_Scene() ) {
EmotIconModel->Remove();
REF_PTR_RELEASE( EmotIconModel );
}
} else if ( EmotIconModel != NULL ) {
//
// Put the icon over the soldier's head
//
Matrix3D tm = Get_Transform();
tm.Set_Translation (tm.Get_Translation() + Vector3 (0, 0, EMOT_ICON_HEIGHT));
EmotIconModel->Set_Transform( tm );
}
}
//
// Should we change the idle facial animation?
//
GenerateIdleFacialAnimTimer -= TimeManager::Get_Frame_Seconds();
if ( GenerateIdleFacialAnimTimer <= 0 ) {
WWPROFILE("FacialAnims");
//
// Change the facial animation
//
if ( HeadModel != NULL ) {
// Don't stop a playing script animation
if ( ( HeadModel->Peek_Animation() == NULL ) ||
(HeadModel->Peek_Animation() == SpeechAnim ) ) {
SpeechAnim->Generate_Idle_Animation( 20, 0.5F );
HeadModel->Set_Animation( SpeechAnim, 0, RenderObjClass::ANIM_MODE_LOOP );
}
}
//
// Reset the timer
//
GenerateIdleFacialAnimTimer = 100.0F;
}
/*
if (!Is_Destroy()) {
CombatManager::Set_Soldier_Tint(this);
}
*/
// Apply Surface damage
{
WWPROFILE("Apply_Damage");
if ( Peek_Human_Phys() ) {
SurfaceEffectsManager::Apply_Damage( Peek_Human_Phys()->Get_Contact_Surface_Type(), this );
}
}
// Update the water wake
// - If our feet are not on "underwater dirt" we don't even check for water
// - Otherwise, do a ray cast to find the water surface, if it hits
{
WWPROFILE("Water");
bool in_water = false;
Vector3 p0 = Get_Transform().Get_Translation();
Vector3 p1 = Get_Bullseye_Position();
int hit_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_RUN;
if ( Is_Crouched() ) {
hit_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_CROUCHED;
} else if ( HumanState.Get_Sub_State() & HumanStateClass::SUB_STATE_SLOW ) {
hit_type = SurfaceEffectsManager::HITTER_TYPE_FOOTSTEP_WALK;
}
Vector3 vel;
Peek_Human_Phys()->Get_Velocity(&vel);
if ((Peek_Human_Phys()->Get_Contact_Surface_Type() == SURFACE_TYPE_UNDERWATER_DIRT) &&
(vel.Length2() > 0.1f))
{
// Raycast to find water surface
CastResultStruct res;
LineSegClass ray(p0,p1);
PhysRayCollisionTestClass raytest(ray,&res,BULLET_COLLISION_GROUP,COLLISION_TYPE_PROJECTILE);
Peek_Human_Phys()->Inc_Ignore_Counter();
COMBAT_SCENE->Cast_Ray(raytest);
Peek_Human_Phys()->Dec_Ignore_Counter();
// if found update emitter
if ((res.Fraction < 1.0f) && (res.SurfaceType == SURFACE_TYPE_WATER_PERMEABLE)) {
Vector3 point;
ray.Compute_Point(res.Fraction,&point);
SurfaceEffectsManager::Update_Persistant_Emitter( WaterWake,
res.SurfaceType,
hit_type,
Matrix3D(point));
in_water = true;
}
}
if (!in_water) {
SurfaceEffectsManager::Update_Persistant_Emitter( WaterWake,
SURFACE_TYPE_DEFAULT,
hit_type,
Matrix3D(p0));
}
}
// Punish update
if ( Get_Player_Data() && Get_Player_Data()->Get_Punish_Timer() > 0 ) {
Get_Player_Data()->Inc_Punish_Timer( TimeManager::Get_Frame_Seconds() ) ;
}
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Post_Think( void )
{
if ( Get_State() == HumanStateClass::IN_VEHICLE ) {
SmartGameObj::Post_Think();
return;
}
{ WWPROFILE( "Soldier PostThink" );
HumanState.Post_Think();
bool update_weapon = false;
if ( WeaponChanged ) {
WeaponChanged = false;
Update_Back_Gun();
update_weapon = true;
}
if ( ( Get_Weapon() != NULL ) && ( Get_Weapon()->Is_Model_Update_Needed() ) ) {
update_weapon = true;
Get_Weapon()->Reset_Model_Update(); // reset model update needed
}
if ( update_weapon ) {
if ( Get_Weapon() != NULL ) {
Set_Weapon_Model( Get_Weapon()->Get_Model_Name() );
} else {
Set_Weapon_Model( NULL );
}
}
// if ( Get_Weapon()->Is_Anim_Update_Needed() ) {
// Set_Weapon_Animation( Get_Weapon()->Get_Anim_Name() );
// Get_Weapon()->Reset_Anim_Update(); // reset model anim update needed
// }
if (WeaponAnimControl) {
WeaponAnimControl->Update( TimeManager::Get_Frame_Seconds() ); // update the animation control
}
Handle_Head_look();
if ( Get_Weapon() != NULL && Get_State() == HumanStateClass::ON_FIRE ) {
Get_Weapon()->Set_Primary_Triggered( false );
Get_Weapon()->Set_Secondary_Triggered( false );
}
}
SmartGameObj::Post_Think();
Update_Healing_Effect();
}
//------------------------------------------------------------------------------------
const Matrix3D & SoldierGameObj::Get_Muzzle( int index )
{
static Matrix3D _muzzle(1);
if ( WeaponRenderModel != NULL ) {
Matrix3D true_muzzle = WeaponRenderModel->Get_Bone_Transform( "muzzlea0" );
Vector3 muzzle_pos = true_muzzle.Get_Translation();
_muzzle.Obj_Look_At( muzzle_pos, Get_Targeting_Pos(), 0 );
if ( !Is_Human_Controlled() ) {
// If the bullet is not close to going down the muzzle, force it to be
Vector3 to_target = _muzzle.Get_X_Vector();
Vector3 down_muzzle = true_muzzle.Get_X_Vector();
float cos = Vector3::Dot_Product( to_target, down_muzzle );
if ( cos < WWMath::Cos( DEG_TO_RADF( 20 ) ) ) {
_muzzle = true_muzzle;
}
}
}
return _muzzle;
}
static int head_bone = -1;
static int neck_bone = -1;
//------------------------------------------------------------------------------------
Matrix3D SoldierGameObj::Get_Look_Transform(void)
{
if ( head_bone != -1 ) {
// Convert from CS head convention back to normal
Matrix3D tm = Peek_Model()->Get_Bone_Transform( head_bone );
tm.Rotate_Z( DEG_TO_RAD( 90 ) );
tm.Rotate_X( DEG_TO_RAD( 90 ) );
return tm;
}
return Get_Transform();
}
//------------------------------------------------------------------------------------
#define HEAD_TURN_LIMIT DEG_TO_RADF( 70 )
#define HEAD_TILT_LIMIT DEG_TO_RADF( 20 )
void SoldierGameObj::Look_Random( float time )
{
if ( time == 0 && HeadLookDuration != 0 ) {
HeadLookDuration = 0.0001f; // maybe done next time...
} else {
HeadLookDuration = time;
}
HeadLookAngleTimer = 0;
HeadLookAngle = Vector3( 1,1,1 );
}
////////////////////////////////////////////////////////////////
// Clamp_Angle
////////////////////////////////////////////////////////////////
static inline float
Clamp_Angle (float angle, float min_angle, float max_angle)
{
//
// Make sure all the parameters are in the same range
//
angle = WWMath::Wrap (angle, 0, DEG_TO_RADF (360));
min_angle = WWMath::Wrap (min_angle, 0, DEG_TO_RADF (360));
max_angle = WWMath::Wrap (max_angle, 0, DEG_TO_RADF (360));
float result = angle;
if (min_angle <= max_angle) {
//
// Handle the 'typical' case where there is no 360-mark wrap-around
//
if (angle < min_angle) {
result = min_angle;
} else if (angle > max_angle) {
result = max_angle;
}
} else {
//
// Handle the 360-mark wrap-around case
//
if (angle < min_angle && angle > max_angle) {
float min_delta = min_angle - angle;
float max_delta = angle - max_angle;
//
// Which edge is the angle closer to?
//
if (min_delta < max_delta) {
result = min_angle;
} else {
result = max_angle;
}
}
}
return result;
}
void SoldierGameObj::Handle_Head_look( void )
{
if ( Peek_Model ()->Get_HTree () == NULL ) {
return ;
}
//
// Get the head bone
//
if ( head_bone == -1 || neck_bone == -1) {
head_bone = Peek_Model()->Get_Bone_Index( "C HEAD" );
neck_bone = Peek_Model()->Get_Bone_Index( "C NECK" );
WWASSERT( head_bone != -1 );
WWASSERT( neck_bone != -1 );
}
if ( HeadLookDuration > 0 ) {
HeadLookDuration -= TimeManager::Get_Frame_Seconds();
// Should we be returning to look ahead?
bool returning = HeadLookDuration < 0;
//Matrix3D head(1);
Vector3 desired_head_rotation( 0,0,0 );
if ( !returning ) {
if ( HeadLookAngle.Length() > 0.001f ) {
HeadLookAngleTimer -= TimeManager::Get_Frame_Seconds();
if ( HeadLookAngleTimer < 0 ) {
HeadLookAngle = Vector3(
FreeRandom.Get_Float( -HEAD_TURN_LIMIT, HEAD_TURN_LIMIT ),
FreeRandom.Get_Float( -HEAD_TILT_LIMIT, HEAD_TILT_LIMIT ) ,0);
// Debug_Say(( "New Look Turn %f Tilt %f\n", RAD_TO_DEG(HeadLookAngle.X), RAD_TO_DEG(HeadLookAngle.Y) ));
HeadLookAngleTimer = FreeRandom.Get_Float( 2, 5 );
}
desired_head_rotation = HeadLookAngle;
} else {
//
// Release the captured bone, this will have the effect of causing the Get_Bone_Transform ()
// methods to return the un-modified (due to being controlled) transform of the bone.
//
/*if ( Peek_Model()->Is_Bone_Captured( head_bone ) ) {
Peek_Model()->Release_Bone( head_bone );
}*/
///
// Get the transform that has been used to modify the head bone...
//
const HTreeClass *htree = Peek_Model()->Get_HTree();
WWASSERT( htree != NULL );
Matrix3D bone_control_tm( 1 );
htree->Get_Bone_Control( head_bone, bone_control_tm );
//
// Get the inverse of the head-bone transform
//
Matrix3D inv_bone_control_tm;
bone_control_tm.Get_Orthogonal_Inverse (inv_bone_control_tm);
//
// Get the head to world and neck to world transforms
//
Matrix3D cur_head = Peek_Model()->Get_Bone_Transform( head_bone );
Matrix3D cur_neck = Peek_Model()->Get_Bone_Transform( neck_bone );
//
// Strip off the control transform from last frame
//
cur_head = cur_head * inv_bone_control_tm;
//
// Get the world to neck transform
//
Matrix3D world_to_neck_tm;
cur_neck.Get_Orthogonal_Inverse (world_to_neck_tm);
//
// Build a head to neck transform
//
Matrix3D head_to_neck_tm = world_to_neck_tm * cur_head;
//
// Get the target relative to the head
//
Vector3 relative_head_target;
Matrix3D::Inverse_Transform_Vector( cur_head, HeadLookTarget, &relative_head_target );
//
// Determine the 'twist' and lookup/down angles.
// Note: Currently in the head bone coordinate system, the X axis is the same
// as the Z axis in object space, the Y axis is the same as the X axis in object space,
// and the Z axis is the same as the Y axis in object space.
//
desired_head_rotation.X = WWMath::Atan2( relative_head_target.Z, relative_head_target.Y );
desired_head_rotation.Z = -WWMath::Fast_Asin( relative_head_target.X / relative_head_target.Length() );
desired_head_rotation.Y = 0;
//
// Determine how far to allow the character to turn and tilt his/her head.
// These boundaries are based on the "absolute" amount the person can turn
// their head, this has to take into consideration the amount that the current
// animation is turning the head and the amount we need to turn to look at the target.
//
Vector3 temp_vec = head_to_neck_tm.Get_Y_Vector ();
float curr_rot_x = ::atan2 (temp_vec.Z, temp_vec.Y);
float curr_rot_z = ::atan2 (temp_vec.X, temp_vec.Y);
float min_twist = ((-HEAD_TURN_LIMIT) - curr_rot_x);
float max_twist = (HEAD_TURN_LIMIT - curr_rot_x);
float min_tilt = ((-HEAD_TILT_LIMIT) - curr_rot_z);
float max_tilt = (HEAD_TILT_LIMIT - curr_rot_z);
//
// Clamp the rotations
//
desired_head_rotation.X = WWMath::Clamp( desired_head_rotation.X, min_twist, max_twist);
desired_head_rotation.Z = WWMath::Clamp( desired_head_rotation.Z, min_tilt, max_tilt);
}
}
#define HEAD_TURN_RATE (DEG_TO_RAD( 360 )/2)
#define HEAD_TILT_RATE (DEG_TO_RAD( 180 )/2)
float max_turn = HEAD_TURN_RATE * TimeManager::Get_Frame_Seconds();
float max_tilt = HEAD_TILT_RATE * TimeManager::Get_Frame_Seconds();
HeadRotation.X += WWMath::Clamp( (desired_head_rotation.X - HeadRotation.X), -max_turn, max_turn );
HeadRotation.Z += WWMath::Clamp( (desired_head_rotation.Z - HeadRotation.Z), -max_tilt, max_tilt );
Matrix3D head(1);
head.Rotate_X( HeadRotation.X );
head.Rotate_Z( HeadRotation.Z );
if ( !Peek_Model()->Is_Bone_Captured( head_bone ) ) {
Peek_Model()->Capture_Bone( head_bone );
}
WWASSERT( Peek_Model()->Is_Bone_Captured( head_bone ) );
if ( Peek_Model()->Is_Bone_Captured( head_bone ) ) {
Peek_Model()->Control_Bone( head_bone, head );
}
HeadRotation.Z = 0;
if ( returning && HeadRotation.Length() > 0.001f ) {
HeadLookDuration = 0.0001f; // maybe done next time...
}
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Blended_Animation( const char *animation_name, bool looping, float frame_offset, bool play_backwards )
{
if ( animation_name == NULL ) {
HumanState.Stop_Scripted_Animation();
return;
}
// Humans ignore the start_frame parameter for now
AnimationName = animation_name;
HumanState.Start_Scripted_Animation( animation_name, true, looping );
Get_Anim_Control()->Set_Mode( looping ? ANIM_MODE_LOOP : ANIM_MODE_ONCE, frame_offset );
if ( play_backwards ) {
HAnimClass *anim = Get_Anim_Control()->Peek_Animation();
if ( anim != NULL ) {
int frame_count = anim->Get_Num_Frames();
Get_Anim_Control()->Set_Mode( ANIM_MODE_TARGET, frame_count - 1 );
Get_Anim_Control()->Set_Target_Frame( 0 );
}
}
return ;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Animation( const char *animation_name, bool looping, float start_frame )
{
if ( animation_name == NULL ) {
// Debug_Say(( "Stoping Scripted Human Animation\n" ));
HumanState.Stop_Scripted_Animation();
// FIX AnimControl->UnLock_Animation();
return;
}
// Humans ignore the start_frame parameter for now
// Debug_Say(( "Starting Scripted Human Animation %s\n", animation_name ));
AnimationName = animation_name;
HumanState.Start_Scripted_Animation( animation_name, false, looping );
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Start_Transition_Animation( const char * anim_name, TransitionCompletionDataStruct *data )
{
// Debug_Say(( "Starting Human Transition Animation %s\n", anim_name ));
//WWASSERT( TransitionCompletionData == NULL );
TransitionCompletionData = data;
AnimationName = anim_name;
HumanState.Start_Transition_Animation( anim_name, false );
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Weapon_Model( const char *model_name )
{
if ( WeaponRenderModel != NULL ) { // remove old gun model
if ( Peek_Model() != NULL ) {
Peek_Model()->Remove_Sub_Object(WeaponRenderModel); // Clean the bone
}
WeaponRenderModel->Release_Ref();
WeaponRenderModel = NULL;
}
if ( (model_name != NULL) && (*model_name != 0) ) {
//Debug_Say(( "Updating soldier Weapon model to %s!!!\n", model_name ));
StringClass stripped_name(true);
Get_Render_Obj_Name_From_Filename( stripped_name, model_name );
WeaponRenderModel = SoldierGameObj::Find_RenderObj( stripped_name );
if ( WeaponRenderModel == NULL ) {
WeaponRenderModel = Create_Render_Obj_From_Filename( model_name );
WWASSERT( WeaponRenderModel );
SET_REF_OWNER( WeaponRenderModel );
Add_RenderObj( WeaponRenderModel );
WeaponRenderModel->Release_Ref();
}
WeaponRenderModel->Add_Ref();
// Create and add new gun model
if ( Peek_Model() != NULL ) {
if ( WeaponRenderModel->Get_Container() != Peek_Model() ) {
Peek_Model()->Add_Sub_Object_To_Bone( WeaponRenderModel, GUN_BONE_NAME );
}
}
assert( Get_Weapon() );
Get_Weapon()->Set_Model( WeaponRenderModel ); // let the weapon know who's firing him
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Weapon_Animation( const char *anim_name )
{
if ( WeaponAnimControl == NULL ) {
WeaponAnimControl = new SimpleAnimControlClass;
if (WeaponRenderModel != NULL ) {
// Update Anim Control
WeaponAnimControl->Set_Model( WeaponRenderModel );
}
}
if ( WeaponAnimControl != NULL ) {
// Debug_Say(( "Updating soldier gun anim to \"%s\"!!!\n", anim_name ));
if ( ( anim_name != NULL ) && ( *anim_name != 0 ) ) {
WeaponAnimControl->Set_Animation( anim_name );
}
}
}
void SoldierGameObj::Set_Back_Weapon_Model( const char *model_name )
{
if ( BackWeaponRenderModel != NULL ) { // remove old gun model
if (Peek_Model() != NULL ) {
Peek_Model()->Remove_Sub_Object(BackWeaponRenderModel);
}
BackWeaponRenderModel->Release_Ref();
BackWeaponRenderModel = NULL;
}
if ( (model_name != NULL) && (*model_name != 0) ) {
// Create and add back gun model
StringClass stripped_name(true);
Get_Render_Obj_Name_From_Filename( stripped_name, model_name );
BackWeaponRenderModel = SoldierGameObj::Find_RenderObj( stripped_name );
if ( BackWeaponRenderModel == NULL ) {
BackWeaponRenderModel = Create_Render_Obj_From_Filename( model_name );
// WWASSERT( BackWeaponRenderModel );
if ( BackWeaponRenderModel != NULL ) {
SET_REF_OWNER( BackWeaponRenderModel );
Add_RenderObj( BackWeaponRenderModel );
BackWeaponRenderModel->Release_Ref();
}
}
if ( BackWeaponRenderModel != NULL ) {
BackWeaponRenderModel->Add_Ref();
if (Peek_Model() != NULL ) {
Peek_Model()->Add_Sub_Object_To_Bone( BackWeaponRenderModel, BACK_GUN_BONE_NAME );
}
} else {
Debug_Say(( "Missing Back Model %s", model_name ));
}
}
}
void SoldierGameObj::Set_Back_Flag_Model(const char *model_name,
const Vector3 & tint)
{
if ( BackFlagRenderModel != NULL ) { // remove old gun model
if (Peek_Model() != NULL ) {
Peek_Model()->Remove_Sub_Object(BackFlagRenderModel);
}
BackFlagRenderModel->Release_Ref();
BackFlagRenderModel = NULL;
}
if ( (model_name != NULL) && (*model_name != 0) ) {
// Create and add back gun model
BackFlagRenderModel = Create_Render_Obj_From_Filename( model_name );
if ( BackFlagRenderModel != NULL ) {
SET_REF_OWNER( BackFlagRenderModel );
/*
extern void Tint(RenderObjClass *robj, const Vector3 & color);
Tint(BackFlagRenderModel, tint);
*/
if (Peek_Model() != NULL ) {
Peek_Model()->Add_Sub_Object_To_Bone( BackFlagRenderModel, BACK_GUN_BONE_NAME );
}
} else {
Debug_Say(( "Missing Back Model %s", model_name ));
}
}
}
void SoldierGameObj::Update_Back_Gun( void )
{
//Debug_Say(("CommandoGameObj::Update_Back_Gun\n"));
WeaponClass *next_weapon = WeaponBag->Get_Next_Weapon();
if ( next_weapon && ( next_weapon != Get_Weapon() ) ) {
Set_Back_Weapon_Model( next_weapon->Get_Back_Model_Name() );
} else {
Set_Back_Weapon_Model( NULL );
}
}
//------------------------------------------------------------------------------------
float SoldierGameObj::Get_Weapon_Height( void )
{
float height = 1.62f; // set to be at about eye level
if ( Is_Crouched() ) {
height -= 0.56f;
}
return height; // verticle offset, move to weapon
}
//------------------------------------------------------------------------------------
float SoldierGameObj::Get_Weapon_Length( void )
{
return 0.8f; // forward offset, move to weapon
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::Internal_Set_Targeting( const Vector3 & target_pos, bool do_tilt )
{
WWPROFILE( "Soldier Set Targeting" );
if ( CombatManager::Is_Skeleton_Slider_Demo_Enabled() ) {
return false;
}
SmartGameObj::Set_Targeting( target_pos );
if ( ( Get_State() == HumanStateClass::DEATH ) ||
( Get_State() == HumanStateClass::DESTROY ) ||
( Get_State() == HumanStateClass::TRANSITION ) ||
( Get_State() == HumanStateClass::LADDER ) ) {
// Debug_Say(( "Ignore Set Target in Transition \n" ));
return false;
}
if ( Get_State() == HumanStateClass::IN_VEHICLE ) {
if ( Vehicle != NULL ) {
if ( Vehicle->Get_Driver_Is_Gunner() ) {
if ( Vehicle->Get_Driver() == this ) {
Vehicle->Set_Targeting( target_pos );
}
} else {
if ( Vehicle->Get_Driver() == this && Vehicle->Get_Gunner() == NULL ) {
Vehicle->Set_Targeting( target_pos );
} else if ( Vehicle->Get_Gunner() == this ) {
Vehicle->Set_Targeting( target_pos );
}
}
}
return false;
}
Vector3 muzzle_pos;
Get_Position( &muzzle_pos );
muzzle_pos.Z += Get_Weapon_Height();
Vector3 rel_target_pos = target_pos - muzzle_pos;
// Set Tilt
float dist = rel_target_pos.Length();
float tilt = 0;
if ( dist && do_tilt ) {
tilt = WWMath::Fast_Asin( rel_target_pos.Z / dist );
}
// tilt = 0;
// Debug_Say(( "Tilt %f", tilt ));
bool is_complete = true;
// Set Facing
float cur_facing = Peek_Human_Phys()->Get_Heading();
float facing = WWMath::Atan2( rel_target_pos.Y, rel_target_pos.X );
float facing_dif = facing - cur_facing;
if ( WWMath::Fabs(facing_dif) > 0.001f ) {
WWPROFILE( "Facing" );
facing_dif = WWMath::Wrap( facing_dif, DEG_TO_RADF( -180.0f ), DEG_TO_RADF( 180.0f ) );
// Debug_Say(( "Must change %1.3f, from facing %1.3f to facing %1.3f\n", RAD_TO_DEG( facing_dif ), RAD_TO_DEG( cur_facing ), RAD_TO_DEG( facing ) ));
float change = facing_dif;
if ( !Is_Human_Controlled() ) { // human players don't use turn limits
float max_change = Get_Turn_Rate() * TimeManager::Get_Frame_Seconds();
// Turn more slowly when turning a small amount
if ( WWMath::Fabs( change ) < DEG_TO_RAD( 20 ) ) {
max_change *= 0.3f;
}
change = WWMath::Clamp( facing_dif, -max_change, max_change );
}
if ( !Is_Human_Controlled() ) { // human players don't use turn anims
HumanState.Set_Turn_Velocity( change ); // play the leg turning anim
}
is_complete = (change == facing_dif); // are we facing?
facing = cur_facing + change;
facing = WWMath::Wrap( facing, DEG_TO_RADF( -180.0f ), DEG_TO_RADF( 180.0f ) );
Peek_Human_Phys()->Set_Heading( facing );
}
if ( Is_Human_Controlled() && Get_State() != HumanStateClass::IN_VEHICLE ) {
#define TILT_DOWN_SPEED 4.0
float direction = -1;
if ( Get_Weapon() && Get_Weapon()->Is_Reloading() ) {
direction = 1;
}
ReloadingTilt += direction * TimeManager::Get_Frame_Seconds() * TILT_DOWN_SPEED;
ReloadingTilt = WWMath::Clamp( ReloadingTilt, 0, 1 );
if ( ReloadingTilt > 0 ) {
tilt = WWMath::Lerp( (float)tilt, DEG_TO_RADF( -90 ), ReloadingTilt );
}
}
HumanState.Update_Aiming( tilt, 0 ); // no turn
// facing = HumanState.Peek_Physical_Object()->Get_Heading();
// Debug_Say(( "Soldier Facing %f Tilt %f\n", RAD_TO_DEG( facing ), RAD_TO_DEG( WeaponTilt ) ));
// Debug_Say(( "rel_target_pos %f %f %f\n", rel_target_pos.X, rel_target_pos.Y, rel_target_pos.Z ));
return is_complete;
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::Set_Targeting( const Vector3 & target_pos, bool do_tilt )
{
bool retval = false;
//
// Don't do the targetting if we are locked on an object
//
if ( FacingObject == NULL ) {
retval = Internal_Set_Targeting( target_pos, do_tilt );
}
return retval;
}
//------------------------------------------------------------------------------------
RenderObjClass * SoldierGameObj::Find_Head_Model( void )
{
RenderObjClass *head_model = NULL;
//
// Get a pointer to the HLod this object is using
//
RenderObjClass *model = Peek_Model ();
if ( model != NULL && model->Class_ID () == RenderObjClass::CLASSID_HLOD ) {
HLodClass *lod = reinterpret_cast<HLodClass *> ( model );
//
// Try to find the head-bone
//
int bone_index = lod->Get_Bone_Index ( "C HEAD" );
int obj_count = lod->Get_Num_Sub_Objects_On_Bone(bone_index);
//
// Try to find a model on the head bone that uses the human head skeleton
//
for (int index = 0; index < obj_count; index ++) {
RenderObjClass *render_obj = lod->Get_Sub_Object_On_Bone ( index, bone_index );
if (render_obj != NULL) {
const HTreeClass *htree = render_obj->Get_HTree();
if ( htree != NULL ) {
//
// Is this really a head model?
//
if ( ::stricmp (htree->Get_Name(), "S_A_HEAD") == 0 ||
::stricmp (htree->Get_Name(), "S_B_HEAD") == 0)
{
head_model = render_obj;
break;
}
}
render_obj->Release_Ref ();
}
}
}
return head_model;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Emot_Icon ( const char *model_name, float duration )
{
//
// Free the old emot icon
//
if ( EmotIconModel != NULL ) {
if ( EmotIconModel->Is_In_Scene() ) {
EmotIconModel->Remove ();
}
REF_PTR_RELEASE( EmotIconModel );
}
//
// Try to load the new emot icon model
//
if ( model_name != NULL ) {
//
// Create the new model
//
EmotIconModel = ::Create_Render_Obj_From_Filename( model_name );
if ( EmotIconModel != NULL ) {
//
// Determine what the animation name for the model is
//
const char *name = EmotIconModel->Get_Name ();
StringClass anim_name;
anim_name.Format ("%s.%s", name, name);
//
// Animate the model
//
HAnimClass *anim = WW3DAssetManager::Get_Instance ()->Get_HAnim( anim_name );
if ( anim != NULL ) {
EmotIconModel->Set_Animation( anim, 0.0F, RenderObjClass::ANIM_MODE_LOOP );
REF_PTR_RELEASE( anim );
}
//
// Put the icon a few meters above the soldier's head
//
Matrix3D tm = Get_Transform();
tm.Set_Translation (tm.Get_Translation() + Vector3 (0, 0, EMOT_ICON_HEIGHT));
EmotIconModel->Set_Transform( tm );
COMBAT_SCENE->Add_Render_Object( EmotIconModel );
EmotIconTimer = duration;
}
}
return ;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Say_Dialogue( int dialog_id )
{
WWASSERT( dialog_id >= 0 && dialog_id < DIALOG_MAX );
//
// Lookup the conversation we are starting
//
int conversation_id = DialogList[dialog_id].Get_Conversation();
if ( conversation_id > 0 ) {
//
// Start the conversation
//
ActiveConversationClass *conversation = ConversationMgrClass::Start_Conversation( this, conversation_id, true );
REF_PTR_RELEASE (conversation);
}
return ;
}
//------------------------------------------------------------------------------------
float SoldierGameObj::Say_Dynamic_Dialogue
(
int text_id,
SoldierGameObj * speaker,
AudibleSoundClass ** sound_obj_to_return
)
{
float duration = 2.0F;
//
// Lookup the translation object from the strings database
//
TDBObjClass *translate_obj = TranslateDBClass::Find_Object( text_id );
if (translate_obj != NULL) {
const WCHAR *string = translate_obj->Get_String ();
int sound_def_id = (int)translate_obj->Get_Sound_ID ();
const char *anim_name = translate_obj->Get_Animation_Name ();
//
// If this soldier was still talking from a previos call, then
// kill the old sound
//
if ( speaker != NULL ) {
speaker->Stop_Current_Speech();
}
//
// Play the sound effect
//
bool display_text = true;
if ( sound_def_id > 0 ) {
//
// Create the sound object
//
AudibleSoundClass *speech = WWAudioClass::Get_Instance ()->Create_Sound( sound_def_id );
if ( speech != NULL ) {
duration = (speech->Get_Duration() / 1000.0F);
//
// Return the sound object to the caller as necessary
//
if ( sound_obj_to_return != NULL ) {
(*sound_obj_to_return) = speech;
(*sound_obj_to_return)->Add_Ref();
}
//
// Either play the sound at the speaker's location
// or just play it as a 2D sample.
//
if ( speaker != NULL ) {
speech->Set_Transform( speaker->Get_Transform() );
speech->Add_To_Scene();
display_text = (speech->Is_Sound_Culled() == false);
} else {
//
// Play the sound
//
speech->Play();
}
}
//
// Update the speaker's internal sound object pointer
//
if ( speaker != NULL ) {
speaker->CurrentSpeech = speech;
} else {
REF_PTR_RELEASE (speech);
}
}
//
// Check to see if this string is commented out.
//
if( string != NULL && string[0] == L'/' && string[1] == L'/' ) {
string += 2;
display_text = false;
}
//
// Display the text on the screen
//
if ( display_text && string != NULL && string[0] != 0 ) {
float message_duration = max( duration, 5.0F );
CombatManager::Get_Message_Window ()->Add_Message( string, Vector3 (1, 1, 1),
speaker, message_duration );
}
//
// Play the facial animation (if one exists)
//
if ( speaker != NULL && speaker->HeadModel != NULL) {
HAnimClass *head_anim = NULL;
//
// Dig out the skeleton name for the head model
//
StringClass anim_root_name;
const HTreeClass *htree = speaker->HeadModel->Get_HTree ();
if (htree != NULL) {
anim_root_name = htree->Get_Name ();
anim_root_name += ".";
}
//
// Determine if we should use a pre-canned animation, or
// if we should build one dynamically
//
if ( anim_name == NULL || anim_name[0] == 0 ) {
//
// Build an animation dynamically
//
const char *english_string = translate_obj->Get_English_String();
if ( english_string != NULL && english_string[0] != 0 ) {
if (speaker->SpeechAnim->Generate_Animation( english_string, duration )) {
head_anim = speaker->SpeechAnim;
}
}
} else {
//
// Build a string containing the fully qualified animation name
//
StringClass full_anim_name;
if ( ::strchr( anim_name, '.' ) == 0 ) {
full_anim_name = anim_root_name;
full_anim_name += anim_name;
} else {
full_anim_name = anim_name;
}
head_anim = WW3DAssetManager::Get_Instance()->Get_HAnim( full_anim_name );
}
//
// Recreate the facial animation when the speech is complete
//
speaker->GenerateIdleFacialAnimTimer = duration + 1.0F;
//
// Play the animation on the head model (if one exists)
//
if ( speaker->HeadModel != NULL && head_anim != NULL ) {
speaker->HeadModel->Set_Animation( head_anim, 0, RenderObjClass::ANIM_MODE_ONCE );
}
}
}
return duration;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Stop_Current_Speech( void )
{
//
// Kill the current sound we are making (speech, scream, grunt, etc)
//
if ( CurrentSpeech != NULL ) {
GenerateIdleFacialAnimTimer = 0;
CurrentSpeech->Stop();
CurrentSpeech->Remove_From_Scene();
CurrentSpeech->Release_Ref();
CurrentSpeech = NULL;
}
return ;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Apply_Damage( const OffenseObjectClass & damager, float scale, int alternate_skin )
{
if ( !Is_In_Vehicle() ) {
SmartGameObj::Apply_Damage( damager, scale, alternate_skin );
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Apply_Damage_Extended( const OffenseObjectClass & damager, float scale,
const Vector3 & direction, const char * collision_box_name )
{
// If negative damage, just apply
if ( Get_Defense_Object()->Is_Repair( damager ) ) {
// if ( damager.Get_Damage() * scale < 0 ) {
SmartGameObj::Apply_Damage_Extended( damager, scale, direction, collision_box_name );
// Add electric effect
if ( HealingEffect == NULL ) {
HealingEffect = CombatMaterialEffectManager::Get_Health_Effect();
if ( HealingEffect != NULL ) {
Peek_Human_Phys()->Add_Effect_To_Me( HealingEffect );
}
}
if ( HealingEffect != NULL ) {
HealingEffect->Set_Target_Parameter(0.495f); // go almost halfway
}
return;
}
// Do this after the repair effect
/* if ( !CombatManager::I_Am_Server() ) { Clients can apply damage
return;
}*/
if ( Is_In_Vehicle() ) {
return;
}
bool ambushed = false;
// Ambush Kill
if ( ( Get_AI_State() == AI_STATE_IDLE ) || ( Get_AI_State() == AI_STATE_SECONDARY_IDLE ) ) {
// Only ambush if there is an owner to the damage, and the target is human controlled
if ( damager.Get_Owner() != NULL && !Is_Human_Controlled() ) {
scale *= AMBUSH_DAMAGE_SCALE;
ambushed = true;
// Debug_Say(( "Ambush Damage!!\n" ));
}
}
bool anim_ok = true;
Reset_Hibernating(); // Wake up when damaged
int ouch_type = Get_Ouch_Type( direction, collision_box_name );
// Stats
PlayerDataClass * damager_data = NULL;
if ( damager.Get_Owner() && damager.Get_Owner()->As_SoldierGameObj() ) {
damager_data = damager.Get_Owner()->As_SoldierGameObj()->Get_Player_Data();
}
// Dont add stats for "non-directional" damage. E.g. standing in a tiberium
// field should not count as thousands of hits.
if (direction.Length2() > WWMATH_EPSILON) {
switch( ouch_type ) {
case HumanStateClass::HEAD_FROM_BEHIND:
case HumanStateClass::HEAD_FROM_FRONT:
if ( Get_Player_Data() != NULL ) {
Get_Player_Data()->Stats_Add_Head_Hit();
}
if ( damager_data != NULL ) {
damager_data->Stats_Add_Head_Shot();
}
break;
case HumanStateClass::TORSO_FROM_BEHIND:
case HumanStateClass::TORSO_FROM_FRONT:
if ( Get_Player_Data() != NULL ) {
Get_Player_Data()->Stats_Add_Torso_Hit();
}
if ( damager_data != NULL ) {
damager_data->Stats_Add_Torso_Shot();
}
break;
case HumanStateClass::LEFT_ARM_FROM_BEHIND:
case HumanStateClass::LEFT_ARM_FROM_FRONT:
case HumanStateClass::RIGHT_ARM_FROM_BEHIND:
case HumanStateClass::RIGHT_ARM_FROM_FRONT:
if ( Get_Player_Data() != NULL ) {
Get_Player_Data()->Stats_Add_Arm_Hit();
}
if ( damager_data != NULL ) {
damager_data->Stats_Add_Arm_Shot();
}
break;
case HumanStateClass::LEFT_LEG_FROM_BEHIND:
case HumanStateClass::LEFT_LEG_FROM_FRONT:
case HumanStateClass::RIGHT_LEG_FROM_BEHIND:
case HumanStateClass::RIGHT_LEG_FROM_FRONT:
if ( Get_Player_Data() != NULL ) {
Get_Player_Data()->Stats_Add_Leg_Hit();
}
if ( damager_data != NULL ) {
damager_data->Stats_Add_Leg_Shot();
}
break;
case HumanStateClass::GROIN:
if ( Get_Player_Data() != NULL ) {
Get_Player_Data()->Stats_Add_Crotch_Hit();
}
if ( damager_data != NULL ) {
damager_data->Stats_Add_Crotch_Shot();
}
break;
}
}
// Determine what (if any) dialogue to say
int dialogue_id = -1;
ArmedGameObj *damage_owner = damager.Get_Owner();
if( damage_owner != NULL ) {
// Were we injured by a friend or foe?
if ( Is_Enemy( damage_owner ) ) {
dialogue_id = DIALOG_ON_TAKE_DAMAGE_FROM_ENEMY;
} else {
dialogue_id = DIALOG_ON_TAKE_DAMAGE_FROM_FRIEND;
}
}
float health_before = Get_Defense_Object()->Get_Health();
float armor_before = Get_Defense_Object()->Get_Shield_Strength();
if ( collision_box_name != NULL ) {
char * start = ::strchr( collision_box_name, '.' );
if ( start != NULL ) {
start++;
float bone_scale = BonesManager::Get_Bone_Damage_Scale( start );
scale *= bone_scale;
}
}
// Update damage indicators
if ( this == COMBAT_STAR ) {
if ( Get_Defense_Object()->Would_Damage( damager ) && !damager.ForceServerDamage ) {
if ( direction.Length() == 0 ) {
for ( int i = 0; i < 8; i++ ) {
CombatManager::Show_Star_Damage_Direction( i );
}
// Set all
} else {
Vector3 relative_direction = Get_Transform().Inverse_Rotate_Vector( direction );
// Convert direction into 0 .. 7
float angle = ::WWMath::Atan2 ( relative_direction.Y, -relative_direction.X);
int dir = (int)(8.0f * angle / DEG_TO_RAD( 360 ) + 8.5f);
CombatManager::Show_Star_Damage_Direction( dir & 7 );
}
}
}
SmartGameObj::Apply_Damage_Extended( damager, scale, direction, collision_box_name );
float health = Get_Defense_Object()->Get_Health();
if ( this == COMBAT_STAR ) {
Vector3 pos;
COMBAT_STAR->Get_Position( &pos );
int hitter_id = 0;
const char * weapon_name = "";
if ( damager.Get_Owner() ) {
hitter_id = damager.Get_Owner()->Get_ID();
if ( damager.Get_Owner()->Get_Weapon() ) {
weapon_name = damager.Get_Owner()->Get_Weapon()->Get_Definition()->Get_Name();
}
}
const char * body_part = ( collision_box_name != NULL ) ? collision_box_name : "";
float armor = Get_Defense_Object()->Get_Shield_Strength();
DIAG_LOG(( "DRCE", "%s; %d; %s; %1.2f; %1.2f; %1.2f; %1.2f; %1.2f", weapon_name, hitter_id, body_part, armor, health, pos.X, pos.Y, pos.Z ));
}
if (( damager.Get_Owner() == COMBAT_STAR ) && ( COMBAT_STAR != NULL )) {
Vector3 pos;
COMBAT_STAR->Get_Position( &pos );
const char * weapon_name = "";
int ammo = 0;
if ( COMBAT_STAR->Get_Weapon() ) {
weapon_name = COMBAT_STAR->Get_Weapon()->Get_Definition()->Get_Name();
ammo = COMBAT_STAR->Get_Weapon()->Get_Total_Rounds();
}
int hittee_id = Get_ID();
const char * body_part = ( collision_box_name != NULL ) ? collision_box_name : "";
float armor = Get_Defense_Object()->Get_Shield_Strength();
Vector3 victim_pos;
Get_Position( &victim_pos );
const char * team_name = Player_Type_Name( Get_Player_Type() );
DIAG_LOG(( "DEFE", "%1.2f; %1.2f; %1.2f; %s; %d; %d; %s; %1.2f; %1.2f; %1.2f; %1.2f; %1.2f; %s ", pos.X, pos.Y, pos.Z, weapon_name, ammo, hittee_id, body_part, armor, health, victim_pos.X, victim_pos.Y, victim_pos.Z, team_name ));
}
if ( ambushed ) {
int victim_id = Get_ID();
Vector3 victim_pos;
Get_Position( &victim_pos );
Vector3 shooter_pos;
damager.Get_Owner()->Get_Position( &shooter_pos );
float armor = Get_Defense_Object()->Get_Shield_Strength();
DIAG_LOG(( "AMGE", "%1.2f; %1.2f; %1.2f; %d; %1.2f; %1.2f; %1.2f; %1.2f; %1.2f", victim_pos.X, victim_pos.Y, victim_pos.Z, victim_id, shooter_pos.X, shooter_pos.Y, shooter_pos.Z, armor, health ));
}
if (health == health_before && Get_Defense_Object()->Get_Shield_Strength() == armor_before) {
//
// No damage was applied.
// This is a hack.
//
// Handle zero health bug
if ( health > 0 ||
HumanState.Get_State() == HumanStateClass::DEATH ||
HumanState.Get_State() == HumanStateClass::DESTROY ) {
return;
} else {
Debug_Say(( "Solving Zero health Bug %f %d\n", health, HumanState.Get_State() ));
}
}
// Can't start special damage unless damage was done.
// Check for special damage
int warhead = damager.Get_Warhead();
ArmorWarheadManager::SpecialDamageType special_damage = ArmorWarheadManager::Get_Special_Damage_Type( warhead );
if ( special_damage != 0 ) {
float probability = ArmorWarheadManager::Get_Special_Damage_Probability( warhead );
if (health <= 0) {
probability = 1;
}
if ( FreeRandom.Get_Float() < probability ) {
// if skin is not impervious to the damage
int skin = Get_Defense_Object()->Get_Skin();
ArmorWarheadManager::SpecialDamageType special_damage = ArmorWarheadManager::Get_Special_Damage_Type( warhead );
if ( !ArmorWarheadManager::Is_Skin_Impervious( special_damage, skin ) ) {
Set_Special_Damage_Mode( special_damage, damager.Get_Owner() );
}
}
}
if ( this == COMBAT_STAR ) {
if ( _shake_delay < 0 ) {
_shake_delay = 0.6f; // don't shake/sound too fast
// And Shake the camera
Vector3 pos = COMBAT_CAMERA->Get_Transform().Get_Translation();
COMBAT_SCENE->Add_Camera_Shake( pos, 1, 0.5f, 0.05f );
}
anim_ok = false;
if ( _cry_delay < 0 ) {
_cry_delay = 2; // don't shake/sound too fast
anim_ok = true;
// Play ouch sound
AudibleSoundClass * sound = WWAudioClass::Get_Instance()->Create_Sound( "Take_Damage_Sound" );
if ( sound ) {
sound->Play();
sound->Release_Ref();
}
}
}
if ( health <= 0 ) {
// Check for creating visceroids
if ( IS_MISSION ) {
int warhead = damager.Get_Warhead();
float visceroid_probability = ArmorWarheadManager::Get_Visceroid_Probability( warhead );
if ( !Is_Human_Controlled() && visceroid_probability != 0 ) {
if ( FreeRandom.Get_Float() < visceroid_probability ) {
#define VISCEROID_NAME "Visceroid"
// Not from other visceroids
if ( ::stricmp( Get_Definition().Get_Name(), VISCEROID_NAME ) != 0 ) {
// Create a visceroid
PhysicalGameObj * vis = ObjectLibraryManager::Create_Object( VISCEROID_NAME );
if ( vis != NULL ) {
vis->Set_Transform( Get_Transform() );
vis->Start_Observers ();
Set_Delete_Pending(); // Kill me
Debug_Say(( "Made Visceroid\n" ));
}
}
}
}
}
Enable_Hibernation( false );
// Stats
SoldierGameObj * damager_owner = NULL;
if ( damager.Get_Owner() && damager.Get_Owner()->As_SoldierGameObj() ) {
damager_owner = damager.Get_Owner()->As_SoldierGameObj();
}
if ( damager_owner && damager_owner->Get_Player_Data() ) {
if ( Is_Teammate( damager_owner ) ) {
damager_owner->Get_Player_Data()->Stats_Add_Ally_Killed();
}
if ( Is_Enemy( damager_owner ) ) {
damager_owner->Get_Player_Data()->Stats_Add_Enemy_Killed();
}
if ( damager_owner->Get_Vehicle() ) {
damager_owner->Get_Player_Data()->Stats_Add_Kill_From_Vehicle();
}
}
if ( HumanState.Get_State() != HumanStateClass::DEATH ) {
if ( this == COMBAT_STAR ) {
CombatManager::Register_Star_Killer( damager.Get_Owner() );
}
// Play death animation
HumanState.Set_State( HumanStateClass::DEATH, ouch_type );
//
// Stop any sound we WERE making
//
Stop_Current_Speech ();
int death_sound_id = Get_Definition ().DeathSoundPresetID;
if (death_sound_id == 0) {
//
// Lookup the global death sound
//
GlobalSettingsDef *global_settings = GlobalSettingsDef::Get_Global_Settings ();
if (global_settings != NULL) {
death_sound_id = global_settings->Get_Death_Sound_ID();
}
}
//
// Reveal this object to the player's encyclopedia
//
if ( damager.Get_Owner () == COMBAT_STAR ) {
EncyclopediaMgrClass::Reveal_Object( this );
}
//
// Play the death sound
//
if (death_sound_id != 0) {
Matrix3D tm = Get_Transform();
RefCountedGameObjReference *owner_ref = new RefCountedGameObjReference(this);
WWAudioClass::Get_Instance()->Create_Instant_Sound( death_sound_id, tm, owner_ref );
REF_PTR_RELEASE(owner_ref);
}
// Play death explosion, since we don't call Completely_Damaged
if ( Get_Definition().KilledExplosion != 0 ) {
Vector3 pos;
Get_Position(&pos);
WWASSERT(pos.Is_Valid());// most likely candidate for explosion damage bug....?
ExplosionManager::Create_Explosion_At( Get_Definition().KilledExplosion, pos, damager.Get_Owner() ); // no one gets credit for this
}
//
// Queue the guy who killed us...
//
if ( damage_owner != NULL &&
damage_owner != this &&
damage_owner->As_SoldierGameObj () != NULL )
{
SoldierGameObj *our_killer = damage_owner->As_SoldierGameObj ();
//
// Were we killed by a friend or foe?
//
if ( Is_Enemy( damage_owner ) ) {
our_killer->Say_Dialogue( DIALOG_ON_KILLED_ENEMY );
} else {
our_killer->Say_Dialogue( DIALOG_ON_KILLED_FRIEND );
}
}
}
} else {
// Play wound animation
// If state is interruptable.....
if ( Get_State() == HumanStateClass::UPRIGHT && anim_ok ) {
HumanState.Set_State( HumanStateClass::WOUNDED, ouch_type );
}
}
if( CurrentSpeech == NULL && dialogue_id >= 0 ) {
Say_Dialogue( dialogue_id );
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Exit_Ladder( void )
{
HumanState.Set_State( HumanStateClass::UPRIGHT );
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Enter_Ladder( bool top )
{
HumanState.Set_State( HumanStateClass::LADDER );
if ( Is_Human_Controlled() ) {
if ( top ) {
LadderUpMask = true;
} else {
LadderDownMask = true;
}
}
}
//------------------------------------------------------------------------------------
HumanPhysClass *SoldierGameObj::Peek_Human_Phys( void ) const
{
WWASSERT( Peek_Physical_Object() );
WWASSERT( Peek_Physical_Object()->As_HumanPhysClass() );
return Peek_Physical_Object()->As_HumanPhysClass();
}
//------------------------------------------------------------------------------------
/*
** Vehicles
*/
void SoldierGameObj::Enter_Vehicle( VehicleGameObj * vehicle, const char * anim_name )
{
// WWASSERT( Get_State() != HumanStateClass::IN_VEHICLE );
Vehicle = vehicle;
HumanState.Set_State( HumanStateClass::IN_VEHICLE );
AnimationName = anim_name;
HumanState.Force_Animation( anim_name, false );
if ( this == COMBAT_STAR && vehicle != NULL ) {
Vector3 pos;
Vehicle->Get_Position( &pos );
int ammo = 0;
if ( vehicle->Get_Weapon() ) {
ammo = vehicle->Get_Weapon()->Get_Total_Rounds();
}
DefenseObjectClass * defense = vehicle->Get_Defense_Object();
DIAG_LOG(( "ENVE", "%1.2f; %1.2f; %1.2f; %1.2f; %1.2f; %d", pos.X, pos.Y, pos.Z, defense->Get_Shield_Strength(), defense->Get_Health(), ammo ));
}
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Exit_Vehicle( void )
{
if ( this == COMBAT_STAR && Vehicle != NULL ) {
Vector3 pos;
Vehicle->Get_Position( &pos );
int ammo = 0;
if ( Vehicle->Get_Weapon() ) {
ammo = Vehicle->Get_Weapon()->Get_Total_Rounds();
}
DefenseObjectClass * defense = Vehicle->Get_Defense_Object();
DIAG_LOG(( "EXVE", "%1.2f; %1.2f; %1.2f; %1.2f; %1.2f; %d", pos.X, pos.Y, pos.Z, defense->Get_Shield_Strength(), defense->Get_Health(), ammo ));
}
Vehicle = NULL;
HumanState.Set_State( HumanStateClass::UPRIGHT );
}
void SoldierGameObj::Exit_Destroyed_Vehicle( int seat_num, const Vector3 & vehicle_pos )
{
Vehicle = NULL;
HumanState.Set_State( HumanStateClass::UPRIGHT );
Vector3 extent = Peek_Human_Phys()->Get_Collision_Box().Extent;
float width = MAX( extent.X, extent.Y ) * 1.1f;
if ( Peek_Model() ) {
Peek_Model()->Set_Hidden( false );
}
Vector3 offsets[4] = {
Vector3( -1.0f, -1.0f, 0 ),
Vector3( -1.0f, 1.0f, 0 ),
Vector3( 1.0f, -1.0f, 0 ),
Vector3( 1.0f, 1.0f, 0 ),
};
Vector3 pos = vehicle_pos + offsets[ seat_num & 3 ] * width;
Matrix3D tm( pos );
if ( Peek_Human_Phys()->Can_Teleport( tm ) ) {
Peek_Human_Phys()->Set_Position( pos );
} else {
Vector3 new_pos = pos;
Peek_Human_Phys()->Find_Teleport_Location( pos, 4, &new_pos );
Peek_Human_Phys()->Set_Position( new_pos );
}
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::Is_Permitted_To_Enter_Vehicle(void)
{
if (!CombatManager::Is_Gameplay_Permitted()) {
//
// You can't enter a vehicle if there are no opponents, etc
//
return false;
}
/*
//
// A soldier cannot enter a vehicle if he is carrying a flag
//
if (CtfTeamFlag == NO_FLAG) {
return true;
} else {
return false;
}
*/
return true;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Get_Velocity(Vector3 & vel)
{
Peek_Human_Phys()->Get_Velocity(&vel);
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Velocity(Vector3 & vel)
{
Peek_Human_Phys()->Set_Velocity(vel);
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Give_All_Weapons(void)
{
//WWASSERT(CombatManager::I_Am_Server());
// WWASSERT(PlayerType != PLAYERTYPE_NEUTRAL);
// For all weapon defs with the AGiveWeaponsWeapon checked, Give It!
for ( WeaponDefinitionClass *weapon_def = (WeaponDefinitionClass *)DefinitionMgrClass::Get_First( CLASSID_DEF_WEAPON );
weapon_def != NULL;
weapon_def = (WeaponDefinitionClass *)DefinitionMgrClass::Get_Next( weapon_def, CLASSID_DEF_WEAPON ) ) {
if ( weapon_def->AGiveWeaponsWeapon ) {
WeaponBag->Add_Weapon( weapon_def->Get_Name(), -1 );
}
}
}
//------------------------------------------------------------------------------------
VehicleGameObj * SoldierGameObj::Get_Profile_Vehicle( void )
{
if (( Get_State() == HumanStateClass::IN_VEHICLE ) && Vehicle ) {
return Vehicle;
}
if (( Get_State() == HumanStateClass::TRANSITION ) &&
( TransitionCompletionData != NULL )) {
if ( TransitionCompletionData->Type == TransitionDataClass::VEHICLE_ENTER ) {
return (VehicleGameObj *)TransitionCompletionData->Vehicle.Get_Ptr();
}
}
return NULL;
}
bool SoldierGameObj::Use_Ladder_View( void )
{
if ( Get_State() == HumanStateClass::LADDER ) {
return true;
}
if (( Get_State() == HumanStateClass::TRANSITION ) &&
( TransitionCompletionData != NULL )) {
if (( TransitionCompletionData->Type == TransitionDataClass::LADDER_ENTER_TOP ) ||
( TransitionCompletionData->Type == TransitionDataClass::LADDER_ENTER_BOTTOM )) {
return true;
}
}
return false;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Model(const char *model_name)
{
Peek_Physical_Object()->Set_Model_By_Name(model_name);
HumanState.Set_Anim_Control( (HumanAnimControlClass *)Get_Anim_Control() ); // Must set the anim control after the phys object
}
//------------------------------------------------------------------------------------
Vector3 SoldierGameObj::Get_Bullseye_Position( void )
{
if ( Get_Vehicle() != NULL ) {
return Get_Vehicle()->Get_Bullseye_Position();
}
Vector3 pos;
Get_Position(&pos);
if ( Is_Crouched() ) {
pos.Z += 0.5f;
} else {
pos.Z += Get_Bullseye_Offset_Z();
}
// pos.Z += 1.2f;
return pos;
}
//------------------------------------------------------------------------------------
bool SoldierGameObj::Can_See(SoldierGameObj * p_soldier)
{
WWASSERT(p_soldier != NULL);
Vector3 ray_start = Get_Bullseye_Position();
Vector3 ray_end = p_soldier->Get_Bullseye_Position(); // This may a big high
Vector3 path = ray_end - ray_start;
if (path.Length() > 1) {
Vector3 offset = path;
offset.Normalize();
ray_start += offset;
}
LineSegClass ray(ray_start, ray_end);
CastResultStruct result;
PhysRayCollisionTestClass raytest(ray, &result,
BULLET_COLLISION_GROUP, COLLISION_TYPE_PHYSICAL);
WWASSERT(COMBAT_SCENE != NULL);
{ WWPROFILE( "Cast Ray" );
COMBAT_SCENE->Cast_Ray(raytest);
}
bool can_see = false;
if (raytest.CollidedPhysObj != NULL) {
SmartGameObj * p_blocker = NULL;
if ( raytest.CollidedPhysObj->Get_Observer() != NULL ) {
PhysicalGameObj * p_obj = ((CombatPhysObserverClass *)raytest.CollidedPhysObj->Get_Observer())->As_PhysicalGameObj();
if ( p_obj != NULL ) {
p_blocker = p_obj->As_SmartGameObj();
}
}
if (p_blocker != NULL && p_blocker->Get_Control_Owner() ==
p_soldier->Get_Control_Owner()) {
can_see = true;
}
}
return can_see;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Adjust_Skeleton( float height, float width )
{
// Debug_Say(( "Height %f, width %f\n", height, width ));
// Only adjust male skeletons
Animatable3DObjClass * robj = (Animatable3DObjClass *)Peek_Model();
if ( !robj || !robj->Get_HTree() || robj->Get_HTree()->Get_Name()[2] != 'A' ) {
return;
}
HTreeClass * tree_base = NULL;
HTreeClass * tree_tall = NULL;
HTreeClass * tree_wide = NULL;
if ( tree_base == NULL ) {
tree_base = WW3DAssetManager::Get_Instance()->Get_HTree( "s_a_human" );
tree_tall = WW3DAssetManager::Get_Instance()->Get_HTree( "s_a_tall" );
tree_wide = WW3DAssetManager::Get_Instance()->Get_HTree( "s_a_wide" );
}
if ( ( tree_base != NULL ) && ( tree_tall != NULL ) && ( tree_wide != NULL ) ) {
HTreeClass *tree = HTreeClass::Create_Interpolated( tree_base, tree_tall, tree_wide,
height, width );
if ( tree ) {
robj->Set_HTree( tree );
delete tree;
}
}
}
/*
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Ctf_Team_Flag(int team)
{
WWASSERT(
team == NO_FLAG ||
team == PLAYERTYPE_NOD ||
team == PLAYERTYPE_GDI);
CtfTeamFlag = team;
Set_Object_Dirty_Bit( NetworkObjectClass::BIT_OCCASIONAL, true );
if (team == NO_FLAG) {
Set_Back_Flag_Model(NULL);
} else {
//Set_Back_Flag_Model("O_Flag.w3d", Get_Team_Color());
Set_Back_Flag_Model("O_Flag.w3d", Get_Color_For_Team(team));
}
}
*/
/*
//------------------------------------------------------------------------------------
void SoldierGameObj::Set_Precision(void)
{
cEncoderList::Set_Precision(BITPACK_CTF_TEAM_FLAG, NO_FLAG, (int) PLAYERTYPE_GDI);
}
*/
//------------------------------------------------------------------------------------
SoldierObserverClass * SoldierGameObj::Get_Innate_Controller( void )
{
if ( Get_Definition().UseInnateBehavior ) {
const GameObjObserverList & observer_list = Get_Observers();
for( int index = 0; index < observer_list.Count(); index++ ) {
if ( !strcmp( observer_list[ index ]->Get_Name(), "Innate Soldier" ) ) {
return (SoldierObserverClass *)observer_list[ index ];
}
}
}
return NULL;
}
//------------------------------------------------------------------------------------
const char * SoldierGameObj::Get_First_Person_Hands_Model_Name( void )
{
return Get_Definition().FirstPersonHands;
}
//------------------------------------------------------------------------------------
void SoldierGameObj::Get_Information( StringClass & string )
{
SmartGameObj::Get_Information( string );
HumanState.Get_Information( string );
SoldierObserverClass * innate = Get_Innate_Controller();
if ( innate ) {
innate->Get_Information( string );
StringClass disabled;
if (!Is_Innate_Enabled(SOLDIER_INNATE_EVENT_BULLET_HEARD)) {
disabled += "B";
}
if (!Is_Innate_Enabled(SOLDIER_INNATE_EVENT_GUNSHOT_HEARD)) {
disabled += "G";
}
if (!Is_Innate_Enabled(SOLDIER_INNATE_EVENT_FOOTSTEP_HEARD)) {
disabled += "F";
}
if (!Is_Innate_Enabled(SOLDIER_INNATE_EVENT_ENEMY_SEEN)) {
disabled += "S";
}
if (!Is_Innate_Enabled(SOLDIER_INNATE_ACTIONS)) {
disabled += "A";
}
if ( !disabled.Is_Empty() ) {
string += "Disabled:";
string += disabled;
string += "\n";
}
}
}
//------------------------------------------------------------------------------------
//void SoldierGameObj::Get_Extended_Information(StringClass & description)
void SoldierGameObj::Get_Description(StringClass & description)
{
StringClass line;
line.Format("ID: %d\n", Get_ID());
description += line;
line.Format("NAME: %s\n", Get_Definition().Get_Name());
description += line;
line.Format("TEAM: %d\n", Get_Player_Type());
description += line;
line.Format("CONTR: %d\n", Get_Control_Owner());
description += line;
Vector3 position;
Get_Position(&position);
line.Format("POS: %-5.2f, %-5.2f, %-5.2f\n", position.X, position.Y, position.Z);
description += line;
Vector3 target = Get_Targeting_Pos();
line.Format("TGT: %-5.2f, %-5.2f, %-5.2f\n", target.X, target.Y, target.Z);
description += line;
Vector3 velocity;
Get_Velocity(velocity);
line.Format("VEL: %-5.2f, %-5.2f, %-5.2f\n", velocity.X, velocity.Y, velocity.Z);
description += line;
WeaponClass * p_weapon = Get_Weapon();
if (p_weapon != NULL) {
line.Format("WEAP: %s\n", p_weapon->Get_Name());
description += line;
line.Format("TRNDS: %d\n", p_weapon->Get_Total_Rounds());
description += line;
}
line.Format("HLTH: %-5.2f\n", DefenseObject.Get_Health());
description += line;
line.Format("HMAX: %-5.2f\n", DefenseObject.Get_Health_Max());
description += line;
HumanPhysClass * p_human_phys = Peek_Human_Phys();
if (p_human_phys != NULL) {
line.Format("FACE: %-5.2f\n", p_human_phys->Get_Facing());
description += line;
}
line.Format("STATE: %s", Get_State_Name());
if (Is_Crouched()) {
line += " (Crouched)";
}
line += "\n";
description += line;
line.Format("ANIM: %s\n", AnimationName);
description += line;
if (Vehicle != NULL) {
line.Format("VEH: %d\n", Vehicle->Get_ID());
description += line;
}
const GameObjObserverList & observer_list = Get_Observers();
line.Format("#OBSV: %d\n", observer_list.Count());
description += line;
for (int index = 0; index < observer_list.Count(); index++) {
line.Format(" %s\n", observer_list[index]->Get_Name());
description += line;
}
line.Format("INNAT: %d\n", Is_Innate_Enabled());
description += line;
line.Format("HIB: %d\n", Is_Hibernating());
description += line;
line.Format("CTRL: %d, %d, %5.2f, %5.2f, %5.2f, %5.2f\n",
Control.Get_One_Time_Boolean_Bits(),
Control.Get_Continuous_Boolean_Bits(),
Control.Get_Analog(ControlClass::ANALOG_MOVE_FORWARD),
Control.Get_Analog(ControlClass::ANALOG_MOVE_LEFT),
Control.Get_Analog(ControlClass::ANALOG_MOVE_UP),
Control.Get_Analog(ControlClass::ANALOG_TURN_LEFT));
description += line;
ActionClass * p_action = Get_Action();
if (p_action != NULL)
{
line.Format("ACTCT: %d\n", p_action->Get_Act_Count());
description += line;
Vector3 move_loc = p_action->Get_Parameters().MoveLocation;
line.Format("MVLOC: (%5.2f, %5.2f, %5.2f)\n", move_loc.X, move_loc.Y, move_loc.Z);
description += line;
}
line.Format("stlth: %d\n", Is_Stealth_Enabled());
description += line;
line.Format(" on: %d\n", Is_Stealthed());
description += line;
line.Format("ISC: %d\n", Get_Import_State_Count());
description += line;
}
//------------------------------------------------------------------------------------
struct {
ArmorWarheadManager::SpecialDamageType Mode;
const char * EmitterName;
const char * BoneName;
} _SpecialDamageEmitters[] = {
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_FIRE, "AG_FLAME01", "C SPINE" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C SPINE" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C L UPPERARM" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C R UPPERARM" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C L CALF" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C R CALF" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE, "AG_FLAME01", "C NECK" },
// { ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_FIRE, "E_FLAME01", "C L UPPERARM" },
// { ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_FIRE, "E_FLAME01", "C R UPPERARM" },
{ ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_CHEM, "e_tib_dump", "C SPINE" },
// { ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_CHEM, "e_tib_dump", "C L UPPERARM" },
// { ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_CHEM, "e_tib_dump", "C R UPPERARM" },
};
#define NUM_SPECIAL_DAMAGE_EMITTERS (sizeof(_SpecialDamageEmitters)/sizeof(_SpecialDamageEmitters[0]))
void SoldierGameObj::Set_Special_Damage_Mode( ArmorWarheadManager::SpecialDamageType mode, ArmedGameObj * damager )
{
// Check for turning off
if ( mode == ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE ) {
// remove all subobjs from the bones used
for ( int emitter = 0; emitter < NUM_SPECIAL_DAMAGE_EMITTERS; emitter++ ) {
if ( _SpecialDamageEmitters[emitter].Mode == SpecialDamageMode ) {
int bone = Peek_Model()->Get_Bone_Index( _SpecialDamageEmitters[emitter].BoneName );
int sub_count = Peek_Model()->Get_Num_Sub_Objects_On_Bone( bone );
while ( --sub_count >= 0 ) {
RenderObjClass * sub = Peek_Model()->Get_Sub_Object_On_Bone( sub_count, bone );
if ( ::stricmp(sub->Get_Name(), _SpecialDamageEmitters[emitter].EmitterName ) == 0 ) {
Peek_Model()->Remove_Sub_Object( sub );
}
sub->Release_Ref();
}
}
}
if ( SpecialDamageEffect != NULL ) {
SpecialDamageEffect->Set_Target_Parameter(0);
SpecialDamageEffect->Enable_Remove_On_Complete(true);
REF_PTR_RELEASE( SpecialDamageEffect );
}
if ( !Is_Human_Controlled() && IS_MISSION ) {
if ( HumanState.Get_State() >= HumanStateClass::ON_FIRE &&
HumanState.Get_State() <= HumanStateClass::ON_CNC_CHEM ) {
HumanState.Set_State( HumanStateClass::UPRIGHT );
}
}
SpecialDamageDamager = NULL;
} else {
if ( mode != SpecialDamageMode ) {
// Remove old mode
Set_Special_Damage_Mode( ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_NONE );
if ( Allow_Special_Damage_State_Lock() && IS_MISSION && mode != ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_SUPER_FIRE ) {
HumanState.Set_State( (HumanStateClass::HumanStateType)( mode -
ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_FIRE + HumanStateClass::ON_FIRE ) );
}
// Add new emitters
for ( int emitter = 0; emitter < NUM_SPECIAL_DAMAGE_EMITTERS; emitter++ ) {
if ( _SpecialDamageEmitters[emitter].Mode == mode ) {
RenderObjClass * ro = WW3DAssetManager::Get_Instance()->Create_Render_Obj(
_SpecialDamageEmitters[emitter].EmitterName );
if ( ro != NULL ) {
Peek_Model()->Add_Sub_Object_To_Bone( ro, _SpecialDamageEmitters[emitter].BoneName );
ro->Release_Ref();
}
}
}
// Add electric effect
if ( mode == ArmorWarheadManager::SPECIAL_DAMAGE_TYPE_ELECTRIC ) {
WWASSERT( SpecialDamageEffect == NULL );
SpecialDamageEffect = CombatMaterialEffectManager::Get_Electrocution_Effect();
if ( SpecialDamageEffect != NULL ) {
SpecialDamageEffect->Set_Target_Parameter(0.49f); // go almost halfway
Peek_Human_Phys()->Add_Effect_To_Me( SpecialDamageEffect );
}
}
// Save Damager
SpecialDamageDamager = damager;
}
}
SpecialDamageMode = mode;
SpecialDamageTimer = ArmorWarheadManager::Get_Special_Damage_Duration( SpecialDamageMode );
}
//-----------------------------------------------------------------------------
void SoldierGameObj::Perturb_Position(float max_perturb)
{
//
// Jiggle the soldier to a non-intersecting position
//
Vector3 initial_position;
Get_Position(&initial_position);
Vector3 new_position;
WWASSERT(Peek_Human_Phys() != NULL);
bool succeeded = Peek_Human_Phys()->Find_Teleport_Location(
initial_position, max_perturb, &new_position);
if (succeeded) {
Set_Position(new_position);
}
}
/*
**
*/
void SoldierGameObj::Toggle_Fly_Mode( void )
{
InFlyMode = !InFlyMode;
if ( InFlyMode ) {
HumanState.Set_State( HumanStateClass::DEBUG_FLY );
Peek_Physical_Object()->Set_Collision_Group( UNCOLLIDEABLE_GROUP );
} else {
HumanState.Set_State( HumanStateClass::UPRIGHT );
Peek_Physical_Object()->Set_Collision_Group( SOLDIER_COLLISION_GROUP );
}
}
/*
**
*/
void SoldierGameObj::Set_AI_State( SoldierAIState state )
{
//
// Is the soldier changing states?
//
if ( AIState != state ) {
//
// Kill the conversation (if necessary)
//
if ( state >= AI_STATE_SEARCH && state > AIState &&
ActiveConversation != NULL &&
ActiveConversation->Is_Interruptable ())
{
ActiveConversation->Stop_Conversation (ACTION_COMPLETE_CONVERSATION_INTERRUPTED);
}
AIState = state;
}
return ;
}
/*
** Soldiers maintain all RenderObjs they have created for later use and saving
** This is used for weapon models
*/
void SoldierGameObj::Add_RenderObj( RenderObjClass * obj )
{
RenderObjList.Add( obj );
obj->Add_Ref();
}
RenderObjClass * SoldierGameObj::Find_RenderObj( const char * name )
{
for ( int i = 0; i < RenderObjList.Count(); i++ ) {
if ( !stricmp( RenderObjList[i]->Get_Name(), name ) ) {
return RenderObjList[i];
}
}
return NULL;
}
void SoldierGameObj::Reset_RenderObjs( void )
{
while ( RenderObjList.Count() ) {
RenderObjList[0]->Release_Ref();
RenderObjList.Delete( 0 );
}
}
/*
//-----------------------------------------------------------------------------
void SoldierGameObj::Change_Flag_Status(int ctf_team_flag)
{
WWASSERT(CombatManager::I_Am_Only_Client());
if (ctf_team_flag == NO_FLAG) {
//
// We dropped a flag
//
WWASSERT(WWAudioClass::Get_Instance() != NULL);
WWAudioClass::Get_Instance()->Create_Instant_Sound("Drop_Flag", Get_Transform());
float speed_factor = 100 / (float) CombatManager::Get_Max_Speed_Pc(this);
Set_Max_Speed(speed_factor * Get_Max_Speed());
Set_Ctf_Team_Flag(ctf_team_flag);
} else {
//
// We picked up a flag
//
WWASSERT(WWAudioClass::Get_Instance() != NULL);
WWAudioClass::Get_Instance()->Create_Instant_Sound("Pick_Up_Flag", Get_Transform());
Set_Ctf_Team_Flag(ctf_team_flag);
float speed_factor = CombatManager::Get_Max_Speed_Pc(this) / 100.0f;
Set_Max_Speed(speed_factor * Get_Max_Speed());
}
}
*/
/*
void SoldierGameObj::Interpret_Sc_Position_Data(Vector3 & sc_position)
{
WWASSERT(CombatManager::I_Am_Only_Client());
switch (CombatManager::Get_Client_Interpolation_Model()) {
case CLIENT_INTERPOLATION_SERVER_AUTHORITATIVE:
//
// Simplest case - pop to location given by server
//
//Set_Position(sc_position);
if (Get_State() == HumanStateClass::TRANSITION) {
//
// Pop
//
Set_Position(sc_position);
if (Get_Control_Owner() == CombatManager::Get_My_Id()) {
Debug_Say(("Popping own soldier at time %s\n", cMiscUtil::Get_Text_Time()));
}
} else {
Vector3 current_position;
Get_Position(&current_position);
Vector3 pos_error = current_position - sc_position;
if (pos_error.Length() > 2.0f) {
Set_Position(sc_position);
if (Get_Control_Owner() == CombatManager::Get_My_Id()) {
Debug_Say(("Popping own soldier at time %s\n", cMiscUtil::Get_Text_Time()));
}
}
}
break;
case CLIENT_INTERPOLATION_SERVER_AUTHORITATIVE_WITH_BLENDING:
if (Get_State() == HumanStateClass::TRANSITION) {
//
// Pop
//
Set_Position(sc_position);
} else {
//
// Blend to position given by server
//
Vector3 current_position;
Get_Position(&current_position);
Set_Position(0.50 * current_position + 0.50 * sc_position);
}
break;
case CLIENT_INTERPOLATION_PATHFIND: {
Vector3 current_position;
Get_Position(&current_position);
Vector3 pos_error = current_position - sc_position;
if (pos_error.Length() > 0.02f) {
if (Get_Control_Owner() == CombatManager::Get_My_Id()) {
if (pos_error.Length() > 2) {
//
// Client is authoritative over his own guy, unless error
// becomes significant. In this case, pop.
//
Set_Position(sc_position);
}
} else {
//if (pos_error.Length() > 20) {
// //
// // Pop
// //
// Set_Position(sc_position);
//} else {
//
// For NPC's the server could transmit the final destination as well as
// the proper location. Pop if appropriate to get as close to
// proper dest as possible, but pathfind instead to the final dest.
//
ActionParamsStruct parameters;
parameters.Priority = 1;
parameters.MoveLocation = sc_position;
parameters.MoveArrivedDistance = 0.1f;
WWASSERT(Get_Action() != NULL);
Get_Action()->Goto(parameters);
//}
}
}
break;
}
default:
WWASSERT(0);
}
}
*/
/*
void SoldierGameObj::Think_Pathfind( void )
{
// CLIENT_PATHFINDING
//
// Pop pathfinding client-side soldiers at the earliest opportunity -
// as soon as we find them out of the camera fulcrum.
//
if (CombatManager::I_Am_Only_Client() &&
Get_Control_Owner() != CombatManager::Get_My_Id()) {
Vector3 current_position;
Get_Position(&current_position);
ActionClass * p_action = Get_Action();
WWASSERT(p_action != NULL);
const Vector3 height_offset(0, 0, 0.9f);
Vector3 from_position = current_position + height_offset;
Vector3 to_position = p_action->MovementLocation + height_offset;
//
// We can only pop if he is not presently in the camera fulcrum.
//
if (p_action->MovementAction != NULL &&
!CombatManager::Is_In_Camera_Frustrum(from_position)) {
if (!CombatManager::Is_In_Camera_Frustrum(to_position)) {
//
// If the correct position is also out of the fulcrum, pop
// all the way there.
//
Set_Position(p_action->MovementLocation);
p_action->Set_Movement(NULL);
} else {
//
// We are crossing into the fulcrum. Pop as close to the edge
// of the fulcrum as possible and pathfind from there.
//
//Debug_Say(("FRAME\n"));
bool is_finished = false;
do {
Vector3 next_pos;
p_action->Movement_Act(next_pos);
//if (CombatManager::Is_In_Camera_Frustrum(next_pos + height_offset)) {
// is_finished = true;
//
// //
// // Logically it would be better if the next line could be omitted.
// // However this seems to screw things up.
// //
// Set_Position(next_pos);
//
// //Debug_Say(("Finished skipping."));
//} else {
// Set_Position(next_pos);
//
// //Debug_Say(("Skipping to (%5.2f, %5.2f, %5.2f)\n",
// // next_pos.X, next_pos.Y, next_pos.Z));
//}
Set_Position(next_pos);
Vector3 adjusted_next_pos = next_pos + height_offset;
if (CombatManager::Is_In_Camera_Frustrum(adjusted_next_pos)) {
is_finished = true;
}
} while ((p_action->MovementAction != NULL) && !is_finished);
}
}
}
}
void SoldierGameObj::Think_Pathfind(void)
{
//
// Pop pathfinding client-side soldiers at the earliest opportunity -
// as soon as we find them out of the camera fulcrum.
//
if ((CombatManager::Get_Client_Interpolation_Model() == CLIENT_INTERPOLATION_PATHFIND) &&
CombatManager::I_Am_Only_Client() &&
Get_Control_Owner() != CombatManager::Get_My_Id()) {
Vector3 current_position;
Get_Position(&current_position);
ActionClass * p_action = Get_Action();
WWASSERT(p_action != NULL);
ActionParamsStruct parameters = p_action->Get_Parameters();
const Vector3 height_offset(0, 0, 0.9f);
Vector3 from_position = current_position + height_offset;
Vector3 to_position = parameters.MoveLocation + height_offset;
//
// We can only pop if he is not presently in the camera fulcrum.
//
if (!CombatManager::Is_In_Camera_Frustrum(from_position)) {
if (!CombatManager::Is_In_Camera_Frustrum(to_position)) {
//
// If the correct position is also out of the fulcrum, pop
// all the way there.
//
Set_Position(to_position);
} else {
//
// Keep popping until we are almost in the fulcrum.
//
Vector3 current_pos;
Get_Position(&current_pos);
Vector3 last_pos;
Vector3 test_pos;
do {
last_pos = current_pos;
p_action->Act();
Get_Position(&current_pos);
test_pos = current_pos + height_offset;
} while ((current_pos != last_pos) &&
!CombatManager::Is_In_Camera_Frustrum(test_pos));
Set_Position(last_pos);
}
}
}
}
*/
void SoldierGameObj::Update_Healing_Effect( void )
{
if ( HealingEffect != NULL ) {
if (( HealingEffect->Get_Target_Parameter() >= 0.49f ) &&
( HealingEffect->Get_Parameter() >= 0.49f ) ) {
HealingEffect->Set_Target_Parameter( 0 );
}
if (( HealingEffect->Get_Target_Parameter() == 0 ) &&
( HealingEffect->Get_Parameter() == 0 ) ) {
Peek_Human_Phys()->Remove_Effect_From_Me( HealingEffect );
REF_PTR_RELEASE( HealingEffect );
}
}
}
void SoldierGameObj::Enable_Ghost_Collision( bool onoff )
{
bool is_using_ghost_collision = (Peek_Physical_Object ()->Get_Collision_Group() == SOLDIER_GHOST_COLLISION_GROUP);
if ( onoff == is_using_ghost_collision ) {
return ;
}
//
// Change the collision group as necessary
//
if ( onoff ) {
Peek_Physical_Object ()->Set_Collision_Group( SOLDIER_GHOST_COLLISION_GROUP );
} else {
Peek_Physical_Object ()->Set_Collision_Group( SOLDIER_COLLISION_GROUP );
}
return ;
}
bool SoldierGameObj::Is_Safe_To_Disable_Ghost_Collision( const Vector3 &curr_pos )
{
const Vector3 PERSONAL_SPACE_BOX_SIZE (1.5F, 1.5F, 1.0F);
const float HUMAN_HALF_HEIGHT = 1.0F;
bool retval = true;
//
// Build a box that represents the "personal" space around the soldier
//
Vector3 box_pos = curr_pos + Vector3 (0, 0, HUMAN_HALF_HEIGHT);
AABoxClass box (box_pos, PERSONAL_SPACE_BOX_SIZE);
//
// Collect all the dynamic objects in this box
//
NonRefPhysListClass obj_list;
PhysicsSceneClass::Get_Instance ()->Collect_Objects (box, false, true, &obj_list);
//
// Loop over all the collected objects
//
NonRefPhysListIterator it (&obj_list);
for (it.First(); !it.Is_Done(); it.Next()) {
PhysClass *phys_obj = it.Peek_Obj ();
PhysicalGameObj *game_obj = NULL;
if ( phys_obj->As_HumanPhysClass () && phys_obj->Get_Observer() != NULL ) {
game_obj = ((CombatPhysObserverClass *)phys_obj->Get_Observer())->As_PhysicalGameObj();
}
//
// Is this a living soldier?
//
if ( game_obj != NULL && game_obj != this &&
game_obj->As_SoldierGameObj() != NULL &&
game_obj->As_SoldierGameObj()->Is_Destroyed () == false)
{
Vector3 block_pos;
game_obj->Get_Position (&block_pos);
//
// Lets make sure the boxes really intersect
//
AABoxClass block_box (block_pos + Vector3 (0, 0, 1.0F), Vector3 (0.3F, 0.3F, 1.0F));
if (CollisionMath::Overlap_Test (box, block_box) != CollisionMath::OUTSIDE) {
//
// Is the boxes intersect, then it is NOT SAFE to disable ghost collision
// mode.
//
retval = false;
break;
}
}
}
return retval;
}
bool SoldierGameObj::Is_Soldier_Blocked( const Vector3 &curr_pos )
{
//
// Only do this for soldiers who meet our criteria
//
if ( (Get_Action () != NULL && Get_Action ()->Is_Busy ()) ||
Is_Destroyed () || (IS_SOLOPLAY == false))
{
return false;
}
const Vector3 PERSONAL_SPACE_BOX_SIZE (1.5F, 1.5F, 1.0F);
const float HUMAN_HALF_HEIGHT = 1.0F;
//
// Build a box that represents the "personal" space around the soldier
//
Vector3 box_pos = curr_pos + Vector3 (0, 0, HUMAN_HALF_HEIGHT);
AABoxClass box (box_pos, PERSONAL_SPACE_BOX_SIZE);
//
// Collect all the dynamic objects in this box
//
NonRefPhysListClass obj_list;
PhysicsSceneClass::Get_Instance ()->Collect_Objects (box, false, true, &obj_list);
uint32 my_id = Get_ID ();
uint32 smallest_id = my_id;
//
// Loop over all the collected objects
//
NonRefPhysListIterator it (&obj_list);
for (it.First(); !it.Is_Done(); it.Next()) {
PhysClass *phys_obj = it.Peek_Obj ();
PhysicalGameObj *game_obj = NULL;
if ( phys_obj->As_HumanPhysClass () && phys_obj->Get_Observer() != NULL ) {
game_obj = ((CombatPhysObserverClass *)phys_obj->Get_Observer())->As_PhysicalGameObj();
}
//
// Is this a living soldier?
//
if ( game_obj != NULL && game_obj != this &&
game_obj->As_SoldierGameObj() != NULL &&
game_obj->As_SoldierGameObj()->Is_Destroyed () == false)
{
Vector3 block_pos;
game_obj->Get_Position (&block_pos);
//
// Lets make sure the boxes really intersect
//
AABoxClass block_box (block_pos + Vector3 (0, 0, 1.0F), Vector3 (0.3F, 0.3F, 1.0F));
if (CollisionMath::Overlap_Test (box, block_box) != CollisionMath::OUTSIDE) {
if (game_obj->As_SmartGameObj ()->Is_Human_Controlled () == false) {
//
// Is this soldier moving?
//
ActionClass *curr_action = game_obj->As_SmartGameObj ()->Get_Action ();
Vector3 dest_pos = curr_action->Get_Parameters ().MoveLocation;
float distance = (block_pos - dest_pos).Length ();
if (distance > curr_action->Get_Parameters ().MoveArrivedDistance) {
//
// Is this the smallest ID so far?
//
uint32 curr_id = game_obj->Get_ID ();
if (curr_id < smallest_id) {
smallest_id = curr_id;
}
//
// Push the other guy out of the way (a little)
//
/*if (Is_Human_Controlled () || curr_id > my_id) {
Vector3 delta_vector = block_pos - curr_pos;
delta_vector.Normalize ();
SoldierGameObj *soldier = game_obj->As_SoldierGameObj ();
if (soldier->Peek_Human_Phys () != NULL) {
soldier->Peek_Human_Phys ()->Collide (delta_vector * TimeManager::Get_Frame_Seconds ());
}
}*/
}
}
}
}
}
return (smallest_id != my_id);
}
bool SoldierGameObj::Is_Targetable( void ) const
{
return (!(((SoldierGameObj*)this)->Is_In_Vehicle())) &&
SmartGameObj::Is_Targetable();
}
float SoldierGameObj::Get_Stealth_Fade_Distance(void) const
{
if (IS_MISSION) {
return GlobalSettingsDef::Get_Global_Settings()->Get_Stealth_Distance_Human();
} else {
return GlobalSettingsDef::Get_Global_Settings()->Get_MP_Stealth_Distance_Human();
}
}
void SoldierGameObj::Lock_Facing( PhysicalGameObj * game_obj, bool turn_body )
{
FacingObject = game_obj;
FacingAllowBodyTurn = turn_body;
//
// Stop facing if there's nothing to look at
//
if ( game_obj == NULL ) {
Cancel_Look_At();
}
return ;
}
void SoldierGameObj::Update_Locked_Facing( void )
{
if ( FacingObject != NULL ) {
//
// Get the position of the object we're "looking" at.
//
Vector3 pos;
FacingObject.Get_Ptr ()->Get_Position( &pos );
//
// If the object is a soldier, then look at his head
//
if ( FacingObject.Get_Ptr ()->As_PhysicalGameObj ()->As_SoldierGameObj () != NULL ) {
const float SOLDIER_HEIGHT = 1.7F;
pos.Z += SOLDIER_HEIGHT;
}
//
// Look at the object
//
Look_At( pos, 100.0F );
//
// If we can turn to face the object, do so...
//
if ( FacingAllowBodyTurn ) {
Internal_Set_Targeting( pos, false );
}
}
return ;
}
/*
if (CombatManager::I_Am_Server()) {
CombatManager::Soldier_Dies(this);
}
*/
Reference in a new issue Copy permalink