Initial commit of Command & Conquer Renegade source code.

2025-12-15 23:21:40 -05:00 · 2025-02-27 16:39:46 +00:00
parent 74ab8fa5e0
commit 58ed459113
4918 changed files with 1366710 additions and 0 deletions
--- a/Code/Combat/transition.cpp
+++ b/Code/Combat/transition.cpp
@@ -0,0 +1,735 @@
+/*
+**	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 ;
+}