/*
** 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/transition.cpp $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 1/09/02 3:53p $*
* *
* $Revision:: 75 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
** Includes
*/
#include "transition.h"
#include "soldier.h"
#include "debug.h"
#include "assets.h"
#include "combat.h"
#include "ccamera.h"
#include "gameobjmanager.h" // hack???
#include "scripts.h"
#include "hanim.h"
#include "slist.h"
#include "vehicle.h"
#include "phys3.h"
#include "wwprofile.h"
#include "diaglog.h"
#include <string.h>
#include <stdlib.h>
#include "pathaction.h"
/*
**
*/
const char * TransitionTypeNames[] = {
"LADDER_EXIT_TOP",
"LADDER_EXIT_BOTTOM",
"LADDER_ENTER_TOP",
"LADDER_ENTER_BOTTOM",
"LEGACY_VEHICLE_ENTER_0",
"LEGACY_VEHICLE_ENTER_1",
"LEGACY_VEHICLE_EXIT_0",
"LEGACY_VEHICLE_EXIT_1",
"VEHICLE_ENTER",
"VEHICLE_EXIT",
};
/*
**
*/
bool Is_Point_Inside( const Vector3 & pos, const Vector3 & min, const Vector3 & max )
{
return ( ( pos.X >= min.X ) && ( pos.X <= max.X ) &&
( pos.Y >= min.Y ) && ( pos.Y <= max.Y ) &&
( pos.Z >= min.Z ) && ( pos.Z <= max.Z ) );
}
/*
** Save and Load for TransitionDataClass
*/
namespace TRANSITION_DATA_CLASS_SAVELOAD
{
enum {
CHUNKID_VARIABLES = 0x11051106,
MICROCHUNKID_TYPE = 1,
MICROCHUNKID_ZONE,
MICROCHUNKID_ANIMATION_NAME,
MICROCHUNKID_ENDING_TM,
MICROCHUNKID_LADDER_INDEX
};
}
/*
**
*/
TransitionDataClass::TransitionDataClass( )
: Type( LADDER_EXIT_TOP )
{
}
/*
**
*/
const char * TransitionDataClass::Get_Type_Name( StyleType type )
{
WWASSERT( ((int)type) < Get_Num_Types() );
return TransitionTypeNames[((int)type)];
}
/*
**
*/
bool TransitionDataClass::Save( ChunkSaveClass & csave )
{
using namespace TRANSITION_DATA_CLASS_SAVELOAD;
csave.Begin_Chunk( CHUNKID_VARIABLES );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TYPE, Type );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_ZONE, Zone );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_ENDING_TM, EndingTM );
WRITE_MICRO_CHUNK_WWSTRING( csave, MICROCHUNKID_ANIMATION_NAME, AnimationName );
csave.End_Chunk();
return true;
}
/*
**
*/
bool TransitionDataClass::Load( ChunkLoadClass & cload )
{
using namespace TRANSITION_DATA_CLASS_SAVELOAD;
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_VARIABLES:
{
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_TYPE, Type );
READ_MICRO_CHUNK( cload, MICROCHUNKID_ZONE, Zone );
READ_MICRO_CHUNK( cload, MICROCHUNKID_ENDING_TM, EndingTM );
READ_MICRO_CHUNK_WWSTRING( cload, MICROCHUNKID_ANIMATION_NAME, AnimationName );
default:
Debug_Say(( "Unrecognized Transition Variable chunkID\n" ));
break;
}
cload.Close_Micro_Chunk();
}
break;
}
default:
Debug_Say(( "Unrecognized Transition chunkID\n" ));
break;
}
cload.Close_Chunk();
}
switch ( Type ) {
case LEGACY_VEHICLE_ENTER_0:
case LEGACY_VEHICLE_ENTER_1:
Type = VEHICLE_ENTER;
break;
case LEGACY_VEHICLE_EXIT_0:
case LEGACY_VEHICLE_EXIT_1:
Type = VEHICLE_EXIT;
break;
}
return true;
}
/*
** TransitionCompletionDataStruct
*/
namespace TRANSITION_COMPLETION_SAVE_LOAD
{
enum {
CHUNKID_VARIABLES = 1105991816,
CHUNKID_VEHICLE,
MICROCHUNKID_TYPE = 1,
};
}
bool TransitionCompletionDataStruct::Save( ChunkSaveClass & csave )
{
using namespace TRANSITION_COMPLETION_SAVE_LOAD;
csave.Begin_Chunk( CHUNKID_VARIABLES );
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TYPE, Type );
csave.End_Chunk();
csave.Begin_Chunk( CHUNKID_VEHICLE );
Vehicle.Save( csave );
csave.End_Chunk();
return true;
}
bool TransitionCompletionDataStruct::Load( ChunkLoadClass & cload )
{
using namespace TRANSITION_COMPLETION_SAVE_LOAD;
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_VARIABLES:
while (cload.Open_Micro_Chunk()) {
switch(cload.Cur_Micro_Chunk_ID()) {
READ_MICRO_CHUNK( cload, MICROCHUNKID_TYPE, Type );
default:
Debug_Say(( "Unrecognized TransitionCompletion Variable chunkID\n" ));
break;
}
cload.Close_Micro_Chunk();
}
break;
case CHUNKID_VEHICLE:
Vehicle.Load( cload );
break;
default:
Debug_Say(( "Unrecognized TransitionCompletion chunkID\n" ));
break;
}
cload.Close_Chunk();
}
return true;
}
/*
** TransitionInstanceClass
*/
TransitionInstanceClass::TransitionInstanceClass( const TransitionDataClass & data ) :
Data( data ),
EndingTM( 1 ),
LadderIndex( -1 ),
Zone( Vector3( 0,0,0 ), Vector3( 0,0,0 ) )
{
}
TransitionInstanceClass::~TransitionInstanceClass( void )
{
}
bool TransitionInstanceClass::Check( SoldierGameObj *obj, bool action_trigger )
{
Vector3 pos;
obj->Get_Position( &pos );
// make sure we are in the zone
if ( CollisionMath::Overlap_Test( Zone, pos ) == CollisionMath::OUTSIDE ) {
return false; // not inside
}
// ignore triggers when transitioning
if ( obj->Is_State_Locked() ) {
return false;
}
// Bail if not manually triggered and not ladder exit and
if ( !action_trigger &&
( Get_Type() != TransitionDataClass::LADDER_EXIT_TOP ) &&
( Get_Type() != TransitionDataClass::LADDER_EXIT_BOTTOM ) ) {
#if 0
// no auto transitions or not human controlled
if ( !CombatManager::Are_Transitions_Automatic() ||
!obj->Is_Human_Controlled() )
#endif
{
return false;
}
}
bool condition = action_trigger;
if ( action_trigger == false ) {
const float MIN_VELOCITY = 0.1f;
// Check for auto trigger
Vector3 vel;
obj->Get_Velocity( vel );
if ( vel.Length() > MIN_VELOCITY ) {
Vector3 end_direction;
// make sure we meet the conditions
switch ( Get_Type() ) {
case TransitionDataClass::LADDER_ENTER_BOTTOM:
end_direction = EndingTM.Get_X_Vector();
end_direction.Normalize();
break;
case TransitionDataClass::LADDER_ENTER_TOP:
end_direction = -EndingTM.Get_X_Vector();
end_direction.Normalize();
break;
case TransitionDataClass::LADDER_EXIT_BOTTOM:
end_direction = Vector3( 0, 0, -1 );
break;
case TransitionDataClass::LADDER_EXIT_TOP:
end_direction = Vector3( 0, 0, 1 );
break;
case TransitionDataClass::VEHICLE_ENTER:
case TransitionDataClass::VEHICLE_EXIT:
vel.Z = 0; // don't consider vertical
end_direction = EndingTM.Get_Translation() - Zone.Center;
end_direction.Normalize();
break;
default:
Debug_Say(( "Unrecognized Transition Type\n" ));
condition = false;
break;
}
// If still has length
if ( vel.Length() > MIN_VELOCITY ) {
vel.Normalize();
float dotp = Vector3::Dot_Product( vel, end_direction );
if ( dotp > 0.5f ) {
condition = true;
}
}
}
}
// make sure we meet the conditions
switch ( Get_Type() ) {
case TransitionDataClass::LADDER_EXIT_TOP:
case TransitionDataClass::LADDER_EXIT_BOTTOM:
if ( !obj->Is_On_Ladder() ) {
condition = false;
}
break;
case TransitionDataClass::LADDER_ENTER_TOP:
case TransitionDataClass::LADDER_ENTER_BOTTOM:
if ( !obj->Is_Upright() ) {
condition = false;
}
break;
case TransitionDataClass::VEHICLE_ENTER:
if ( !obj->Is_Upright() && !obj->Is_Wounded() ) {
// Added wounded because we couldn't enter vehicles in a tib field
condition = false;
}
VehicleGameObj * p_vehicle;
p_vehicle = (VehicleGameObj *) Vehicle.Get_Ptr();
WWASSERT(p_vehicle != NULL);
if (!obj->Is_Permitted_To_Enter_Vehicle() ||
!p_vehicle->Is_Entry_Permitted(obj)) {
condition = false;
}
// When entering a vehicle, ensure that there are no walls between us
// Do this by casting a ray from our position to the vehicle position; only
// checking against static geometry.
{
Vector3 p0,p1;
p_vehicle->Get_Position(&p0);
obj->Get_Position(&p1);
CastResultStruct result;
LineSegClass ray(p0,p1);
int colgroup = obj->Peek_Physical_Object()->Get_Collision_Group();
PhysRayCollisionTestClass raytest(ray,&result,colgroup,COLLISION_TYPE_PHYSICAL);
raytest.CheckDynamicObjs = false;
PhysicsSceneClass::Get_Instance()->Cast_Ray(raytest);
if (result.Fraction < 1.0f) {
condition = false;
}
}
break;
case TransitionDataClass::VEHICLE_EXIT:
if ( !obj->Is_In_Vehicle() ) {
condition = false;
}
break;
default:
Debug_Say(( "Unrecognized Transition Type\n" ));
condition = false;
break;
}
if ( !condition ) {
return false;
}
//
// Check to ensure the object can teleport to the ending location
//
Matrix3D dummy_tm;
MoveablePhysClass *move_phys = obj->Peek_Physical_Object()->As_MoveablePhysClass();
switch ( Get_Type() ) {
case TransitionDataClass::LADDER_ENTER_TOP:
case TransitionDataClass::LADDER_ENTER_BOTTOM:
{
//
// Its not legal to get on a ladder when someone else is on the ladder.
// Try to detect this case.
//
if( obj == COMBAT_STAR && LadderIndex >= 0 ) {
ScriptableGameObj *occupant = PathActionClass::Get_Ladder_Occupant( LadderIndex );
if( occupant != NULL && occupant != obj ) {
condition = false;
}
}
break;
}
case TransitionDataClass::LADDER_EXIT_TOP:
case TransitionDataClass::LADDER_EXIT_BOTTOM:
//
// When exiting a Ladder, we just have to check for a dynamic object blocking our
// exit point. (the third parameter to Can_Teleport_And_Stand is true...)
//
/*if ( move_phys != NULL &&
move_phys->Can_Teleport(EndingTM, true) == false)
{
condition = false;
}*/
break;
case TransitionDataClass::VEHICLE_EXIT:
//
// When exiting a vehicle, we perform two steps:
// - ignore our vehicle and sweep the character to the exit transform
// - un-ignore the vehicle and do a teleport test.
//
if (move_phys != NULL) {
bool can_move_to;
VehicleGameObj * vgobj = Get_Vehicle();
PhysClass * pobj = vgobj->Peek_Physical_Object();
pobj->Inc_Ignore_Counter();
can_move_to = move_phys->Can_Move_To(EndingTM);
pobj->Dec_Ignore_Counter();
if ( (can_move_to == false) ||
(move_phys->Can_Teleport_And_Stand(EndingTM,&dummy_tm) == false) )
{
condition = false;
}
}
break;
}
if ( !condition ) {
return false;
}
Start( obj );
return true;
}
void TransitionInstanceClass::Start( SoldierGameObj *obj )
{
// Debug_Say(( "Starting Animation\n" ));
// if this is the camera's target...
if ( COMBAT_STAR == obj ) {
// Get duration
#if 0
HAnimClass * animation = WW3DAssetManager::Get_Instance()->Get_HAnim( Data.Get_Animation_Name() );
if ( animation ) {
float anim_duration = animation->Get_Num_Frames() / animation->Get_Frame_Rate();
animation->Release_Ref();
// COMBAT_CAMERA->Set_Lerp_Time( anim_duration * 1.3f );
COMBAT_CAMERA->Set_Lerp_Time( anim_duration );
}
#else
COMBAT_CAMERA->Set_Lerp_Time( 1.0f );
#endif
}
// set the object ending position & orientation
#ifdef WWDEBUG
Vector3 pos = EndingTM.Get_Translation();
if (!pos.Is_Valid()) {
WWDEBUG_SAY(("Transition EndingTM has invalid position: %f, %f, %f\r\n",pos.X,pos.Y,pos.Z));
}
#endif
obj->Set_Transform( EndingTM );
if ( obj->Peek_Physical_Object() != NULL && obj->Peek_Physical_Object()->As_Phys3Class() != NULL ) {
obj->Peek_Physical_Object()->As_Phys3Class()->Set_Velocity( Vector3(0,0,0) );
}
// make the completion data
TransitionCompletionDataStruct * completion_data = new TransitionCompletionDataStruct;
completion_data->Type = Data.Get_Type();
completion_data->Vehicle = Vehicle;
//
// Mark ladders as being used/free as necessary
//
switch ( Get_Type() ) {
case TransitionDataClass::LADDER_ENTER_TOP:
case TransitionDataClass::LADDER_ENTER_BOTTOM:
{
//
// Mark this ladder as being "in use" so no one else tries to get on it
//
if( obj == COMBAT_STAR && LadderIndex >= 0 ) {
PathActionClass::Set_Ladder_Occupant( LadderIndex, obj );
}
break;
}
case TransitionDataClass::LADDER_EXIT_TOP:
case TransitionDataClass::LADDER_EXIT_BOTTOM:
{
//
// Free this ladder so other's can use it
//
if( obj == COMBAT_STAR && LadderIndex >= 0 ) {
PathActionClass::Set_Ladder_Occupant( LadderIndex, NULL );
}
break;
}
}
#if 0
obj->Start_Transition_Animation( Data.Get_Animation_Name(), completion_data );
VehicleGameObj * vehicle = Get_Vehicle();
// If vehicle entry/exit, allow it to animate as well
switch ( Get_Type() ) {
case TransitionDataClass::VEHICLE_ENTER:
{
if ( vehicle ) {
vehicle->Passenger_Entering();
}
break;
}
case TransitionDataClass::VEHICLE_EXIT:
{
WWASSERT( vehicle );
// obj->Set_Vehicle_State( SoldierGameObj::EXITING_VEHICLE, vehicle );
vehicle->Passenger_Exiting();
break;
}
default:
break;
}
#else
End( obj, completion_data );
#endif
}
void TransitionInstanceClass::End( SoldierGameObj *obj,
TransitionCompletionDataStruct * completion_data )
{
VehicleGameObj * vehicle = (VehicleGameObj *)completion_data->Vehicle.Get_Ptr();
switch ( completion_data->Type ) {
case TransitionDataClass::LADDER_EXIT_TOP:
case TransitionDataClass::LADDER_EXIT_BOTTOM:
obj->Exit_Ladder();
if ( obj == COMBAT_STAR ) {
Vector3 pos;
obj->Get_Position( &pos );
DIAG_LOG(( "LAEX", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
break;
case TransitionDataClass::LADDER_ENTER_TOP:
case TransitionDataClass::LADDER_ENTER_BOTTOM:
obj->Enter_Ladder( completion_data->Type == TransitionDataClass::LADDER_ENTER_TOP );
if ( obj == COMBAT_STAR ) {
Vector3 pos;
obj->Get_Position( &pos );
DIAG_LOG(( "LAEN", "%1.2f; %1.2f; %1.2f", pos.X, pos.Y, pos.Z ));
}
break;
case TransitionDataClass::VEHICLE_ENTER:
{
if ( vehicle != NULL ) {
vehicle->Add_Occupant( obj );
}
break;
}
case TransitionDataClass::VEHICLE_EXIT:
{
if ( vehicle != NULL ) {
vehicle->Remove_Occupant( obj );
} else {
obj->Exit_Vehicle();
}
break;
}
default:
Debug_Say(( "Unrecognized Transition Type\n" ));
break;
}
// Delete the data (soldier better not use it)
delete completion_data;
}
void TransitionInstanceClass::Set_Parent_Transform( const Matrix3D & tm )
{
Matrix3D::Multiply( tm, Data.Get_Ending_TM(), &EndingTM );
OBBoxClass::Transform( tm, Data.Get_Zone(), &Zone );
}
/*
** TransitionManager
*/
SList<TransitionInstanceClass> Transitions;
SList<TransitionInstanceClass> TransitionsDestroy;
void TransitionManager::Add( TransitionInstanceClass * transition )
{
Transitions.Add_Tail( transition );
}
void TransitionManager::Destroy( TransitionInstanceClass * transition )
{
TransitionsDestroy.Add_Tail( transition );
}
void TransitionManager::Reset( void )
{
Destroy_Pending();
while ( Transitions.Get_Count() ) {
delete Transitions.Remove_Head();
}
}
void TransitionManager::Destroy_Pending( void )
{
while ( TransitionsDestroy.Get_Count() ) {
TransitionInstanceClass * trans = TransitionsDestroy.Remove_Head();
Transitions.Remove( trans );
delete trans;
}
}
bool TransitionManager::Check( SoldierGameObj *obj, bool action_trigger )
{
WWPROFILE( "Transition Check" );
SLNode<TransitionInstanceClass> *ti_node;
for ( ti_node = Transitions.Head(); ti_node; ti_node = ti_node->Next()) {
if ( ti_node->Data()->Check( obj, action_trigger ) ) {
Destroy_Pending();
return true;
}
}
return false;
}
void TransitionManager::Build_Ladder_List (DynamicVectorClass<TransitionInstanceClass *> &list)
{
SLNode<TransitionInstanceClass> *ti_node = NULL;
for ( ti_node = Transitions.Head(); ti_node; ti_node = ti_node->Next()) {
//
// Is this a ladder transition?
//
TransitionDataClass::StyleType type = ti_node->Data()->Get_Type ();
if ( type == TransitionDataClass::LADDER_EXIT_TOP || type == TransitionDataClass::LADDER_EXIT_BOTTOM ||
type == TransitionDataClass::LADDER_ENTER_TOP || type == TransitionDataClass::LADDER_ENTER_BOTTOM)
{
list.Add( ti_node->Data () );
}
}
return ;
}