515 lines
14 KiB
C++
515 lines
14 KiB
C++
/*
|
|
** 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/cinematicgameobj.cpp $*
|
|
* *
|
|
* $Author:: Tom_s $*
|
|
* *
|
|
* $Modtime:: 10/10/01 11:37a $*
|
|
* *
|
|
* $Revision:: 32 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
/*
|
|
** Includes
|
|
*/
|
|
#include "cinematicgameobj.h"
|
|
#include "debug.h"
|
|
#include "animcontrol.h"
|
|
#include "Sound3D.H"
|
|
#include "combat.h"
|
|
#include "pscene.h"
|
|
#include "persistfactory.h"
|
|
#include "combatchunkid.h"
|
|
#include "simpledefinitionfactory.h"
|
|
#include "wwhack.h"
|
|
#include "weapons.h"
|
|
#include "gameobjmanager.h"
|
|
#include "assets.h"
|
|
#include "ccamera.h"
|
|
#include "explosion.h"
|
|
#include "damage.h"
|
|
#include "dynamicanimphys.h"
|
|
#include "wwprofile.h"
|
|
#include "apppackettypes.h"
|
|
|
|
|
|
/*
|
|
** CinematicGameObjDef
|
|
*/
|
|
DECLARE_FORCE_LINK( Cinematic )
|
|
|
|
SimplePersistFactoryClass<CinematicGameObjDef, CHUNKID_GAME_OBJECT_DEF_CINEMATIC> _CinematicGameObjDefPersistFactory;
|
|
|
|
DECLARE_DEFINITION_FACTORY(CinematicGameObjDef, CLASSID_GAME_OBJECT_DEF_CINEMATIC, "Cinematic") _CinematicGameObjDefDefFactory;
|
|
|
|
CinematicGameObjDef::CinematicGameObjDef( void ) :
|
|
SoundDefID( 0 ),
|
|
AutoFireWeapon( false ),
|
|
DestroyAfterAnimation( true ),
|
|
CameraRelative( false )
|
|
{
|
|
MODEL_DEF_PARAM( CinematicGameObjDef, PhysDefID, "DynamicAnimPhysDef" );
|
|
EDITABLE_PARAM( CinematicGameObjDef, ParameterClass::TYPE_SOUNDDEFINITIONID, SoundDefID );
|
|
EDITABLE_PARAM( CinematicGameObjDef, ParameterClass::TYPE_STRING, SoundBoneName );
|
|
FILENAME_PARAM( CinematicGameObjDef, AnimationName, "Animation", ".W3D" );
|
|
EDITABLE_PARAM( CinematicGameObjDef, ParameterClass::TYPE_BOOL, AutoFireWeapon );
|
|
EDITABLE_PARAM( CinematicGameObjDef, ParameterClass::TYPE_BOOL, DestroyAfterAnimation );
|
|
EDITABLE_PARAM( CinematicGameObjDef, ParameterClass::TYPE_BOOL, CameraRelative );
|
|
}
|
|
|
|
uint32 CinematicGameObjDef::Get_Class_ID (void) const
|
|
{
|
|
return CLASSID_GAME_OBJECT_DEF_CINEMATIC;
|
|
}
|
|
|
|
const PersistFactoryClass & CinematicGameObjDef::Get_Factory (void) const
|
|
{
|
|
return _CinematicGameObjDefPersistFactory;
|
|
}
|
|
|
|
PersistClass * CinematicGameObjDef::Create( void ) const
|
|
{
|
|
CinematicGameObj * obj = new CinematicGameObj;
|
|
obj->Init( *this );
|
|
return obj;
|
|
}
|
|
|
|
enum {
|
|
CHUNKID_DEF_PARENT = 418001957,
|
|
CHUNKID_DEF_VARIABLES,
|
|
|
|
MICROCHUNKID_DEF_SOUND_DEF_ID = 1,
|
|
MICROCHUNKID_DEF_SOUND_BONE_NAME,
|
|
XXX_MICROCHUNKID_DEF_ANIMATION_NAME,
|
|
MICROCHUNKID_DEF_AUTO_FIRE_WEAPON,
|
|
MICROCHUNKID_DEF_DESTROY_AFTER_ANIMATION,
|
|
MICROCHUNKID_DEF_CAMERA_RELATIVE,
|
|
};
|
|
|
|
bool CinematicGameObjDef::Save( ChunkSaveClass & csave )
|
|
{
|
|
csave.Begin_Chunk( CHUNKID_DEF_PARENT );
|
|
ArmedGameObjDef::Save( csave );
|
|
csave.End_Chunk();
|
|
|
|
csave.Begin_Chunk( CHUNKID_DEF_VARIABLES );
|
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_SOUND_DEF_ID, SoundDefID );
|
|
WRITE_MICRO_CHUNK_WWSTRING( csave, MICROCHUNKID_DEF_SOUND_BONE_NAME, SoundBoneName );
|
|
WRITE_MICRO_CHUNK_WWSTRING( csave, XXX_MICROCHUNKID_DEF_ANIMATION_NAME, AnimationName );
|
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_AUTO_FIRE_WEAPON,AutoFireWeapon );
|
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_DESTROY_AFTER_ANIMATION, DestroyAfterAnimation );
|
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_DEF_CAMERA_RELATIVE, CameraRelative );
|
|
csave.End_Chunk();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CinematicGameObjDef::Load( ChunkLoadClass &cload )
|
|
{
|
|
while (cload.Open_Chunk()) {
|
|
switch(cload.Cur_Chunk_ID()) {
|
|
|
|
case CHUNKID_DEF_PARENT:
|
|
ArmedGameObjDef::Load( cload );
|
|
break;
|
|
|
|
case CHUNKID_DEF_VARIABLES:
|
|
while (cload.Open_Micro_Chunk()) {
|
|
switch(cload.Cur_Micro_Chunk_ID()) {
|
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_SOUND_DEF_ID, SoundDefID );
|
|
READ_MICRO_CHUNK_WWSTRING( cload, MICROCHUNKID_DEF_SOUND_BONE_NAME, SoundBoneName );
|
|
READ_MICRO_CHUNK_WWSTRING( cload, XXX_MICROCHUNKID_DEF_ANIMATION_NAME, AnimationName );
|
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_AUTO_FIRE_WEAPON,AutoFireWeapon );
|
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_DESTROY_AFTER_ANIMATION, DestroyAfterAnimation );
|
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_DEF_CAMERA_RELATIVE, CameraRelative );
|
|
default:
|
|
Debug_Say(( "Unrecognized CinematicDef Variable chunkID\n" ));
|
|
break;
|
|
}
|
|
cload.Close_Micro_Chunk();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Debug_Say(( "Unrecognized CinematicDef chunkID\n" ));
|
|
break;
|
|
}
|
|
cload.Close_Chunk();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
** CinematicGameObj
|
|
*/
|
|
SimplePersistFactoryClass<CinematicGameObj, CHUNKID_GAME_OBJECT_CINEMATIC> _CinematicGameObjPersistFactory;
|
|
|
|
const PersistFactoryClass & CinematicGameObj::Get_Factory (void) const
|
|
{
|
|
return _CinematicGameObjPersistFactory;
|
|
}
|
|
|
|
|
|
CinematicGameObj::CinematicGameObj() :
|
|
Sound( NULL )
|
|
{
|
|
Set_App_Packet_Type(APPPACKETTYPE_CINEMATIC);
|
|
}
|
|
|
|
CinematicGameObj::~CinematicGameObj()
|
|
{
|
|
Set_Sound( 0 );
|
|
|
|
COMBAT_SCENE->Remove_From_Dirty_Cull_List( Peek_Physical_Object() );
|
|
}
|
|
|
|
/*
|
|
**
|
|
*/
|
|
void CinematicGameObj::Init( void )
|
|
{
|
|
Init( Get_Definition() );
|
|
}
|
|
|
|
/*
|
|
**
|
|
*/
|
|
void CinematicGameObj::Init( const CinematicGameObjDef & definition )
|
|
{
|
|
ArmedGameObj::Init( definition );
|
|
|
|
Cinematic_Init();
|
|
}
|
|
|
|
void CinematicGameObj::Cinematic_Init( void )
|
|
{
|
|
/*
|
|
** (gth) cinematic game objects behave like animated terrain so they are in the
|
|
** terrain collision group
|
|
*/
|
|
Peek_Physical_Object()->Set_Collision_Group( PhysicsSceneClass::COLLISION_GROUP_WORLD );
|
|
// COMBAT_SCENE->Add_To_Dirty_Cull_List( Peek_Physical_Object() );
|
|
|
|
Set_Sound( Get_Definition().SoundDefID, Get_Definition().SoundBoneName );
|
|
}
|
|
|
|
const CinematicGameObjDef & CinematicGameObj::Get_Definition( void ) const
|
|
{
|
|
return (const CinematicGameObjDef &)BaseGameObj::Get_Definition();
|
|
}
|
|
|
|
|
|
/*
|
|
** CinematicGameObj Save and Load
|
|
*/
|
|
enum {
|
|
CHUNKID_PARENT = 418002008,
|
|
XXXCHUNKID_VARIABLES,
|
|
XXXCHUNKID_ANIM_CONTROL,
|
|
|
|
XXXMICROCHUNKID_PHYSICAL_OBJECT = 1,
|
|
};
|
|
|
|
bool CinematicGameObj::Save( ChunkSaveClass & csave )
|
|
{
|
|
csave.Begin_Chunk( CHUNKID_PARENT );
|
|
ArmedGameObj::Save( csave );
|
|
csave.End_Chunk();
|
|
|
|
// We don't need to save the sound
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CinematicGameObj::Load( ChunkLoadClass &cload )
|
|
{
|
|
while (cload.Open_Chunk()) {
|
|
switch(cload.Cur_Chunk_ID()) {
|
|
|
|
case CHUNKID_PARENT:
|
|
ArmedGameObj::Load( cload );
|
|
break;
|
|
|
|
default:
|
|
Debug_Say(( "Unrecognized Cinematic chunkID\n" ));
|
|
break;
|
|
|
|
}
|
|
cload.Close_Chunk();
|
|
}
|
|
|
|
SaveLoadSystemClass::Register_Post_Load_Callback(this);
|
|
return true;
|
|
}
|
|
|
|
void CinematicGameObj::On_Post_Load( void )
|
|
{
|
|
ArmedGameObj::On_Post_Load();
|
|
|
|
Cinematic_Init();
|
|
}
|
|
|
|
|
|
/*
|
|
**
|
|
*/
|
|
void CinematicGameObj::Set_Sound( int sound_def_id, const char * bone_name )
|
|
{
|
|
// Stop Old Sound
|
|
if ( Sound != NULL ) {
|
|
Sound->Stop();
|
|
Sound->Attach_To_Object( NULL );
|
|
Sound->Remove_From_Scene();
|
|
Sound->Release_Ref();
|
|
Sound = NULL;
|
|
}
|
|
|
|
// Start new Sound
|
|
if ( sound_def_id != 0 ) {
|
|
Sound = WWAudioClass::Get_Instance()->Create_Continuous_Sound( sound_def_id );
|
|
if ( Sound != NULL ) {
|
|
RenderObjClass * model = Peek_Model();
|
|
WWASSERT( model );
|
|
int bone_index = model->Get_Bone_Index( bone_name );
|
|
Sound->Attach_To_Object( Peek_Model(), bone_index );
|
|
Sound->Add_To_Scene( true );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CinematicGameObj::Think( void )
|
|
{
|
|
{ WWPROFILE( "Cinematic Think" );
|
|
|
|
// If auto fire weapon
|
|
if ( Get_Definition().AutoFireWeapon ) {
|
|
|
|
PhysicalGameObj * enemy = NULL;
|
|
Vector3 my_pos;
|
|
Get_Position( &my_pos );
|
|
|
|
// if any enemies can be found in range
|
|
SLNode<BaseGameObj> *objnode;
|
|
for ( objnode = GameObjManager::Get_Game_Obj_List()->Head(); objnode; objnode = objnode->Next()) {
|
|
PhysicalGameObj *obj = objnode->Data()->As_PhysicalGameObj();
|
|
if ( obj && obj->Peek_Physical_Object() ) { // zones have no phy obj CHANGE THIS
|
|
if ( obj == this ) {
|
|
continue;
|
|
}
|
|
if ( Is_Teammate( obj ) ) {
|
|
continue;
|
|
}
|
|
|
|
Vector3 v;
|
|
obj->Get_Position(&v);
|
|
v -= my_pos;
|
|
if ( v.Length() < Get_Weapon()->Get_Range() ) {
|
|
enemy = obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( enemy != NULL ) {
|
|
Vector3 enemy_pos;
|
|
enemy->Get_Position( &enemy_pos );
|
|
enemy_pos.Z += 1;
|
|
|
|
if ( Set_Targeting( enemy_pos ) == false ) {
|
|
Get_Weapon()->Set_Primary_Triggered( false );
|
|
} else {
|
|
Get_Weapon()->Set_Primary_Triggered( true ); // Fire Primary
|
|
}
|
|
} else {
|
|
Get_Weapon()->Set_Primary_Triggered( false );
|
|
}
|
|
|
|
}
|
|
|
|
if ( Get_Definition().CameraRelative && COMBAT_CAMERA != NULL ) {
|
|
Matrix3D tm = COMBAT_CAMERA->Get_Transform();
|
|
tm.Rotate_Z( DEG_TO_RADF(90.0) );
|
|
tm.Rotate_Y( DEG_TO_RADF(90.0) );
|
|
Set_Transform( tm );
|
|
}
|
|
}
|
|
ArmedGameObj::Think();
|
|
|
|
}
|
|
|
|
void CinematicGameObj::Post_Think( void )
|
|
{
|
|
ArmedGameObj::Post_Think();
|
|
|
|
WWPROFILE( "Cinematic PostThink" );
|
|
|
|
// Animation is handled by the DynamicAnimPhysClass for this class
|
|
WWASSERT(Get_Anim_Control() == NULL);
|
|
|
|
if (Get_Definition().DestroyAfterAnimation) {
|
|
PhysClass * pobj = Peek_Physical_Object();
|
|
if (pobj != NULL) {
|
|
DynamicAnimPhysClass * dpobj = pobj->As_DynamicAnimPhysClass();
|
|
if ((dpobj != NULL) &&
|
|
(dpobj->Get_Animation_Manager().Peek_Animation() != NULL) &&
|
|
(dpobj->Get_Animation_Manager().Is_At_Target()) )
|
|
{
|
|
Set_Delete_Pending();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CinematicGameObj::Completely_Damaged( const OffenseObjectClass & damager )
|
|
{
|
|
if ( Get_Definition().KilledExplosion != 0 ) {
|
|
Vector3 pos;
|
|
Get_Position(&pos);
|
|
WWASSERT(pos.Is_Valid());// most likely candidate for explosion damage bug....?
|
|
|
|
// If the object has a moving bounding box, use its center point for the explosion
|
|
RenderObjClass * model = Peek_Model();
|
|
if (model != NULL) {
|
|
RenderObjClass * bbox = model->Get_Sub_Object_By_Name("BoundingBox");
|
|
if (bbox != NULL) {
|
|
Matrix3D bbox_tm = bbox->Get_Transform();
|
|
bbox_tm.Get_Translation(&pos);
|
|
REF_PTR_RELEASE(bbox);
|
|
}
|
|
}
|
|
|
|
ExplosionManager::Create_Explosion_At( Get_Definition().KilledExplosion, pos, damager.Get_Owner() ); // no one gets credit for this
|
|
}
|
|
Set_Delete_Pending();
|
|
}
|
|
|
|
|
|
float CinematicGameObj::Get_Animation_Length( void )
|
|
{
|
|
float length = 0;
|
|
|
|
//
|
|
// Try to get the dynamic anim phys object from the physics object
|
|
//
|
|
PhysClass *phys_obj = Peek_Physical_Object();
|
|
if (phys_obj != NULL) {
|
|
DynamicAnimPhysClass * dynamic_anim_phys = phys_obj->As_DynamicAnimPhysClass();
|
|
if (dynamic_anim_phys != NULL) {
|
|
|
|
//
|
|
// Peek at this object's animation
|
|
//
|
|
AnimCollisionManagerClass &anim_mgr = dynamic_anim_phys->Get_Animation_Manager();
|
|
HAnimClass *anim = anim_mgr.Peek_Animation();
|
|
if (anim != NULL) {
|
|
|
|
//
|
|
// Return the length of the animation to the caller
|
|
//
|
|
length = anim->Get_Total_Time();
|
|
}
|
|
}
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
void
|
|
CinematicGameObj::Import_Creation( BitStreamClass &packet )
|
|
{
|
|
ArmedGameObj::Import_Creation (packet);
|
|
return ;
|
|
}
|
|
*/
|
|
|
|
|
|
void CinematicGameObj::Export_Rare( BitStreamClass &packet )
|
|
{
|
|
ArmedGameObj::Export_Rare( packet );
|
|
|
|
StringClass animation_name;
|
|
AnimCollisionManagerClass::AnimModeType anim_mode = AnimCollisionManagerClass::ANIMATE_TARGET;
|
|
|
|
//
|
|
// Dig the animation data out of the physics object
|
|
//
|
|
DynamicAnimPhysClass *dynanim = Peek_Physical_Object()->As_DynamicAnimPhysClass();
|
|
if (dynanim != NULL) {
|
|
AnimCollisionManagerClass &anim_mgr = dynanim->Get_Animation_Manager();
|
|
|
|
//
|
|
// Get the animation name
|
|
//
|
|
HAnimClass *anim = anim_mgr.Peek_Animation();
|
|
if (anim != NULL) {
|
|
animation_name = anim->Get_Name();
|
|
}
|
|
|
|
//
|
|
// Get the animation mode
|
|
//
|
|
anim_mode = anim_mgr.Get_Animation_Mode ();
|
|
}
|
|
|
|
//
|
|
// Send the animation data to the client
|
|
//
|
|
packet.Add_Terminated_String( (const char *)animation_name, true );
|
|
packet.Add( anim_mode );
|
|
return ;
|
|
}
|
|
|
|
|
|
void CinematicGameObj::Import_Rare( BitStreamClass &packet )
|
|
{
|
|
ArmedGameObj::Import_Rare( packet );
|
|
|
|
//
|
|
// Get information about the animation
|
|
//
|
|
StringClass animation_name;
|
|
int anim_mode = AnimCollisionManagerClass::ANIMATE_TARGET;
|
|
packet.Get_Terminated_String( animation_name.Get_Buffer( 256 ), 256, true );
|
|
packet.Get( anim_mode );
|
|
|
|
//
|
|
// Pass the animation information onto the controller
|
|
//
|
|
DynamicAnimPhysClass *dynanim = Peek_Physical_Object()->As_DynamicAnimPhysClass();
|
|
if (dynanim != NULL) {
|
|
AnimCollisionManagerClass &anim_mgr = dynanim->Get_Animation_Manager();
|
|
anim_mgr.Set_Animation( animation_name );
|
|
anim_mgr.Set_Animation_Mode( (AnimCollisionManagerClass::AnimModeType)anim_mode );
|
|
}
|
|
|
|
return ;
|
|
}
|