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/Tools/LevelEdit/DefinitionUtils.cpp

458 lines
14 KiB
C++
Raw Permalink Blame History

/*
** 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/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : LevelEdit *
* *
* $Archive:: /Commando/Code/Tools/LevelEdit/DefinitionUtils.cpp $*
* *
* Author:: Patrick Smith *
* *
* $Modtime:: 8/24/01 12:15p $*
* *
* $Revision:: 11 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "StdAfx.h"
#include "definition.h"
#include "definitionmgr.h"
#include "definitionfactorymgr.h"
#include "definitionfactory.h"
#include "phys.h"
#include "Utils.h"
#include "physicalgameobj.h"
#include "tiledefinition.h"
#include "combatchunkid.h"
#include "dialogue.h"
#include "soldier.h"
#include "presetmgr.h"
///////////////////////////////////////////////////////////////////////
//
// Create_Physics_Definition
//
///////////////////////////////////////////////////////////////////////
DefinitionClass *
Create_Physics_Definition (LPCTSTR base_class_name, bool is_temp)
{
DefinitionClass *definition = NULL;
//
// Loop over all the factories, until we've found one that matches
// the base we are looking for
//
DefinitionFactoryClass *factory = NULL;
for ( factory = DefinitionFactoryMgrClass::Get_First (CLASSID_PHYSICS);
factory != NULL && definition == NULL;
factory = DefinitionFactoryMgrClass::Get_Next (factory, CLASSID_PHYSICS))
{
//
// Instantiate a definition
//
definition = factory->Create ();
if (definition != NULL) {
//
// Is this the definition 'type' we want?
//
if (((PhysDefClass *)definition)->Is_Type (base_class_name) == false) {
SAFE_DELETE (definition);
} else {
if (is_temp) {
definition->Set_ID (::Get_Next_Temp_ID ());
} else {
definition->Set_ID (DefinitionMgrClass::Get_New_ID (definition->Get_Class_ID ()));
}
}
}
}
return definition;
}
///////////////////////////////////////////////////////////////////////
//
// Create_Definition
//
///////////////////////////////////////////////////////////////////////
DefinitionClass *
Create_Definition (int class_id, bool is_temp)
{
DefinitionClass *definition = NULL;
//
// Attempt to find a factory for this definition
//
DefinitionFactoryClass *factory = DefinitionFactoryMgrClass::Find_Factory (class_id);
if (factory != NULL) {
//
// Create a new instance of the definition
//
definition = factory->Create ();
ASSERT (definition != NULL);
//
// Give the definition a new id
//
if (is_temp) {
definition->Set_ID (::Get_Next_Temp_ID ());
} else {
definition->Set_ID (DefinitionMgrClass::Get_New_ID (definition->Get_Class_ID ()));
}
}
return definition;
}
///////////////////////////////////////////////////////////////////////
//
// Copy_Definition
//
///////////////////////////////////////////////////////////////////////
void
Copy_Definition (DefinitionClass *src_def, DefinitionClass *dest_def, bool is_temp)
{
SANITY_CHECK(src_def != NULL && dest_def != NULL) {
return ;
}
//
// Make sure the definitions are of the same type.
//
uint32 class_id1 = dest_def->Get_Class_ID ();
uint32 class_id2 = src_def->Get_Class_ID ();
if (class_id1 == class_id2) {
//
// Loop over all the parameters contained in the definitions
//
int count = dest_def->Get_Parameter_Count ();
for (int index = 0; index < count; index ++) {
ParameterClass *dest_param = dest_def->Lock_Parameter (index);
ParameterClass *src_param = src_def->Lock_Parameter (index);
if ((dest_param != NULL) && (src_param != NULL)) {
//
// Is this parameter type a 'phys-def' parameter?
///If it is, we need to make sure we don't copy the phys-def ID value,
// we need to copy the properties of the phys-definition that the parameter
// points to.
//
if (dest_param->Get_Type () == ParameterClass::TYPE_MODELDEFINITIONID) {
int dest_def_id = ((ModelDefParameterClass *)dest_param)->Get_Value ();
int src_def_id = ((ModelDefParameterClass *)src_param)->Get_Value ();
DefinitionClass *dest_phys_def = DefinitionMgrClass::Find_Definition (dest_def_id, false);
DefinitionClass *src_phys_def = DefinitionMgrClass::Find_Definition (src_def_id, false);
//
// Create a new phys-def for the destination param
//
if (dest_phys_def == NULL && src_phys_def != NULL) {
dest_phys_def = ::Create_Definition (src_phys_def->Get_Class_ID (), is_temp);
if (dest_phys_def != NULL) {
((ModelDefParameterClass *)dest_param)->Set_Value (dest_phys_def->Get_ID ());
DefinitionMgrClass::Register_Definition (dest_phys_def);
}
}
//
// If both the src and dest params point to valid physics-definitions,
// then, copy the properties from the src to the dest (recursion)
//
if (dest_phys_def != NULL && src_phys_def != NULL) {
::Copy_Definition (src_phys_def, dest_phys_def, is_temp);
}
} else {
//
// Copy the parameter value
//
dest_param->Copy_Value (*src_param);
}
}
dest_def->Unlock_Parameter (index);
src_def->Unlock_Parameter (index);
}
//
// Should we copy the dialogue list as well?
//
if (class_id1 == CLASSID_GAME_OBJECT_DEF_SOLDIER) {
SoldierGameObjDef *src_soldier = reinterpret_cast<SoldierGameObjDef *> (src_def);
SoldierGameObjDef *dest_soldier = reinterpret_cast<SoldierGameObjDef *> (dest_def);
DialogueClass *src_list = src_soldier->Get_Dialog_List ();
DialogueClass *dest_list = dest_soldier->Get_Dialog_List ();
//
// Copy the settings from the base to the derived...
//
for (int index = 0; index < DIALOG_MAX; index ++) {
dest_list[index] = src_list[index];
}
}
}
return ;
}
///////////////////////////////////////////////////////////////////////
//
// Build_Embedded_Definition_List
//
///////////////////////////////////////////////////////////////////////
void
Build_Embedded_Definition_List (DEFINITION_LIST &list, DefinitionClass *parent)
{
SANITY_CHECK(parent != NULL) {
return ;
}
//
// Loop over all the parameters of this definition
//
int count = parent->Get_Parameter_Count ();
for (int index = 0; index < count; index ++) {
ParameterClass *param = parent->Lock_Parameter (index);
//
// If this is the paramter type we are looking for, get the
// definition pointer from it and return the pointer to the caller
//
if (param != NULL ) {
if (param->Get_Type () == ParameterClass::TYPE_MODELDEFINITIONID) {
int def_id = ((ModelDefParameterClass *)param)->Get_Value ();
DefinitionClass *definition = DefinitionMgrClass::Find_Definition (def_id, false);
if (definition != NULL) {
list.Add (definition);
//
// Now recurse into the model definition
//
Build_Embedded_Definition_List (list, definition);
}
} else if (param->Get_Type () == ParameterClass::TYPE_PHYSDEFINITIONID) {
int def_id = ((PhysDefParameterClass *)param)->Get_Value ();
DefinitionClass *definition = DefinitionMgrClass::Find_Definition (def_id, false);
if (definition != NULL) {
list.Add (definition);
}
}
}
parent->Unlock_Parameter (index);
}
return ;
}
///////////////////////////////////////////////////////////////////////
//
// Fix_Embedded_Definition_IDs
//
///////////////////////////////////////////////////////////////////////
void
Fix_Embedded_Definition_IDs (DefinitionClass *parent)
{
SANITY_CHECK(parent != NULL) {
return ;
}
//
// Loop over all the parameters of this definition
//
int count = parent->Get_Parameter_Count ();
for (int index = 0; index < count; index ++) {
ParameterClass *param = parent->Lock_Parameter (index);
//
// If this is the paramter type we are looking for, get the
// definition pointer from it and return the pointer to the caller
//
if (param != NULL ) {
if (param->Get_Type () == ParameterClass::TYPE_MODELDEFINITIONID) {
int def_id = ((ModelDefParameterClass *)param)->Get_Value ();
DefinitionClass *definition = DefinitionMgrClass::Find_Definition (def_id, false);
if (definition != NULL) {
//
// Give this definition a new ID if necessary
//
if (definition->Get_ID () >= TEMP_DEF_ID_START) {
definition->Set_ID (DefinitionMgrClass::Get_New_ID (definition->Get_Class_ID ()));
((ModelDefParameterClass *)param)->Set_Value (definition->Get_ID ());
}
//
// Now recurse into the model definition
//
Fix_Embedded_Definition_IDs (definition);
}
} else if (param->Get_Type () == ParameterClass::TYPE_PHYSDEFINITIONID) {
int def_id = ((PhysDefParameterClass *)param)->Get_Value ();
DefinitionClass *definition = DefinitionMgrClass::Find_Definition (def_id, false);
if (definition != NULL) {
//
// Give this definition a new ID if necessary
//
if (definition->Get_ID () >= TEMP_DEF_ID_START) {
definition->Set_ID (DefinitionMgrClass::Get_New_ID (definition->Get_Class_ID ()));
((PhysDefParameterClass *)param)->Set_Value (definition->Get_ID ());
}
}
}
}
parent->Unlock_Parameter (index);
}
return ;
}
///////////////////////////////////////////////////////////////////////
//
// Find_Physics_Definition
//
///////////////////////////////////////////////////////////////////////
DefinitionClass *
Find_Physics_Definition (DefinitionClass *parent)
{
SANITY_CHECK(parent != NULL) {
return NULL;
}
DefinitionClass *definition = NULL;
//
// Loop over all the parameters of this definition
//
int count = parent->Get_Parameter_Count ();
for (int index = 0; index < count && definition == NULL; index ++) {
ParameterClass *param = parent->Lock_Parameter (index);
//
// If this is the paramter type we are looking for, get the
// definition pointer from it and return the pointer to the caller
//
if (param != NULL && param->Get_Type () == ParameterClass::TYPE_MODELDEFINITIONID) {
int def_id = ((ModelDefParameterClass *)param)->Get_Value ();
definition = DefinitionMgrClass::Find_Definition (def_id, false);
}
parent->Unlock_Parameter (index);
}
return definition;
}
///////////////////////////////////////////////////////////////////////
//
// Get_Phys_Obj_From_Definition
//
///////////////////////////////////////////////////////////////////////
PhysClass *
Get_Phys_Obj_From_Definition (DefinitionClass *definition)
{
SANITY_CHECK (definition != NULL) {
return NULL;
}
PhysClass *retval = NULL;
//
// What type of object will this definition create?
//
int class_id = definition->Get_Class_ID ();
switch (::SuperClassID_From_ClassID (class_id))
{
/*case CLASSID_TERRAIN:
{
//
// Create the terrain and pull out its physics object
//
TerrainNodeClass *node = (TerrainNodeClass *)definition->Create ();
if (node != NULL) {
MEMBER_ADD (retval, node->Peek_Physics_Obj ());
MEMBER_RELEASE (node);
}
}
break;*/
case CLASSID_TILE:
{
//
// Create the tile and pull out its physics object
//
int phys_def_id = ((TileDefinitionClass *)definition)->Get_Phys_Def_ID ();
if (phys_def_id != 0) {
DefinitionClass *phys_def = DefinitionMgrClass::Find_Definition (phys_def_id, false);
if (phys_def != NULL) {
retval = (PhysClass *)phys_def->Create ();
}
}
}
break;
case CLASSID_GAME_OBJECTS:
{
//
// Create the game object and pull out its physics object
//
BaseGameObj *game_obj = (BaseGameObj *)definition->Create ();
if (game_obj != NULL) {
PhysicalGameObj *phys_game_obj = game_obj->As_PhysicalGameObj ();
if (phys_game_obj != NULL) {
MEMBER_ADD (retval, phys_game_obj->Peek_Physical_Object ());
}
game_obj->Set_Delete_Pending ();
}
}
break;
}
return retval;
}
Reference in a new issue View git blame Copy permalink