guus
/
reman3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
reman3/Rayman_X/cpa/tempgrp/OAC/Src/EdActors/EDACDoc.cpp

2961 lines
103 KiB
C++
Raw Permalink Blame History

// Implementation for the class CMyDocument
/////////////////////////////////////////////
#include "StdAfx.h"
#include "_AInterf.hpp"
#include "EDACDoc.hpp"
#include "EDACDgMC.hpp"
#include "EDACDgMN.hpp"
#include "EDACDgCp.hpp"
#include "EDACDgIf.hpp"
#include "EDACActr.hpp"
#include "EDACDgMC.hpp"
#include "EDACDgMn.hpp"
#include "EDACVwAc.hpp"
#include "EDACVwMS.hpp"
#include "EDACModl.hpp"
#include "EDACCnst.hpp"
#include "EDACGlob.hpp"
#include "EDACStrg.hpp"
#include "EDACDgML.hpp"
#include "EDACDgIC.hpp"
#include "Defines.hpp"
//External Modules
#include "TFa.h"
#include "DPT.h"
#include "Tot.h"
#include "ErO.h"
//End of External Modules
//-----------------IR-------------------------
#include "EdIRFrm.hpp"
#include "EdIRBeEn.hpp"
#include "EdIRDVVw.hpp"
#include "EDACQuer.hpp"
// Shaitan => state list in the level
#include "ai_intf.hpp"
// End Shaitan => state list in the level
//--------------------------------------------
//ROMTEAM LoadAI (Cristi Petrescu 26/03/98)
#include "dlgldai.hpp"
#include "ITF/cpaproj.hpp"
//ENDROMTEAM LoadAI (Cristi Petrescu)
//CPA2 Stegaru Cristian 98/07/01
#include "..\inc\edactors\dlgcleanalwfile.h"
//End CPA2 Stegaru Cristian 98/07/01
#undef CPA_WANTS_IMPORT
#undef CPA_EXPORT
#define CPA_WANTS_EXPORT
//-----------------IR-------------------------
#include "EdIRIRD.hpp"
//--------------------------------------------
#include "_Actors.hpp"
#undef CPA_WANTS_EXPORT
#define CPA_WANTS_IMPORT
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//****************************************************************************
EdActors_MyDocument::EdActors_MyDocument()
{
//Creates lists of actors and models
m_eCurrentDisplayMode = ED_ACTORS_eDisplayMode_Instance;
m_pclCurrentActorsList = &m_clInstancesList;
m_pclCurrentMiniStructureList = NULL;
m_bAIFirstTime = TRUE;
//Initializes editor's state
m_pclDialogList = NULL;
m_pclActorsView = NULL;
m_pclMiniStrucView = NULL;
//-----------------IR-------------------------
m_pclDesignerVariablesView = NULL;
//--------------------------------------------
m_pclSelectedActor = NULL;
m_pclCurrentInstance = NULL;
m_pclCurrentModel = NULL;
m_pclCurrentFamily = NULL;
//Editor's Setup var. Init.
m_bMustConfirmUnallocation = TRUE;
m_bMustConfirmAllocation = TRUE;
m_bMustRefreshDatas = FALSE;
m_bMustConfirmWatchSuppression = TRUE;
m_bMustDisplayModelFieldsInInstance = TRUE;
m_bMustDisplayUnallocatedMS = TRUE;
m_bMustDisplayHelpOnActiveView = FALSE;
m_bWatchAlwaysVisible = TRUE;
m_bProposeUnloadedModels = FALSE;//TRUE;
m_bRestoreGroup = FALSE;
m_bAskForNewInstanceName = TRUE;
//Colors for the name's (model or instance) static
m_pub_colref_NameTextColor = RGB(0,0,0);
m_pub_colref_NameBackgroundColor = RGB(224,224,224);
//Colors for the model's static
m_pub_colref_ModelTextColor = RGB(0,0,0);
m_pub_colref_ModelBackgroundColor = RGB(224,224,224);
//Colors for the family's static
m_pub_colref_FamilyTextColor = RGB(0,0,0);
m_pub_colref_FamilyBackgroundColor = RGB(224,224,224);
//Colors for the fields' static
m_pub_colref_FieldInstanceTextColor = RGB(0,0,0);
m_pub_colref_FieldInstanceBackgroundColor = RGB(224,224,224);
m_pub_colref_FieldInitialTextColor = RGB(0,0,0);
m_pub_colref_FieldInitialBackgroundColor = RGB(224,224,224);
m_pub_colref_FieldCurrentTextColor = RGB(0,0,0);
m_pub_colref_FieldCurrentBackgroundColor = RGB(224,224,224);
m_pub_colref_InWatchFieldTextColor = RGB(255,0,0);
m_pub_colref_InWatchFieldBackgroundColor = RGB(160,160,160);
m_pub_colref_FieldModelTextColor = RGB(0,0,0);
m_pub_colref_FieldModelBackgroundColor = RGB(224,224,224);
m_ulListViewHeight = 150;
m_ulControlViewHeight = 150;
m_ulMSViewHeight = 300;
m_ulModelViewHeight = 200;
m_ulAIViewHeight = 200;
m_ulCharacEditorWidth = C_EDITOR_WIDTH;
//ANNECY Shaitan Correction (16/04/98) {
// m_ucCurrentDataLevel = 2;
//ENDANNECY Shaitan Correction }
m_bIAActivated = FALSE;
m_bWatchActivated = FALSE;
m_bVariablesActivated = FALSE;
m_bDisplayCurrentValue = TRUE;
m_bDisplayInitialValue = TRUE;
m_pri_bTreeMustShowUnloadedObjects = FALSE;
m_pri_bTreeMustOnlyShowFamiliesWithModels = FALSE;
//
m_pub_bMustShowLinks = FALSE;
//
m_pub_bMustDisplayHelpOnFields = FALSE;
m_hPreviousCursorForHelpOnFields = NULL;
//Loads cursor
m_hHelpCursor = AfxGetApp()->LoadCursor(IDC_CURSOR_HELP);
m_hHelpDisabledCursor = AfxGetApp()->LoadCursor(IDC_CURSOR_DISABLED_HELP);
m_pub_bUnloadedModelsArePrepared = FALSE;
m_pub_bWatchWindowIsVisible = FALSE;
m_pub_hWatchIcon_Field = AfxGetApp()->LoadIcon(IDI_CAR_WATCH_FIELD);
m_pub_hWatchIcon_Actor = AfxGetApp()->LoadIcon(IDI_CAR_WATCH_ACTOR);
m_pub_hWatchIcon_MS = AfxGetApp()->LoadIcon(IDI_CAR_WATCH_MS);
m_bDisplayActor = FALSE;
m_pLoadedModel = NULL;
//Other init.
m_fn_vInitialize();
}
//****************************************************************************
EdActors_MyDocument::~EdActors_MyDocument()
{
//Deletes list of enum descriptors
POSITION pos = m_clListOfEnumDescriptors.GetHeadPosition();
while ( pos != NULL )
delete (m_clListOfEnumDescriptors.GetNext(pos));
//Deletes list of mask descriptors
pos = m_clListOfMasksDescriptors.GetHeadPosition();
while ( pos != NULL )
delete (m_clListOfMasksDescriptors.GetNext(pos));
//Deletes editor Instances and Models
// delete m_pclActorsList;
// delete m_pclModelsList;
m_fn_bWriteIniFile();
//CPA2 Stegaru Cristian 98-05
m_clUnloadedAlwaysList.DeleteAllObjects ();
//End CPA2 Stegaru Cristian 98-05
}
//****************************************************************************
//Extra init.
void EdActors_MyDocument::m_fn_vInitialize()
{
//Constructs the list of Enum desciptors
m_fn_vConstructListOfEnumDescriptors();
//Constructs the list of Mask desciptors
m_fn_vConstructListOfMaskDescriptors();
//Fills the mini-structure list (controls)
m_fn_vFillMiniStructureList();
//Init. the INI file name
m_csIniFileName = M_GetMainApp()->m_csEditorDataPath + "Objects\\Actors\\" + C_szActorsIniFileName;
//Reads INI file
m_fn_bReadIniFile();
m_pri_fn_bLoadDimensions();
//HelpFilename
m_csHelpFileNameAndPath = M_GetMainApp()->m_csEditorDataPath
+ CString("Objects\\Actors\\Help\\Actors.hlp >Normale");
//-----------------IR-------------------------
m_csBrainHelpFileNameAndPath= M_GetMainApp()->m_csEditorDataPath
+ CString("Objects\\Actors\\Help\\EdIRfr.hlp");
m_bDesignerVarEditorIsVisible = TRUE;
//--------------------------------------------
//Editor's data
m_csModelsBitmapsPath = CString("Objects\\Actors\\Models\\Actors\\");
m_csModelsBitmapsCompletePath = M_GetMainApp()->m_csEditorDataPath
+ m_csModelsBitmapsPath;
m_csModelsBitmapsPathForGenDoors = CString("Objects\\Actors\\Models\\GenDoors\\");
m_csModelsBitmapsCompletePathForGenDoors = M_GetMainApp()->m_csEditorDataPath
+ m_csModelsBitmapsPathForGenDoors;
}
///////////////////////////////////
// Models and Instances handling //
///////////////////////////////////
//***************************************************************************
void EdActors_MyDocument::m_fn_vCreateCopiesOfActor(CPA_Actor *_pclSourceActor)
{
EdActors_CopyDialog dial(_pclSourceActor, &g_oBaseFrame);
if ( dial.DoModal() == IDOK )
{
if ( _pclSourceActor->m_fn_bIsAModel() )
m_fn_vCreateCopiesOfModel(_pclSourceActor, dial.m_lCopiesNumber, dial.m_csNewName);
else if ( _pclSourceActor->m_fn_bIsAnInstance() )
m_fn_vCreateCopiesOfInstance(_pclSourceActor, dial.m_lCopiesNumber, dial.m_csNewName);
}
}
/////////////////////
// Models handling //
/////////////////////
//***************************************************************************
//Called to create a model and add it in the list of models
CPA_SuperObject *EdActors_MyDocument::m_fn_pclCreateModel(CString &r_csModelBitmapName)
{
CPA_SuperObject *pclAddedModel = NULL;
EdActors_ModelCreationDialog dial(&g_oBaseFrame);
if ( dial.DoModal() == IDOK )
{
pclAddedModel = dial.m_fn_pclGetNewModel();
r_csModelBitmapName = dial.m_fn_csGetBitmapName();
//Displays Model
m_fn_vDisplayActor(((CPA_Actor *)(pclAddedModel->GetObject()))->m_fn_pclGetEditorActor(), ED_ACTORS_eModeOfActorSelection_Unknown);
}
return pclAddedModel;
}
//***************************************************************************
//Called to create a model and loads its data
CPA_SuperObject *EdActors_MyDocument::m_fn_pclCreateModelForLoad(CString csName,
CPA_Actor *pclEditorActor /*= NULL*/)
{
CPA_SuperObject *pclAddedModel = NULL;
//Creates all needed objects
///////////////////////////////
//Creates Editor's Actor
CPA_Actor *pclNewEditorActor;
if ( pclEditorActor == NULL )
pclNewEditorActor = new CPA_Actor(NULL,
NULL,
g_c_csActorModelType,
NULL,
NULL,
NULL,
csName);
else
pclNewEditorActor = pclEditorActor;
////////////////////////////////////////////////////////
//Creates a SuperObject
pclAddedModel = g_pclInterface->GetInterface()->GetNewSuperObject(E_ss_NoSave,
C_Protected,
"",
"");
pclNewEditorActor->m_pub_fn_vSetSuperObject(pclAddedModel);
pclAddedModel->SetModelName(pclNewEditorActor->GetName());
pclAddedModel->SetObject(pclNewEditorActor);
//PROVISOIRE...
pclAddedModel->GetStruct()->hLocalMatrix = (GEO_tdxHandleToMatrix)malloc(sizeof(POS_tdstCompletePosition));
POS_fn_vSetIdentityMatrix(pclAddedModel->GetStruct()->hLocalMatrix);
return pclAddedModel;
}
//***************************************************************************
// Adds a (loaded) Model in the list
void EdActors_MyDocument::m_fn_vAddLoadedModelInList(EdActors_EditorActorModel *pclModel,
BOOL bMustAddInGlobalList /*= TRUE*/)
{
if ( ( pclModel != NULL ) && ( pclModel->m_pclActor->m_pub_fn_bCanBeInstantiated() ) )
{
EDT_Model *pclNewEDTModel = NULL;
CString csBitmapName;
if ( pclModel->m_pclActor->m_fn_bIsAGenDoor() )
csBitmapName = m_csModelsBitmapsPathForGenDoors + pclModel->m_fn_csGetBitmapName();
else
csBitmapName = m_csModelsBitmapsPath + pclModel->m_fn_csGetBitmapName();
//Adds in the Models Window
pclNewEDTModel = new EDT_Model( g_pclInterface,
M_MAKECHAR(g_c_csActorType),
M_MAKECHAR(pclModel->m_fn_csGetActorName()),
(char *)LPCTSTR(csBitmapName),
g_pclInterface->GetInterface() );
g_pclInterface->GetInterface()->fn_bAddANewModel( pclNewEDTModel,
M_MAKECHAR(g_c_csActorModelType),
g_pclInterface);
//Adds in internal list
g_pclInterface->m_stListModels.AddTail(pclModel->m_pclActor->m_pub_fn_pclGetSuperObject());
}
}
//***************************************************************************
//Called to remove a Model from its list, and deletes corresponding Instances
void EdActors_MyDocument::m_fn_vDeleteModel(CPA_Actor *_pclModelToDelete)
{
ERROR_ASSERT( _pclModelToDelete != NULL );
//Deletes all Instances of Model
CPA_Actor *pclCurrentInstance;
POSITION pos = _pclModelToDelete->m_fn_pclGetEditorModel()->m_clInstancesList.GetHeadPosition();
while ( pos != NULL )
{
pclCurrentInstance = _pclModelToDelete->m_fn_pclGetEditorModel()->m_clInstancesList.GetNext(pos)->m_pclActor;
}
}
//***************************************************************************
//Called to create single or multiple copy of a model
void EdActors_MyDocument::m_fn_vCreateCopiesOfModel(CPA_Actor *_pclModelToCopy,
long _lCopiesNumber,
CString _csNewName)
{
CPA_Actor *pclAddedModel;
CString csCurrentName = _csNewName;
long c_lI;
for (c_lI = 0; c_lI < _lCopiesNumber; c_lI ++)
{
if ( _lCopiesNumber > 1 )
csCurrentName.Format("%s_%ld", LPCTSTR(_csNewName), c_lI);
CPA_SuperObject *pclSuperObject = g_pclInterface->GetInterface()->GetNewSuperObject(E_ss_NoSave,
C_Protected,
"",
"");
pclAddedModel = new CPA_Actor(_pclModelToCopy, pclSuperObject, csCurrentName);
pclAddedModel->m_fn_vMakeGenDoor(_pclModelToCopy->m_fn_bIsAGenDoor());
pclSuperObject->SetModelName(pclAddedModel->GetName());
pclSuperObject->SetObject(pclAddedModel);
//PROVISOIRE...
pclSuperObject->GetStruct()->hLocalMatrix = (GEO_tdxHandleToMatrix)malloc(sizeof(POS_tdstCompletePosition));
POS_fn_vSetIdentityMatrix(pclSuperObject->GetStruct()->hLocalMatrix);
//Adds in Models Window
m_fn_vAddLoadedModelInList(pclAddedModel->m_fn_pclGetEditorModel(), FALSE);
}
//Displays last created Model
m_fn_vDisplayActor(pclAddedModel->m_fn_pclGetEditorActor(), ED_ACTORS_eModeOfActorSelection_Unknown);
}
////////////////////////
// Instances handling //
////////////////////////
//***************************************************************************
//Called to create single or multiple instances from a model
BOOL EdActors_MyDocument::m_fn_bCanInstantiateModel(CString csSourceModelName,
CString &r_csRequiredName)
{
//Remove bloc-comments for programm to ask to user a Name for the Instance
BOOL bReturnValue = FALSE;
//Gets the default name
if ( m_bAskForNewInstanceName )
{
CString csDefaultName;
CPA_List<CPA_BaseObject> clList;
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clList, "", C_szActorInstanceTypeName,NO_CRITERIA);
if ( clList.GetCount() > 0 )
csDefaultName = ((CPA_Actor *)clList.GetHead())->GetDefaultValidName(csSourceModelName + "_I"); //ANNECY BBB: new name is based on the model's
EdActors_InstanceCreationDialog dial(csSourceModelName, csDefaultName, &g_oBaseFrame);
if ( dial.DoModal() == IDOK )
{
r_csRequiredName = dial.m_fn_csGetNewInstanceName();
bReturnValue = TRUE;
}
}
else
bReturnValue = TRUE;
return bReturnValue;
}
//***************************************************************************
//Called to create a model and loads its data
CPA_SuperObject *EdActors_MyDocument::m_fn_pclCreateInstanceForLoad(CString csName, EdActors_tdhHandleToActor hActor)
{
CPA_SuperObject *pclNewInstance = NULL;
//Creates all needed objects
///////////////////////////////
//Creates Editor's Actor
CPA_Actor *pclNewEditorActor = new CPA_Actor(hActor, NULL, g_c_csActorType, NULL, NULL, NULL, csName);
////////////////////////////////////////////////////////
//Creates a SuperObject
pclNewInstance = g_pclInterface->GetInterface()->GetNewSuperObject( E_ss_NoSave, C_Protected, "", "");
pclNewEditorActor->m_pub_fn_vSetSuperObject(pclNewInstance);
pclNewInstance->SetModelName(pclNewEditorActor->GetName());
pclNewInstance->SetObject(pclNewEditorActor);
//PROVISOIRE...
pclNewInstance->GetStruct()->hLocalMatrix = (GEO_tdxHandleToMatrix)malloc(sizeof(POS_tdstCompletePosition));
POS_fn_vSetIdentityMatrix(pclNewInstance->GetStruct()->hLocalMatrix);
return pclNewInstance;
}
//***************************************************************************
//Called to create single or multiple copy of an existing instance
void EdActors_MyDocument::m_fn_vCreateCopiesOfInstance( CPA_Actor *_pclInstanceToCopy,
long _lCopiesNumber,
CString _csNewName)
{
EdActors_InformationDialog InfoDial(&g_oBaseFrame, "Not available yet ...");
InfoDial.DoModal();
}
//***************************************************************************
//Called to remove an Instance from the lists ( <--> DO for Delete)
void EdActors_MyDocument::m_fn_vDeleteInstance(CPA_Actor *pclInstanceToDelete)
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Deleting an Instance",
"EdActors_MyDocument::m_fn_vDeleteInstance(...)",
E_ERROR_GRAVITY_FATAL,
"The Actor is not an Instance, but a Model !");
ERROR_ASSERT( pclInstanceToDelete->m_fn_bIsAnInstance() );
if ( !pclInstanceToDelete->m_fn_bIsAnAlways() )
m_clInstancesList.fn_bRemoveObject(pclInstanceToDelete);
//Removes Motor Actor from Sector list
HIE_tdxHandleToSuperObject hCharacter = pclInstanceToDelete->m_pub_fn_hGetMotorSuperObject();
fn_vRemoveObjectInSectorList(hCharacter);
//Removes Instance from its Model list of Instances
if ( !pclInstanceToDelete->m_fn_bIsAnAlways() )
{
EdActors_EditorActorModel *pclEdModel = (EdActors_EditorActorModel *)pclInstanceToDelete->m_fn_pclGetModel()->m_fn_pclGetEditorActor();
EdActors_EditorActorInstance *pclEdInstance = (EdActors_EditorActorInstance *)pclInstanceToDelete->m_fn_pclGetEditorActor();
pclEdModel->m_fn_vRemoveFromInstancesList(pclEdInstance);
//Removes from List
pclInstanceToDelete->fn_bUnValidate();
//Notifies
if (!pclInstanceToDelete->m_pub_fn_bIsCommon())
pclInstanceToDelete->fn_vNotifyUnSave();
//Sends a notification for the Level to be saved
m_fn_vNotifyLevel(pclInstanceToDelete, FALSE);
// ANNECY MT 13-02-97 {
// Removes from Coherence Manager
g_oCoherenceManager.m_fn_vDeleteObject(pclInstanceToDelete);
// END ANNECY MT }
}
//Updates DialogList
m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
//If Actors is edited, changes current actor
if ( m_pub_fn_bCurrentModeIsInstance() )
{
if ( m_pclCurrentInstance == pclInstanceToDelete->m_fn_pclGetEditorActor() )
{
m_pclCurrentInstance = NULL;
m_fn_vDisplayActor(m_pclCurrentModel, ED_ACTORS_eModeOfActorSelection_Unknown);
}
}
}
//***************************************************************************
//Called to re-put an Instance in the lists (<--> UNDO for Delete)
void EdActors_MyDocument::m_fn_vUndeleteInstance(CPA_Actor *pclInstanceToUndelete)
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Undeleting an Instance",
"EdActors_MyDocument::m_fn_vUndeleteInstance(...)",
E_ERROR_GRAVITY_FATAL,
"The Actor is not an Instance, but a Model !");
ERROR_ASSERT( pclInstanceToUndelete->m_fn_bIsAnInstance() );
m_clInstancesList.fn_bAddObject(pclInstanceToUndelete);
//Puts Motor Actor in Sector list
HIE_tdxHandleToSuperObject hCharacter = pclInstanceToUndelete->m_pub_fn_hGetMotorSuperObject();
struct MTH3D_tdstVector_ tdstVector;
POS_fn_vGetTranslationVector(fn_p_st3dDataGetMatrix(M_GetMSHandle(hCharacter,3dData)), &tdstVector);
fn_vSectInfoInitForSingleCharacter(hCharacter, &tdstVector);
//Adds Instance to its Model list of Instances
EdActors_EditorActorModel *pclEdModel = (EdActors_EditorActorModel *)pclInstanceToUndelete->m_fn_pclGetModel()->m_fn_pclGetEditorActor();
EdActors_EditorActorInstance *pclEdInstance = (EdActors_EditorActorInstance *)pclInstanceToUndelete->m_fn_pclGetEditorActor();
pclEdModel->m_fn_vAddToInstancesList(pclEdInstance);
//Puts in List
pclInstanceToUndelete->fn_bValidate();
//Updates DialogList
m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
//Notifies
if (!pclInstanceToUndelete->m_pub_fn_bIsCommon())
pclInstanceToUndelete->fn_vNotifyRestore();
//Sends a notification for the Level to be saved
m_fn_vNotifyLevel(pclInstanceToUndelete);
// ANNECY MT 13-02-97 {
// Removes from Coherence Manager
g_oCoherenceManager.m_fn_vDestroyObject(pclInstanceToUndelete);
// END ANNECY MT }
}
//***************************************************************************
//Called to set inital position of an actor as its actual's one
void EdActors_MyDocument::m_fn_vSetCurrentActorPositionAsInitial(CPA_Actor *_pclActor)
{
HIE_tdxHandleToSuperObject hActorSO = _pclActor->m_pub_fn_hGetMotorSuperObject();
//Sets the Initial Matrix as the Current one (in motor Actor)
memcpy( fn_p_st3dDataGetMatrixInit(M_GetMSHandle(hActorSO,3dData)),
fn_p_st3dDataGetMatrix(M_GetMSHandle(hActorSO,3dData)),
sizeof(POS_tdstCompletePosition)
);
m_fn_vNotifyLevel(_pclActor);
//If Actor is 'Ed', makes the same transformation to the Camera
if ( MC_fn_ucIsCharacterInMainCharacterList(hActorSO) == 1 )
{
//Gets camera character
HIE_tdxHandleToSuperObject hCameraSO = CAM_fn_hGetActiveCamera(CAM_e_MainViewport);
memcpy( fn_p_st3dDataGetMatrixInit(M_GetMSHandle(hCameraSO,3dData)),
fn_p_st3dDataGetMatrix(M_GetMSHandle(hCameraSO,3dData)),
sizeof(POS_tdstCompletePosition)
);
CPA_Actor *pclCamera = (CPA_Actor *)g_pclInterface->GetMainWorld()->fn_p_oFindObjectWithEngine(hCameraSO->hLinkedObject.p_Void, C_szActorInstanceTypeName);;
m_fn_vNotifyLevel(pclCamera);
EDACTORS_fn_vGiveProgressInfo("Camera initial position updated because Ed initial position changed");
}
}
/////////////////////
// Editor's aspect //
/////////////////////
//***************************************************************************
// Checks if the mode is the right one to display this actor,
// else changes it before editing new Actor (Instance or Model)
void EdActors_MyDocument::m_fn_vDisplayActor(EdActors_EditorActor *pclNewSelectedActor,
ED_ACTORS_tdeModeOfActorSelection _tdeSelectionType)
{
if ( !g_pclInterface->GetInterface()->fn_bIsLoadingWorld() )
{
AfxGetApp()->DoWaitCursor(1);
//ANNECY CB
m_bDisplayActor = TRUE;
m_pclMiniStrucView->ShowWindow(FALSE);
//END
//Checks if right Mode is on, else changes it
if ( pclNewSelectedActor != NULL )
{
//If new Actor is an Always Model, and we are not in Always mode
if ( ( pclNewSelectedActor->m_pclActor->m_fn_bIsAnAlways() ) && (!pclNewSelectedActor->m_pclActor->m_fn_bIsAGenDoor()) /*&& ( !m_pub_fn_bCurrentModeIsAlwaysModel() )*/ )
m_fn_vSetMode(ED_ACTORS_eDisplayMode_AlwaysModel, pclNewSelectedActor->m_pclActor);
//If new Actor is not an Always Model
if ( !pclNewSelectedActor->m_pclActor->m_fn_bIsAnAlways() )
{
//If current Mode was Always, forces change of Mode
if ( m_pub_fn_bCurrentModeIsAlwaysModel() )
{
if ( pclNewSelectedActor->m_fn_bIsAnInstance() )
m_fn_vSetMode(ED_ACTORS_eDisplayMode_Instance);
//else it's a Model
else
m_fn_vSetMode(ED_ACTORS_eDisplayMode_Model);
}
else
{
if ( (pclNewSelectedActor->m_fn_bIsAnInstance()) && (m_pub_fn_bCurrentModeIsModel()) )
m_fn_vSetMode(ED_ACTORS_eDisplayMode_Instance);
else if ( (!pclNewSelectedActor->m_fn_bIsAnInstance()) && (!m_pub_fn_bCurrentModeIsModel()) )
m_fn_vSetMode(ED_ACTORS_eDisplayMode_Model);
}
}
}
//Now Mode is the right one --> Displays the Actor
if ( pclNewSelectedActor != m_pclSelectedActor )
{
EdActors_EditorActor *pclOldSelectedActor = m_pclSelectedActor;
//Selects new Actor
m_pclSelectedActor = pclNewSelectedActor;
if ( m_pub_fn_bCurrentModeIsInstance() || m_pub_fn_bCurrentModeIsAlwaysModel() )
{
m_pclCurrentInstance = (EdActors_EditorActorInstance *)pclNewSelectedActor;
if(m_pclCurrentInstance)
{
m_pclCurrentModel = (EdActors_EditorActorModel *)m_pclCurrentInstance->m_fn_pclGetModel()->m_fn_pclGetEditorActor();
m_pclCurrentFamily = m_pclCurrentModel->m_pclActor->m_pub_fn_pclGetFamily();
}
}
else if ( m_pub_fn_bCurrentModeIsModel() )
{
m_pclCurrentModel = (EdActors_EditorActorModel *)pclNewSelectedActor;
if(m_pclCurrentModel)
m_pclCurrentFamily = m_pclCurrentModel->m_pclActor->m_pub_fn_pclGetFamily();
}
if ( m_pclSelectedActor != NULL )
{
//Type matches current mode ??
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Displaying an Actor",
"EdActors_MyDocument::m_fn_vDisplayActor(...)",
E_ERROR_GRAVITY_FATAL,
"Trying to display an Instance in Model mode, or reverse");
ERROR_ASSERT ( ( ( m_pclSelectedActor->m_fn_bIsAnInstance() )
&& ( m_pub_fn_bCurrentModeIsInstance() || m_pub_fn_bCurrentModeIsAlwaysModel() )
)
|| ( ( !m_pclSelectedActor->m_fn_bIsAnInstance() )
&& ( m_pub_fn_bCurrentModeIsModel() )
)
);
m_fn_vSetPointersForSelectedActor();
//Sets current list (common MS list) for editor AND Actor
char cListToSelect = m_pclSelectedActor->m_fn_ucGetCurrentMSListIndex();
if ( !m_bRestoreGroup )
if ( pclOldSelectedActor != NULL )
cListToSelect = pclOldSelectedActor->m_fn_ucGetCurrentMSListIndex();
m_fn_vSetCurrentList(cListToSelect, FALSE);
//Refreshes controls (Read Only / Read Write)
if ( m_pub_fn_bCurrentModeIsInstance() || m_pub_fn_bCurrentModeIsAlwaysModel() )
{
m_fn_vUpdateControlsForInstance();
//Selects in 3D View, if not already done
if ( _tdeSelectionType != ED_ACTORS_eModeOfActorSelection_InHierarchy )
{
g_pclInterface->GetInterface()->fn_vCancelCurrentSelection();
g_pclInterface->GetInterface()->fn_vAddSelectedObject(m_pclSelectedActor->m_pclActor->m_pub_fn_pclGetSuperObject());
}
}
else if ( m_pub_fn_bCurrentModeIsModel() )
{
m_fn_vUpdateControlsForModel();
}
}
else
{
m_fn_vSetPointersForSelectedActor();
//Default setting
m_fn_vSetCurrentList(1, FALSE);
}
if ( m_pclActorsView != NULL )
m_pclActorsView->m_fn_vDisplayActor(m_pclSelectedActor);
m_pclMiniStrucView->m_fn_vUpdateTree();
//Updates display in Dialog List
if ( ( _tdeSelectionType != ED_ACTORS_eModeOfActorSelection_InListDialog )
&& ( _tdeSelectionType != ED_ACTORS_eModeOfActorSelection_InTreeView )
)
g_pclInterface->m_pub_fn_vSetSelectionInDialogList((pclNewSelectedActor != NULL) ? pclNewSelectedActor->m_pclActor : NULL);
}
//-----------------IR-------------------------
if ( ((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_IA))->GetCheck() )
m_fn_vDisplayActorIA();
//--------------------------------------------
//ANNECY CB
m_pclMiniStrucView->ShowWindow(TRUE);
m_bDisplayActor = FALSE;
//END
AfxGetApp()->DoWaitCursor(-1);
}
}
//-----------------IR-------------------------
//***************************************************************************
void EdActors_MyDocument::m_fn_vDisplayActorIA()
{
if ( m_pub_fn_bCurrentModeIsInstance() || m_pub_fn_bCurrentModeIsAlwaysModel() )
{
if(m_pclCurrentInstance)
{
EdActors_EditorActorModel *pclModel = (EdActors_EditorActorModel *)m_pclCurrentInstance->m_fn_pclGetModel()->m_fn_pclGetEditorActor();
EDAC_fn_vShowBrain(pclModel->m_pclBrain);
if(m_pclDesignerVariablesView)
{
EdActors_EditorActorModel *pclModel = (EdActors_EditorActorModel *)m_pclCurrentInstance->m_fn_pclGetModel()->m_fn_pclGetEditorActor();
EDAC_fn_vDesignerVariableView_UpdateControls(m_pclDesignerVariablesView,&(pclModel->m_clListOfDesignerVariableControl));
EDAC_fn_vDesignerVariableView_UpdateDisplayWithValues(m_pclDesignerVariablesView,m_pclCurrentInstance->m_pclListOfDesignerVariableType);
}
}
}
else if ( m_pub_fn_bCurrentModeIsModel() )
{
if(m_pclCurrentModel)
{
EDAC_fn_vShowBrain(m_pclCurrentModel->m_pclBrain);
if(m_pclDesignerVariablesView)
{
EDAC_fn_vDesignerVariableView_UpdateControls(m_pclDesignerVariablesView,&(m_pclCurrentModel->m_clListOfDesignerVariableControl));
EDAC_fn_vDesignerVariableView_UpdateDisplayWithValues(m_pclDesignerVariablesView,m_pclCurrentModel->m_pclListOfDesignerVariableType);
}
}
}
}
//--------------------------------------------
//***************************************************************************
//Indicates the current display mode
ED_ACTORS_tdeDisplayMode EdActors_MyDocument::m_pub_fn_tdeGetCurrentDisplayMode()
{
return m_eCurrentDisplayMode;
}
//***************************************************************************
BOOL EdActors_MyDocument::m_pub_fn_bCurrentModeIsInstance()
{
return ( m_eCurrentDisplayMode == ED_ACTORS_eDisplayMode_Instance );
}
//***************************************************************************
BOOL EdActors_MyDocument::m_pub_fn_bCurrentModeIsModel()
{
return ( m_eCurrentDisplayMode == ED_ACTORS_eDisplayMode_Model );
}
//***************************************************************************
BOOL EdActors_MyDocument::m_pub_fn_bCurrentModeIsAlwaysModel()
{
return ( m_eCurrentDisplayMode == ED_ACTORS_eDisplayMode_AlwaysModel );
}
//***************************************************************************
//Called to update editor (and watch) currently edited values
void EdActors_MyDocument::m_fn_vUpdateEditedValues()
{
//Updates editor datas
//PROVISOIRE...
m_pclActorsView->m_fn_vDisplayActor(m_pclSelectedActor);
//Updates Watch Window datas
OAC_fn_vUpdateAllDataInWatchWindow();
}
//***************************************************************************
//Sets the current mode : Instances if parameter is TRUE, else Model mode
void EdActors_MyDocument::m_fn_vSetMode(ED_ACTORS_tdeDisplayMode _eNewMode,
CPA_Actor *_pclNewActor /*= NULL*/)
{
BOOL bModeChanged = (_eNewMode != m_eCurrentDisplayMode);
ED_ACTORS_tdeDisplayMode tdeOldMode = m_eCurrentDisplayMode;
m_eCurrentDisplayMode = _eNewMode;
//Sets right lists
if ( ( m_pub_fn_bCurrentModeIsInstance() ) || ( m_pub_fn_bCurrentModeIsModel() ) )
{
if ( m_pub_fn_bCurrentModeIsInstance() )
m_pclCurrentActorsList = &m_clInstancesList;
else
m_pclCurrentActorsList = &m_clModelsList;
if ( tdeOldMode == ED_ACTORS_eDisplayMode_AlwaysModel && bModeChanged)
{
//Closes Character View
CPA_DLLBase *p_clT3D_Dll = g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLTool3DName);
if ( p_clT3D_Dll )
p_clT3D_Dll->OnQueryClose(g_pclInterface, 0, 0);
}
}
else if ( m_pub_fn_bCurrentModeIsAlwaysModel() )
{
m_pclCurrentActorsList = &m_clAlwaysList;
//Launches Chraracter View
CPA_DLLBase *p_clT3D_Dll = g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLTool3DName);
if ( p_clT3D_Dll )
{
if ( _pclNewActor != NULL )
{
CPA_SuperObject *pclEdSO = _pclNewActor->m_pub_fn_pclGetSuperObject();
p_clT3D_Dll->OnQueryOpen(g_pclInterface, C_wTool3D_Char, (long)pclEdSO);
}
}
}
else
m_pclCurrentActorsList = NULL;
}
//***************************************************************************
//Called to set the current MS List
void EdActors_MyDocument::m_fn_vSetCurrentList(char cChoice,
BOOL bMustRepaint)
{
//Sets selected actor's list
if ( m_pclSelectedActor != NULL )
{
//Hides old list of MS
if ( m_pclCurrentMiniStructureList != NULL )
{
POSITION OldListPos = m_pclCurrentMiniStructureList->GetHeadPosition();
while ( OldListPos != NULL )
m_pclCurrentMiniStructureList->GetNext(OldListPos)->m_fn_vHideAllControls();
}
m_pclSelectedActor->m_fn_vSetCurrentMSListIndex(cChoice);
}
m_pclCurrentMiniStructureList = m_clListOfMSLists.m_fn_pclGetListFromIndex(cChoice);
//Shows new list of MS
if ( m_pclCurrentMiniStructureList != NULL )
{
POSITION NewListPos = m_pclCurrentMiniStructureList->GetHeadPosition();
while ( NewListPos != NULL )
m_pclCurrentMiniStructureList->GetNext(NewListPos)->m_fn_vShowAllControls();
}
if ( m_pclActorsView != NULL )
{
//Updates buttons
m_pclActorsView->m_fn_vUpdatePagesButtons(cChoice);
//Redraws all tree
if ( bMustRepaint )
m_pclMiniStrucView->m_fn_vUpdateTree();
}
}
//***************************************************************************
//Called to update controls when current actor's name has changed
void EdActors_MyDocument::m_fn_vUpdateName()
{
//Updates static name
m_pclActorsView->m_pclActorNameStatic->m_fn_vSetTextToDisplay(m_pclSelectedActor->m_fn_csGetActorName());
m_pclActorsView->m_pclActorNameStatic->InvalidateRect(NULL);
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vUpdateControlsForInstance()
{
if ( m_pclSelectedActor != NULL )
{
POSITION pos = m_clListOfMSLists.GetHeadPosition();
while (pos != NULL )
m_clListOfMSLists.GetNext(pos)->m_fn_vUpdateControlsForInstance();
//CPA2 Stegaru Cristian 98-05
ASSERT (m_pclActorsView);
//enable it
BOOL bEnabled = !m_pclSelectedActor->m_pclActor->m_fn_bIsAnAlways() /*&& !m_pclSelectedActor->m_pclActor->m_fn_bIsTheWorldActor()*/;
m_pclActorsView->GetDlgItem(IDC_CHECK_ALWAYS_ACTIVE)->EnableWindow(bEnabled);
//check it
((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_ALWAYS_ACTIVE))->SetCheck (m_pclSelectedActor->m_pclActor->m_pub_fn_bIsAlwaysActive() ? 1 : 0);
//End CPA2 Stegaru Cristian 98-05
// ANNECY MT - 19/11/98 {
bEnabled = !m_pclSelectedActor->m_pclActor->m_fn_bIsAnAlways();
m_pclActorsView->GetDlgItem(IDC_CHECK_IN_ALL_SUBMAPS)->EnableWindow(bEnabled);
//check it
((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_IN_ALL_SUBMAPS))->SetCheck (m_pclSelectedActor->m_pclActor->m_pub_fn_bIsInAllSubMaps() ? 1 : 0);
// END ANNECY MT }
}
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vUpdateControlsForModel()
{
if ( m_pclSelectedActor != NULL )
{
POSITION pos = m_clListOfMSLists.GetHeadPosition();
while (pos != NULL )
m_clListOfMSLists.GetNext(pos)->m_fn_vUpdateControlsForModel();
//CPA2 Stegaru Cristian 98-05
ASSERT (m_pclActorsView);
//enable it
m_pclActorsView->GetDlgItem(IDC_CHECK_ALWAYS_ACTIVE)->EnableWindow(FALSE);
//End CPA2 Stegaru Cristian 98-05
}
}
//***************************************************************************
//Displays the given Actor, then shows the given Data
void EdActors_MyDocument::m_fn_vShowData(EdActors_EditorActor *pclActor,
CTL_Editor_Data *pclData)
{
//Searches for the right Page of MS
EdActors_ActorMiniStructure *pclAMS = NULL;
char cMSPage = pclActor->m_fn_cDoesActorOwnData(pclData, pclAMS);
ERROR_ASSERT( cMSPage != -1 );
ERROR_ASSERT( pclAMS != NULL );
if ( (cMSPage != -1) && (pclAMS != NULL) )
{
pclActor->m_fn_vSetCurrentMSListIndex(cMSPage);
//Displays the Actor
m_fn_vDisplayActor(pclActor, ED_ACTORS_eModeOfActorSelection_Unknown);
//Highlites the Data
m_pclCurrentMiniStructureList->m_fn_vHighliteData(pclData);
}
}
//***************************************************************************
//Re-init. the MS with init. values
void EdActors_MyDocument::m_fn_vReInitMiniStructure(EdActors_ActorMiniStructure *pclActorMS)
{
if ( pclActorMS->m_fn_bIsAllocated() )
{
CTL_Editor_Data *pclData;
POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
while ( pos != NULL )
{
pclData = pclActorMS->m_pclDataList->GetNext(pos);
if ( pclData->m_fn_bHasAnInitialData() )
pclData->m_fn_vUpdateData(pclData->m_fn_pclGetAssociatedInitialData());
}
}
}
//***************************************************************************
//Re-init. all MS with init. values
void EdActors_MyDocument::m_fn_vReInitAllMiniStructures(EdActors_EditorActor *pclActor)
{
POSITION pos = pclActor->m_clListOfAMSLists.GetHeadPosition();
EdActors_ActorMiniStructureList *pclCurrentAMSList;
while ( pos != NULL )
{
pclCurrentAMSList = pclActor->m_clListOfAMSLists.GetNext(pos);
EdActors_ActorMiniStructure *pclAMS;
POSITION AMSpos = pclCurrentAMSList->GetHeadPosition();
while ( AMSpos != NULL )
{
pclAMS = pclCurrentAMSList->GetNext(AMSpos);
m_fn_vReInitMiniStructure(pclAMS);
}
}
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vHideGenDoors()
{
CPA_Actor *pclActor;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
if ( pclActor->m_fn_bIsAGenDoor() )
{
CString csMessage = "A geometric object is not correct (Actor is '" + pclActor->GetName() + "').";
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Hiding Gen Doors before Engine mode",
"EdActors_MyDocument::m_fn_vHideGenDoors(...)",
E_ERROR_GRAVITY_FATAL,
csMessage);
ERROR_ASSERT( pclActor->m_fn_pclGetIsolatedSuperObject() != NULL );
pclActor->m_fn_pclGetIsolatedSuperObject()->Isolate(TRUE);
}
}
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vShowGenDoors()
{
static s_bFirstPassForGenDoors = TRUE;
CPA_Actor *pclActor;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
if ( pclActor->m_fn_bIsAGenDoor() && !s_bFirstPassForGenDoors )
{
if ( pclActor->m_fn_pclGetIsolatedSuperObject() != NULL )
g_pclInterface->GetInterface()->fn_bInsertObjectInHierarchy(pclActor->m_fn_pclGetIsolatedSuperObject(),
pclActor->m_pub_fn_pclGetSuperObject(),
FALSE,
FALSE,
FALSE);
}
}
s_bFirstPassForGenDoors = FALSE;
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vLoadObjectTables()
{
AfxGetApp()->DoWaitCursor(1);
EDACTORS_fn_vGiveProgressInfo("Actors Editor is looking for unloaded Object Tables...");
CPA_Actor *pclActor;
HIE_tdxHandleToSuperObject hMotorSO;
EditorObjectTable *pclCurrentOT;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
hMotorSO = pclActor->m_pub_fn_hGetMotorSuperObject();
pclCurrentOT = pclActor->m_pub_fn_pclGetCurrentObjectTable();
if ( pclCurrentOT != NULL )
{
if ( !pclCurrentOT->fn_bIsAvailable() )
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Loading all used Object Tables before Motor mode",
"EdActors_MyDocument::m_fn_vLoadObjectTables(...)",
E_ERROR_GRAVITY_FATAL,
"An Object Table could not be loaded");
ERROR_VERIFY( pclCurrentOT->GetEditor()->fn_bLoadBaseObject(pclCurrentOT) );
pclActor->m_pub_fn_vUpdateObjectTablesList(pclCurrentOT);
fn_v3dDataSetCurrentObjectsTable(M_GetMSHandle(hMotorSO,3dData), (tdxHandleToObjectsTablesList)pclCurrentOT->GetData());
}
}
}
EDACTORS_fn_vGiveProgressInfo("");
AfxGetApp()->DoWaitCursor(-1);
}
//***************************************************************************
//To Display or Hide the IA Editor
void EdActors_MyDocument::m_fn_vActivateIAEditor(BOOL bActivate /*= TRUE*/)
{
BOOL bIsActive=((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_IA))->GetCheck();
if(bActivate)
{
if((bIsActive!=1) ||
(g_pclInterface->fn_bIsCurrentEditor()==FALSE))
{
((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_IA))->SetCheck(bActivate);
m_pclActorsView->OnCheckModels();
}
}
else
{
if(bIsActive!=0)
{
((CButton *)m_pclActorsView->GetDlgItem(IDC_CHECK_IA))->SetCheck(bActivate);
m_pclActorsView->OnCheckModels();
}
}
}
//***************************************************************************
void EdActors_MyDocument::m_fn_vNotifyLevel(CPA_Actor *pclCauseActor,
BOOL bAddSection /*= TRUE*/,
CString csActorsName /*= ""*/)
{
char a_256cBuffer[256];
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Notifying a level ('.lvl' or '.alw') to be saved",
"EdActors_MyDocument::m_fn_vNotifyLevel(...)",
E_ERROR_GRAVITY_FATAL,
"The Actor which caused this notification is not correct (pointer is NULL)");
ERROR_ASSERT( pclCauseActor != NULL );
CString csLevelFileName;
if ( pclCauseActor->m_fn_bIsAnAlways() )
//Notifies "ALW"
csLevelFileName = fn_zsGetActualLevelFilename(a_256cBuffer, C_ScriptAlwaysSuffixe);
else
//Notifies "LVL"
csLevelFileName = fn_zsGetActualLevelFilename(a_256cBuffer, C_ScriptLevelSuffixe);
CString csActionName = ( pclCauseActor->m_fn_bIsAnAlways() ) ? C_SectionLevelAlways : C_SectionLevelCharacters;
CString csSectionName;
if ( csActorsName.IsEmpty() )
csSectionName = csLevelFileName + '^' + csActionName + ':' + pclCauseActor->GetName();
else
csSectionName = csLevelFileName + '^' + csActionName + ':' + csActorsName;
SCR_tde_Ntfy_Action tdeNotificationType = bAddSection ? SCR_EA_Ntfy_AddOrRebuildSection : SCR_EA_Ntfy_DeleteIfExists;
SCR_fn_v_SvL1_RegisterNotify( (char *)LPCTSTR(csSectionName),
CPA_Actor::s_m_fn_vCallBackSaveActor,
NULL,
tdeNotificationType);
//Notifies Actor (pb with the Initial State)
if ( bAddSection && ((!pclCauseActor->m_fn_bIsAnAlways() && !pclCauseActor->m_pub_fn_bIsCommon()) || !pclCauseActor->fn_bSectionExists()))
pclCauseActor->fn_vNotifySave();
}
//**********************************************************************************************
void EdActors_MyDocument::m_fn_vNotifyFixFile()
{
CString csGameDataPath(fn_szGetGameDataPath());
CString csFixFileName = csGameDataPath + "\\Game.fix";
CString csSectionName = csFixFileName + "^PreloadSectionInFix:Characters" ;
SCR_fn_v_SvL1_RegisterNotify( (char *)LPCTSTR(csSectionName),
EdActors_MyDocument::s_m_fn_vCallBackSaveFixFile,
NULL,
SCR_EA_Ntfy_AddOrRebuildSection);
}
//**********************************************************************************************
//Data Paths
void EdActors_MyDocument::m_fn_vComputeDataPaths()
{
//Gets Level Name
CString csLevelName = m_fn_csGetLevelName();
m_pub_csCommonDataPath = CString(fn_szGetCharactersDataPath());
m_pub_csLevelDataPath = m_pub_csCommonDataPath;
}
//**********************************************************************************************
//Data Paths
CString EdActors_MyDocument::m_fn_csGetLevelName()
{
//PROVISOIRE... will call a motor function
char a_256cBuffer[256];
CString csLevelExtension(C_ScriptAlwaysSuffixe);
CString csLevelFileName = fn_zsGetActualLevelFilename(a_256cBuffer, C_ScriptAlwaysSuffixe);
short wIndex = csLevelFileName.ReverseFind('\\');
if ( wIndex != -1 )
csLevelFileName = csLevelFileName.Right(csLevelFileName.GetLength() - wIndex - 1);
CString csLevelName = csLevelFileName.Left(csLevelFileName.GetLength() - csLevelExtension.GetLength() - 1);
return csLevelName;
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vCheckAllInstancesForActionChange(CPA_Action *_pclChangedAction)
{
CPA_Family *pclFamilyWhichOwnsChangedAction = (CPA_Family *)_pclChangedAction->GetOwner();
ERROR_ASSERT( pclFamilyWhichOwnsChangedAction != NULL );
CPA_Actor *pclCurrentActor;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclCurrentActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
if ( pclCurrentActor->m_pub_fn_pclGetFamily() == pclFamilyWhichOwnsChangedAction )
{
if ( pclCurrentActor->m_pub_fn_pclGetCurrentAction() == _pclChangedAction )
pclCurrentActor->m_pub_fn_vSetCurrentState(_pclChangedAction->mfn_p_oGetDefaultState());
if ( pclCurrentActor->m_pub_fn_pclGetInitialAction() == _pclChangedAction )
pclCurrentActor->m_pub_fn_vSetInitialState(_pclChangedAction->mfn_p_oGetDefaultState(), TRUE);
}
}
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vCheckAllActorsForObjectTableChange(EditorObjectTable *_pclAddedOT)
{
//Gets the owner Family
CPA_Family *_pclParentFamily = (CPA_Family *)_pclAddedOT->GetOwner();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Re_building the Enum Descriptor of Actors for the Object Tables, because an OT has been loaded",
"EdActors_MyDocument::m_pub_fn_vCheckAllActorsForObjectTableChange()",
E_ERROR_GRAVITY_INSTABLE,
"Can't find the Family for the loaded Object Table");
ERROR_ASSERT( _pclParentFamily != NULL );
//Modifies the enum desc. in all concerned Actors
//Instances
CPA_Actor *pclCurrentActor;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclCurrentActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
if ( pclCurrentActor->m_pub_fn_pclGetFamily() == _pclParentFamily )
pclCurrentActor->m_pub_fn_vConstructEnumDescriptorForObjectsTables();
}
//Models
pos = m_clModelsList.GetHeadPosition();
while ( pos != 0 )
{
pclCurrentActor = (CPA_Actor *)m_clModelsList.GetNext(pos);
if ( pclCurrentActor->m_pub_fn_pclGetFamily() == _pclParentFamily )
pclCurrentActor->m_pub_fn_vConstructEnumDescriptorForObjectsTables();
}
//Always Models
pos = m_clAlwaysList.GetHeadPosition();
while ( pos != 0 )
{
pclCurrentActor = (CPA_Actor *)m_clAlwaysList.GetNext(pos);
if ( pclCurrentActor->m_pub_fn_pclGetFamily() == _pclParentFamily )
pclCurrentActor->m_pub_fn_vConstructEnumDescriptorForObjectsTables();
}
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vUpdateActorsEnumDescriptor()
{
CTL_Editor_EnumDescriptor *pclEnumDescriptor = m_clListOfEnumDescriptors.m_fn_pclGetEnumDescriptorByName(g_c_csActorsEnumDescriptorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptor to represent the List of Actors",
"EdActors_MyDocument::m_pub_fn_vUpdateActorsEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Enum Descriptor in the Document");
ERROR_ASSERT( pclEnumDescriptor != NULL );
//Empties Enum descriptor
pclEnumDescriptor->m_fn_vEmptyList();
//Fills it
CPA_Actor *pclCurrentActor;
Position pos = m_clInstancesList.GetHeadPosition();
while ( pos != 0 )
{
pclCurrentActor = (CPA_Actor *)m_clInstancesList.GetNext(pos);
pclEnumDescriptor->m_fn_pclAddElement(pclCurrentActor->GetName(), (long)(pclCurrentActor->m_pub_fn_hGetMotorSuperObject()));
}
//Always adds a NULL target
pclEnumDescriptor->m_fn_pclAddElement("No Target!", 0L);
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vUpdatePartGenEnumDescriptor()
{
CTL_Editor_EnumDescriptor *pclEnumDescriptor = m_clListOfEnumDescriptors.m_fn_pclGetEnumDescriptorByName(g_c_csPartGenEnumDescriptorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptor to represent the List of Particle Generators",
"EdActors_MyDocument::m_pub_fn_vUpdatePartGenEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Enum Descriptor in the Document");
ERROR_ASSERT( pclEnumDescriptor != NULL );
//Empties Enum descriptor
pclEnumDescriptor->m_fn_vEmptyList();
//Gets list
CPA_BaseObjectList *pclList = g_pclInterface->GetMainWorld()->fn_p_oGetOriginalObjectList(C_szPartGenGeneratorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptor to represent the List of Particle Generators",
"EdActors_MyDocument::m_pub_fn_vUpdatePartGenEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the list of Editor Particle Generators");
ERROR_ASSERT( pclList != NULL );
if ( pclList != NULL )
{
//Fills it
CPA_BaseObject *pclCurrentPG;
Position pos = pclList->GetHeadPosition();
while ( pos != 0 )
{
pclCurrentPG = pclList->GetNext(pos);
pclEnumDescriptor->m_fn_pclAddElement(pclCurrentPG->GetName(), (long)(pclCurrentPG->GetData()));
}
}
//Always adds a NULL target
pclEnumDescriptor->m_fn_pclAddElement("No Part. Gen. !", 0L);
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vUpdateGameMaterialsEnumDescriptor()
{
//Gets the Enum descriptor
CTL_Editor_EnumDescriptor *pclGMatEnumDescriptor = m_clListOfEnumDescriptors.m_fn_pclGetEnumDescriptorByName(g_c_csGameMaterialEnumDescriptorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Game Materials",
"EdActors_MyDocument::m_pub_fn_vUpdateGameMaterialsEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Enum Descriptors in the Document");
ERROR_ASSERT( pclGMatEnumDescriptor != NULL );
//Empties Enum descriptor
pclGMatEnumDescriptor->m_fn_vEmptyList();
//Fills them (according to SO LinkTable)
//Gets SO LinkTable
SCR_tdst_Link_Table *p_tdstLinkTable = GMT_fn_p_stGetLinkTable();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Game Materials",
"EdActors_MyDocument::m_pub_fn_vUpdateGameMaterialsEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Game Materials Link Table");
ERROR_ASSERT( p_tdstLinkTable != NULL );
unsigned int uiPos = 0;
SCR_tdst_Link_Value *p_stValue;
/* Get first element of array */
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
while( p_stValue != NULL ) /* p_sValue is NULL at the end of the array */
{
/* Test current retrieved value */
if( SCR_M_e_Link_GetState(p_stValue) == SCR_ELS_Link_Initialized )
{
GMT_tdxHandleToGameMaterial tdxGameMat = (GMT_tdxHandleToGameMaterial)SCR_M_ul_Link_GetValue(p_stValue);
//Gets the Name for the Card
CString csObjectName(SCR_M_p_sz_Link_GetKey(p_stValue));
char a_256cFileName[256];
char a_256cActionName[256];
char a_256cName[256];
SCR_fn_v_RdL0_SplitSectionName((char *)LPCTSTR(csObjectName), a_256cFileName, a_256cActionName, a_256cName);
csObjectName = a_256cName;
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Game Materials",
"EdActors_MyDocument::m_pub_fn_vUpdateGameMaterialsEnumDescriptor()",
E_ERROR_GRAVITY_WARNING,
"Name of Game Material is empty");
ERROR_ASSERT( !csObjectName.IsEmpty() );
//Adds to the enum desc.
pclGMatEnumDescriptor->m_fn_pclAddElement(csObjectName, (long)tdxGameMat);
}
/* Get next element */
uiPos++;
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
}
//Always adds a NULL pointer
pclGMatEnumDescriptor->m_fn_pclAddElement("No Material!", 0L);
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vUpdateSectorsEnumDescriptor()
{
//Gets the Enum descriptor
CTL_Editor_EnumDescriptor *pclSectorsEnumDescriptor = m_clListOfEnumDescriptors.m_fn_pclGetEnumDescriptorByName(g_c_csSectorsEnumDescriptorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors to represent the Sectors",
"EdActors_MyDocument::m_pub_fn_vUpdateSectorsEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Enum Descriptors in the Document");
ERROR_ASSERT( pclSectorsEnumDescriptor != NULL );
//Empties Enum descriptor
pclSectorsEnumDescriptor->m_fn_vEmptyList();
//Fills them (according to SO LinkTable)
//Gets SO LinkTable
SCR_tdst_Link_Table *p_tdstLinkTable = HIE_fn_p_stGetSuperObjectLinkTable();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors to represent the Sectors",
"EdActors_MyDocument::m_pub_fn_vUpdateSectorsEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Super Objects Link Table");
ERROR_ASSERT( p_tdstLinkTable != NULL );
unsigned int uiPos = 0;
SCR_tdst_Link_Value *p_stValue;
/* Get first element of array */
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
while( p_stValue != NULL ) /* p_sValue is NULL at the end of the array */
{
/* Test current retrieved value */
if( SCR_M_e_Link_GetState(p_stValue) == SCR_ELS_Link_Initialized )
{
HIE_tdxHandleToSuperObject hSO = (HIE_tdxHandleToSuperObject)SCR_M_ul_Link_GetValue(p_stValue);
if ( HIE_fn_ulGetSuperObjectType(hSO) == HIE_C_ulSector )
{
//Gets the Name for the Card
CString csObjectName(SCR_M_p_sz_Link_GetKey(p_stValue));
char a_256cFileName[256];
char a_256cActionName[256];
char a_256cName[256];
SCR_fn_v_RdL0_SplitSectionName((char *)LPCTSTR(csObjectName), a_256cFileName, a_256cActionName, a_256cName);
csObjectName = a_256cName;
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors to represent the Sectors",
"EdActors_MyDocument::m_pub_fn_vUpdateSectorsEnumDescriptor()",
E_ERROR_GRAVITY_WARNING,
"Name of SuperObject is empty");
ERROR_ASSERT( !csObjectName.IsEmpty() );
//Adds to the enum desc.
pclSectorsEnumDescriptor->m_fn_pclAddElement(csObjectName, (long)hSO);
}
}
/* Get next element */
uiPos++;
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
}
//Always adds a NULL pointer
pclSectorsEnumDescriptor->m_fn_pclAddElement("No Sector!", 0L);
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vUpdateGraphEnumDescriptor()
{
//Gets the Enum descriptor
CTL_Editor_EnumDescriptor *pclGraphEnumDescriptor = m_clListOfEnumDescriptors.m_fn_pclGetEnumDescriptorByName(g_c_csGraphEnumDescriptorName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Graph",
"EdActors_MyDocument::m_pub_fn_vUpdateGraphEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Enum Descriptors in the Document");
ERROR_ASSERT( pclGraphEnumDescriptor != NULL );
//Empties Enum descriptor
// pclGraphEnumDescriptor->m_fn_vEmptyList();
//Fills them (according to SO LinkTable)
//Gets SO LinkTable
SCR_tdst_Link_Table *p_tdstLinkTable = WPG_fnp_Graph_GetLinkTable();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Graph",
"EdActors_MyDocument::m_pub_fn_vUpdateGraphEnumDescriptor()",
E_ERROR_GRAVITY_FATAL,
"Can't find the Graphs Link Table");
ERROR_ASSERT( p_tdstLinkTable != NULL );
unsigned int uiPos = 0;
SCR_tdst_Link_Value *p_stValue;
/* Get first element of array */
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
//Always adds a NULL pointer
pclGraphEnumDescriptor->m_fn_pclAddElement("Reseau Dynamique", -1L);
while( p_stValue != NULL ) /* p_sValue is NULL at the end of the array */
{
/* Test current retrieved value */
if( SCR_M_e_Link_GetState(p_stValue) == SCR_ELS_Link_Initialized )
{
WP_tdHandleOfGraph hGraph = (WP_tdHandleOfGraph)SCR_M_ul_Link_GetValue(p_stValue);
//Gets the Name for the Card
CString csObjectName(SCR_M_p_sz_Link_GetKey(p_stValue));
char a_256cFileName[256];
char a_256cActionName[256];
char a_256cName[256];
SCR_fn_v_RdL0_SplitSectionName((char *)LPCTSTR(csObjectName), a_256cFileName, a_256cActionName, a_256cName);
csObjectName = a_256cName;
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Building the Enum Descriptors for the Graphs",
"EdActors_MyDocument::m_pub_fn_vUpdateGraphEnumDescriptor()",
E_ERROR_GRAVITY_WARNING,
"Name of Graph is empty");
ERROR_ASSERT( !csObjectName.IsEmpty() );
//Adds to the enum desc.
pclGraphEnumDescriptor->m_fn_pclAddElement(csObjectName, (long)hGraph);
}
/* Get next element */
uiPos++;
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_tdstLinkTable)
)
}
//Always adds a NULL pointer
pclGraphEnumDescriptor->m_fn_pclAddElement("Pas de Reseau", 0L);
}
//**********************************************************************************************
void EdActors_MyDocument::m_pub_fn_vConstructListOfAlways()
{
//Using motor Actors Link Table
//Uses LinkTables
SCR_tdst_Link_Table *p_stLinkTable = &(g_st3DOSLinkTable.stCharacter);
unsigned int uiPos = 0;
SCR_tdst_Link_Value *p_stValue;
/* Get first element of array */
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_stLinkTable)
)
while( p_stValue != NULL ) /* p_sValue is NULL at the end of the array */
{
/* Test current retrieved value */
if( SCR_M_e_Link_GetState(p_stValue) == SCR_ELS_Link_Initialized )
{
EdActors_tdhHandleToActor hAlwaysActor = (EdActors_tdhHandleToActor)SCR_M_ul_Link_GetValue(p_stValue);
if ( fn_ucIsAnAlwaysModel(hAlwaysActor) != 0 )
{
//Gets the Name for the Card
CString csAlwaysName(SCR_M_p_sz_Link_GetKey(p_stValue));
char a_256cFileName[256];
char a_256cActionName[256];
char a_256cName[256];
SCR_fn_v_RdL0_SplitSectionName((char *)LPCTSTR(csAlwaysName), a_256cFileName, a_256cActionName, a_256cName);
csAlwaysName = a_256cName;
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Creating an Editor Always from Motor actor",
"EdActors_MyDocument::m_pub_fn_vConstructListOfAlways()",
E_ERROR_GRAVITY_FATAL,
"No motor name for the Always");
ERROR_ASSERT( !csAlwaysName.IsEmpty() );
//Gets Family
CString csFamilyName = fn_szFindFamilyTypeNameOfFamilyType(fn_otStandardGameGetFamilyType(hAlwaysActor->h_StandardGame));
CPA_Family *pclBaseFamily = (CPA_Family *)g_pclInterface->GetMainWorld()->fn_p_oFindObject(csFamilyName, C_szFamilyTypeName);
//Gets Model
CString csModelName = fn_szFindModelTypeNameOfModelType(fn_otStandardGameGetModelType(hAlwaysActor->h_StandardGame));
csModelName = csFamilyName + "\\" + csModelName + "\\" + csModelName;
CPA_Actor *pclBaseModel = m_fn_pclLoadModel(csModelName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Creating an Editor Always from Motor actor",
"EdActors_MyDocument::m_pub_fn_vConstructListOfAlways()",
E_ERROR_GRAVITY_FATAL,
"Family is unknown");
ERROR_ASSERT( pclBaseFamily != NULL );
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Creating an Editor Always from Motor actor",
"EdActors_MyDocument::m_pub_fn_vConstructListOfAlways()",
E_ERROR_GRAVITY_FATAL,
"Model is not correct");
ERROR_ASSERT( pclBaseModel != NULL );
//Creates Editor Super Object
CPA_SuperObject *pclNewAlwaysSO = g_pclInterface->GetInterface()->GetNewSuperObject(E_ss_NoSave, C_Protected, "", "");
pclNewAlwaysSO->SetTypeSO(C_Dynamic);
//Creates an Editor Actor
CPA_Actor *pclNewAlwaysActor = new CPA_Actor( hAlwaysActor,
NULL,
g_c_csActorType,
pclBaseModel,
pclBaseFamily,
pclNewAlwaysSO,
csAlwaysName);
//Sets Object
pclNewAlwaysSO->SetObject(pclNewAlwaysActor);
pclNewAlwaysActor->m_pub_fn_vSetSuperObject(pclNewAlwaysSO);
// make always
pclNewAlwaysActor->m_fn_vMakeAlways(TRUE);
//Is in common directory ?
CString csAlwaysCompleteName(SCR_M_p_sz_Link_GetKey(p_stValue));
pclNewAlwaysActor->m_pub_fn_vSetCommon(EDACTORS_fn_bIsFileInCommon(csAlwaysCompleteName), TRUE);
//pclNewAlwaysActor->m_pub_fn_vSetAlwaysActive(fn_bGetIfCharacterIsInAlwaysActiveCharacterList(pEngineInstance), TRUE);
pclNewAlwaysActor->m_pub_fn_vSetInFix(fn_bStdGameIsLoadedInFix(hAlwaysActor->h_StandardGame), TRUE);
//Add graphical childs
//Calls motor functions
HIE_tdxHandleToSuperObject hMotorSO = (HIE_tdxHandleToSuperObject)pclNewAlwaysSO->GetData();
fn_vAddChildToSuperObject(hMotorSO, //Motor SuperObject
M_MAKECHAR(pclNewAlwaysActor->m_pub_fn_pclGetFamily()->GetName()),//Family Name
M_MAKECHAR(pclNewAlwaysActor->m_fn_pclGetModel()->GetName()), //Model Name
M_MAKECHAR(pclNewAlwaysActor->GetName())); //Perso. Name
//Builds editor objects
pclNewAlwaysActor->m_pub_fn_vAddChildsFromEngineChilds();
}
}
/* Get next element */
uiPos++;
SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value,
uiPos,
p_stValue,
SCR_M_st_Link_GetDynamicArray(p_stLinkTable)
)
}
}
///////////////////////
// Private functions //
///////////////////////
//**********************************************************************************************
void EdActors_MyDocument::m_fn_vSetPointersForSelectedActor()
{
m_fn_vSetPointersForActor(m_pclSelectedActor);
}
//**********************************************************************************************
void EdActors_MyDocument::m_fn_vSetPointersForActor(EdActors_EditorActor *pclActor)
{
//Sets pointers for all lists
if ( pclActor != NULL )
{
POSITION AMSpos = pclActor->m_clListOfAMSLists.GetHeadPosition();
POSITION MSPos = m_clListOfMSLists.GetHeadPosition();
while ( MSPos != NULL )
m_fn_vSetPointers(m_clListOfMSLists.GetNext(MSPos),
pclActor->m_clListOfAMSLists.GetNext(AMSpos));
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,"Setting pointers on motor data for the newly selected actor",
"EdActors_MyDocument::m_fn_vSetPointersForActor(...)",
E_ERROR_GRAVITY_FATAL,
"There are more ActorMS than controls");
ERROR_ASSERT( AMSpos == NULL );
}
else
{
POSITION MSPos = m_clListOfMSLists.GetHeadPosition();
while ( MSPos != NULL )
m_fn_vSetPointers(m_clListOfMSLists.GetNext(MSPos), NULL);
}
}
//**********************************************************************************************
//Sets the pointer on a Data (the one of the Actor) in each control of each allocated MS
void EdActors_MyDocument::m_fn_vSetPointers(EdActors_MiniStructureList *pclMSList,
EdActors_ActorMiniStructureList *pclActorMSList)
{
if ( pclActorMSList != NULL )
{
//Verifies if the number of MS for the editor and the actor are equal
long lNumberOfEditorMS = pclMSList->GetCount();
long lNumberOfActorMS = pclActorMSList->GetCount();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Setting pointers on motor data for the newly selected actor",
"EdActors_MyDocument::m_fn_vSetPointers(...)",
E_ERROR_GRAVITY_FATAL,
"Number of MS in Actor and in Editor are not the same");
ERROR_ASSERT( lNumberOfEditorMS == lNumberOfActorMS );
//Updates datas pointers in the MS controls
EdActors_MiniStructure *pclMiniStructure;
EdActors_ActorMiniStructure *pclActorMS;
POSITION EditorMSPos = pclMSList->GetHeadPosition();
POSITION ActorMSPos = pclActorMSList->GetHeadPosition();
while ( EditorMSPos != NULL )
{
pclMiniStructure = pclMSList->GetNext(EditorMSPos);
pclActorMS = pclActorMSList->GetNext(ActorMSPos);
//------------------------- Sets mini-structure's pointers --------------------------
pclMiniStructure->m_pclActorMS = pclActorMS;
pclActorMS->m_pclParentMS = pclMiniStructure;
if ( pclActorMS->m_fn_bIsAllocated() )
{
pclMiniStructure->m_clControlList.m_pub_fn_vUpdateControlsWithListOfData(pclActorMS->m_pclDataList);
pclMiniStructure->m_fn_vHasBeenAllocated();
}
}
}
else
{
EdActors_MiniStructure *pclMiniStructure;
POSITION MSEditorPos = pclMSList->GetHeadPosition();
while ( MSEditorPos != NULL )
{
pclMiniStructure = pclMSList->GetNext(MSEditorPos);
//------------------------- Sets mini-structure's pointers --------------------------
pclMiniStructure->m_pclActorMS = NULL;
}
}
}
//***************************************************************************
//Loads the list of models
void EdActors_MyDocument::m_fn_vLoadUnloadedModels()
{
// EdActors_Dialog_LoadModels LMDial(&g_oBaseFrame);
// LMDial.DoModal();
if ( !m_pub_bUnloadedModelsArePrepared )
{
//Loads the unloaded models from Families directories ...
m_fn_vScanDirectoryForUnloadedModels(fn_szGetFamiliesDataPath(),0);
m_pub_bUnloadedModelsArePrepared = TRUE;
}
}
//***************************************************************************
// Copyright Xavier Billault !!
void EdActors_MyDocument::m_fn_vScanDirectoryForUnloadedModels(CString csDirectory, int Level)
{
HANDLE h;
WIN32_FIND_DATA hData;
CString csName;
CString csModelName;
CString csFamilyName;
short wIndex;
h = FindFirstFile(csDirectory + "\\*", &hData);
if( h != INVALID_HANDLE_VALUE )
{
do
{
if( ( CString(hData.cFileName) != "." )
&& ( CString(hData.cFileName) != ".." )
)
{
if( hData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
if(Level<=1)
m_fn_vScanDirectoryForUnloadedModels(csDirectory + "\\" + hData.cFileName, Level+1);
else
continue;
}
else if(Level == 2)
{
CFile cfSrcFile;
CString csSrcFile = csDirectory + "\\" + hData.cFileName;
//Looks if extension is a Model's one
if ( g_csModelExtension.CompareNoCase(csSrcFile.Right(g_csModelExtension.GetLength())) == 0 )
{
//Extracts Model' Name
wIndex = csSrcFile.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csSrcFile.Left(wIndex);
wIndex = csName.ReverseFind('\\');
csModelName = csName.Right(csName.GetLength() - wIndex - 1);
}
else
csModelName = "< Unknown >";
//Extracts Model' Family Name
wIndex = csSrcFile.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csSrcFile.Left(wIndex);
wIndex = csName.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csName.Left(wIndex);
wIndex = csName.ReverseFind('\\');
csFamilyName = csName.Right(csName.GetLength() - wIndex - 1);
}
else
csFamilyName = "< Unknown >";
}
else
csFamilyName = "< Unknown >";
//Looks if this Model is loaded
BOOL bModelFound = FALSE;
CPA_Actor *pclActor;
Position ModelPos = g_pclInterface->m_clDocument.m_clModelsList.GetHeadPosition();
while ( (ModelPos != 0) && (!bModelFound) )
{
pclActor = (CPA_Actor *)g_pclInterface->m_clDocument.m_clModelsList.GetNext(ModelPos);
//Compares Models names AND Families names
if ( pclActor->m_pub_fn_pclGetFamily() != NULL )
bModelFound = (( pclActor->GetName().CompareNoCase(csModelName) == 0 )&&( pclActor->m_pub_fn_pclGetFamily()->GetName().CompareNoCase(csFamilyName) == 0 ));
else
bModelFound = (( pclActor->GetName().CompareNoCase(csModelName) == 0 )&&(pclActor == m_pLoadedModel));
}
if ( !bModelFound )
{
//Displays a message (in status bar)
CString csMessage = "Actors Editor prepares the Model '" + csModelName + "' for load";
EDACTORS_fn_vGiveProgressInfo(csMessage, -1);
BOOL bIsLoadingWorld = g_pclInterface->GetInterface()->fn_bIsLoadingWorld();
g_pclInterface->GetInterface()->SetLoadingWorld(TRUE);
//Gets the Editor Family
CPA_Family *pclBaseFamily = (CPA_Family *)g_pclInterface->GetMainWorld()->fn_p_oFindObject(csFamilyName, C_szFamilyTypeName);
//Constructs the new CPA_Actor
CPA_Actor *pclNewModel = new CPA_Actor( NULL,
NULL,
g_c_csActorModelType,
NULL,
pclBaseFamily, //Family
NULL,
csModelName,
FALSE
);
pclNewModel->SetExistingSection(TRUE);
pclNewModel->fn_vSetExistingSectionSubObject(TRUE);
pclNewModel->SetAvailable(FALSE);
pclNewModel->m_fn_vSetFamilyName(csFamilyName);
m_clModelsList.fn_bAddObject(pclNewModel);
g_pclInterface->GetInterface()->SetLoadingWorld(bIsLoadingWorld);
}
break;
}
}
}
} while ( FindNextFile(h,&hData) );
FindClose(h);
}
}
//***************************************************************************
// Copyright Xavier Billault !!
BOOL EdActors_MyDocument::m_fn_bScanDirectoryForUnloadedModels(CString csDirectory, int Level)
{
HANDLE h;
WIN32_FIND_DATA hData;
CString csName;
CString csModelName;
CString csFamilyName;
short wIndex;
BOOL bUnloadedModel = FALSE;
h = FindFirstFile(csDirectory + "\\*", &hData);
if( h != INVALID_HANDLE_VALUE )
{
do
{
if( ( CString(hData.cFileName) != "." )
&& ( CString(hData.cFileName) != ".." )
)
{
if( hData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
if(Level<=1)
{
if (m_fn_bScanDirectoryForUnloadedModels(csDirectory + "\\" + hData.cFileName, Level+1))
return TRUE;
}
else
continue;
}
else if(Level == 2)
{
CFile cfSrcFile;
CString csSrcFile = csDirectory + "\\" + hData.cFileName;
//Looks if extension is a Model's one
if ( g_csModelExtension.CompareNoCase(csSrcFile.Right(g_csModelExtension.GetLength())) == 0 )
{
//Extracts Model' Name
wIndex = csSrcFile.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csSrcFile.Left(wIndex);
wIndex = csName.ReverseFind('\\');
csModelName = csName.Right(csName.GetLength() - wIndex - 1);
}
else
csModelName = "< Unknown >";
//Extracts Model' Family Name
wIndex = csSrcFile.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csSrcFile.Left(wIndex);
wIndex = csName.ReverseFind('\\');
if ( wIndex != -1 )
{
csName = csName.Left(wIndex);
wIndex = csName.ReverseFind('\\');
csFamilyName = csName.Right(csName.GetLength() - wIndex - 1);
}
else
csFamilyName = "< Unknown >";
}
else
csFamilyName = "< Unknown >";
//Looks if this Model is loaded
BOOL bModelFound = FALSE;
CPA_Actor *pclActor;
Position ModelPos = g_pclInterface->m_clDocument.m_clModelsList.GetHeadPosition();
while ( (ModelPos != 0) && (!bModelFound) )
{
pclActor = (CPA_Actor *)g_pclInterface->m_clDocument.m_clModelsList.GetNext(ModelPos);
//Compares Models names AND Families names
if ( pclActor->m_pub_fn_pclGetFamily() != NULL )
bModelFound = ( ( pclActor->GetName().CompareNoCase(csModelName) == 0 )
&& ( pclActor->m_pub_fn_pclGetFamily()->GetName().CompareNoCase(csFamilyName) == 0 )
);
}
if (!bModelFound)
return TRUE;
break;
}
}
}
} while ( FindNextFile(h,&hData) );
FindClose(h);
}
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : m_fnUpdateWithExternData
// Date : 98-04
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::m_fnUpdateWithExternData ()
{
if (NULL != m_pclSelectedActor && NULL != m_pclActorsView)
m_pclActorsView->m_fn_vDisplayActor(m_pclSelectedActor);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : m_fn_ConstructListOfUnloadedAlways
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::m_fn_ConstructListOfUnloadedAlways ()
{
char *szLevelsRelativePath = fn_szGetLevelsDataPath ();
//find the base root
char szBaseRoot [_MAX_PATH];
GetModuleFileName (NULL, szBaseRoot, _MAX_PATH);
CString csBaseRoot (szBaseRoot);
int iInx = csBaseRoot.ReverseFind ('\\');
ASSERT (-1 != iInx);
csBaseRoot = csBaseRoot.Left (iInx + 1);
//
CString csRootLevels = csBaseRoot + szLevelsRelativePath + "\\";
int iRelativePathInx = csRootLevels.GetLength ();
CString csRootAlwaysCharacters = csRootLevels + "_common\\families";
char *szActualLevelName = fn_p_szGetLevelName ();
CString csActualLevelName = csRootLevels + szActualLevelName + "\\";
CString csAlwFileName = csActualLevelName + szActualLevelName + ".alw";
CStringList lstOfActualLevelAlwaysNames;
mfn_vGetAlwaysNamesFromAlwFile (csAlwFileName, lstOfActualLevelAlwaysNames);
mfn_vFillAlwaysObjectsFromDirectory (csRootAlwaysCharacters, iRelativePathInx, lstOfActualLevelAlwaysNames);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : CPA_UnloadedAlways
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
CPA_UnloadedAlways::CPA_UnloadedAlways (CPA_EditorBase * pEditor, const CString csType, CString csName/* = ""*/) : CPA_BaseObject (pEditor, csType)
{
m_bOnceDblClk = FALSE;
m_bLoaded = FALSE;
while (E_mc_TypeUnicity == fn_eRename (csName))
csName += "1";
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vGetAlwaysNamesFromAlwFile
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vGetAlwaysNamesFromAlwFile (CString csFileName, CStringList &rlstOfAlwaysName)
{
CStdioFile file;
if (!file.Open (csFileName, CFile::modeRead | CFile::typeText))
return;
CString csFileEntry;
while (file.ReadString (csFileEntry))
{
csFileEntry.TrimLeft ();
if (csFileEntry.IsEmpty ())
continue;
if ('{' == csFileEntry [0]) //section's begin
{
CString csRealEntry = csFileEntry.Mid (1);//exclude the '{'
csRealEntry.TrimLeft ();
int iInx = csRealEntry.Find (':');
ASSERT (-1 != iInx); //assume the keyword is on the same line with the '{' character
CString csKeyword = csRealEntry.Left (iInx);
if ("InsertAlways" == csKeyword) //right entry in the section -> read the section
{
CString csAlwaysName = csRealEntry.Mid (iInx + 1);
csAlwaysName.TrimRight ();
//read a section
BOOL bSectionRed = FALSE;
while (file.ReadString (csFileEntry))
{
csFileEntry.TrimLeft ();
if ('}' == csFileEntry [0]) //section's end
{
bSectionRed = TRUE;
break;
}
}
if (!bSectionRed)
{
TRACE0 ("Invalid section in the alw file\n");
file.Close ();
return;
}
rlstOfAlwaysName.AddTail (csAlwaysName);
}
}
}
file.Close ();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vFillAlwaysObjectsFromDirectory
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vFillAlwaysObjectsFromDirectory (CString csDirectoryName, int iRelativePathInx, CStringList &rlstOfCurrentLevelAlwaysName)
{
CTypedPtrList <CPtrList, AlwEntry*> lstOfAlwEntry;
mfn_vSearchDirForAlways (csDirectoryName, iRelativePathInx, lstOfAlwEntry);
int iSufix = 0;
POSITION pos = lstOfAlwEntry.GetHeadPosition ();
while (pos)
{
AlwEntry *pAlwEntry = lstOfAlwEntry.GetNext (pos);
if (!pAlwEntry)
continue;
BOOL bAlwaysOk = TRUE;
POSITION pos2 = rlstOfCurrentLevelAlwaysName.GetHeadPosition ();
while (pos2)
{
const CString csExcludedAlwaysName = rlstOfCurrentLevelAlwaysName.GetNext (pos2);
if (0 == csExcludedAlwaysName.CompareNoCase (pAlwEntry->m_csAlwaysName))
{
bAlwaysOk = FALSE;
break;
}
}
if (bAlwaysOk)
{
CString csSufix;
csSufix.Format ("%s%d", "UnloadedAlways", iSufix++);
CPA_UnloadedAlways *pAlways = new CPA_UnloadedAlways (g_pclInterface, g_c_csUnloadedAlwaysType, pAlwEntry->m_csAlwaysName + csSufix);
if (!pAlways)
return; //not enough memory
// pAlways->SetAvailable (FALSE);
pAlways->mfn_vSetUAlwaysName (pAlwEntry->m_csAlwaysName);
pAlways->mfn_vSetAlwFile (pAlwEntry->m_csAlwFile);
m_clUnloadedAlwaysList.fn_bAddObject (pAlways);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vSearchDirForAlways
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vSearchDirForAlways (CString csDirectoryName, int iRelativePathInx, CTypedPtrList <CPtrList, AlwEntry*> &rlstOfAlwEntry)
{
//search in depth all subdirectories until we get the directories named "charact"
//in this directories look for *.car files whose names begin with "ALW_"
struct _finddata_t findDataSubdir;
long lSubdirHandle = _findfirst (csDirectoryName + "\\*.*", &findDataSubdir);
CString csCharactDir ("charact");
if (-1 != lSubdirHandle)
{
do
{
if (_A_SUBDIR == (findDataSubdir.attrib & _A_SUBDIR))
{
if (0 == csCharactDir.CompareNoCase (findDataSubdir.name))
mfn_vGetAlwaysFromCharactDirectory (csDirectoryName + "\\" + csCharactDir, iRelativePathInx, rlstOfAlwEntry);
else if (CString (".") != findDataSubdir.name && CString ("..") != findDataSubdir.name)
mfn_vSearchDirForAlways (csDirectoryName + "\\" + findDataSubdir.name, iRelativePathInx, rlstOfAlwEntry);
}
}while (-1 != _findnext (lSubdirHandle, &findDataSubdir));
}
_findclose (lSubdirHandle);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vGetAlwaysFromCharactDirectory
// Date : 98-05
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA2
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vGetAlwaysFromCharactDirectory (CString csDirectoryName, int iRelativePathInx, CTypedPtrList <CPtrList, AlwEntry*> &rlstOfAlwEntry)
{
//search the alw file in the subdirectory
struct _finddata_t findDataFile;
CString csCarFile;
long lFileHandle = _findfirst (csDirectoryName + '\\' + "*.car", &findDataFile);
if (-1 != lFileHandle)
{
do
{
csCarFile = findDataFile.name;
CString csPrefix = csCarFile.Left (4);
if (0 == csPrefix.CompareNoCase ("ALW_")) //always character
{
int iInx = csCarFile.ReverseFind ('.');
ASSERT (-1 != iInx);
CString csAlwaysName = csCarFile.Left (iInx);
CString csRelativePath = csDirectoryName + "\\" + csCarFile;
csRelativePath = csRelativePath.Mid (iRelativePathInx);
AlwEntry *pAlwEntry = new AlwEntry (csAlwaysName, csRelativePath);
rlstOfAlwEntry.AddTail (pAlwEntry);
}
}while (-1 != _findnext (lFileHandle, &findDataFile));
}
_findclose (lFileHandle);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : m_fn_vLoadFamilyModels
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::m_fn_vLoadFamilyModels (CString csFamilyName)
{
if (csFamilyName.IsEmpty ())
return;
CString csDirectory = fn_szGetFamiliesDataPath() + CString ("\\") + csFamilyName;
m_fn_vScanDirectoryForUnloadedModels(csDirectory, 1);
m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vExtractAlwaysModelsFromBehaviour
// Date : 98/06/30
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vExtractAlwaysModelsFromBehaviour (CString &rcsAIText, CStringList &rlstOfAlways)
{
CStringList lstGenereName;
lstGenereName.AddHead ("GenereObjet");
lstGenereName.AddHead ("ACT_GenerateObject");
lstGenereName.AddHead ("TEXT_Affiche");
lstGenereName.AddHead ("TEXT_DisplayText");
POSITION posGN = lstGenereName.GetHeadPosition ();
while (NULL != posGN)
{
CString csGenereFunctionName = lstGenereName.GetNext (posGN);
csGenereFunctionName.MakeLower();
CString csAIText = rcsAIText;
csAIText.MakeLower();
BOOL bLastLineFound = FALSE;
while (!csAIText.IsEmpty () && !bLastLineFound)
{
int iNewLineLimit = csAIText.Find ("\n");
CString csAILine;
if (-1 == iNewLineLimit)
{
bLastLineFound = TRUE;
csAILine = csAIText;
}
else
{
csAILine = csAIText.Left (iNewLineLimit);
csAIText = csAIText.Mid (iNewLineLimit + 1);
}
csAILine.TrimLeft ();
if (!csAILine.IsEmpty () && ';' != csAILine [0]) //for every valid line in the AIText(don't treat commented lines)
{
for (;;)
{
int iInx = csAILine.Find (csGenereFunctionName);
if (-1 == iInx)
break;
CString csComplete = csAILine + csAIText;
CString csArg = GetFunctionArgument (csComplete, iInx);
if (!csArg.IsEmpty ())
{
csArg.MakeLower();
if (rlstOfAlways.Find (csArg) == NULL)
rlstOfAlways.AddTail (csArg);
}
csAILine = csAILine.Mid (csGenereFunctionName.GetLength ());
}
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : GetFunctionArgument
// Date : 98/06/30
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
CString EdActors_MyDocument::GetFunctionArgument (CString &rText, int iFunctionInx)
{
CString csArg;
CString csFunctionText = rText.Mid (iFunctionInx);
int i1Sep = csFunctionText.Find ('(');
int i2Sep = csFunctionText.Find (')');
if (-1 != i1Sep && -1 != i2Sep && i2Sep > i1Sep)
{
CString csArgs = csFunctionText.Mid (i1Sep + 1, i2Sep - i1Sep - 1);
int i1StrSep = csArgs.Find ('"');
if (-1 != i1StrSep)
{
CString csArgsSubStr = csArgs.Mid (i1StrSep + 1);
int i2StrSep = csArgsSubStr.Find ('"');
ASSERT (-1 != i2StrSep);
csArg = csArgsSubStr.Left (i2StrSep);
}
}
return csArg;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vFillRefAlwaysForModel
// Date : 98/07/16
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vFillRefAlwaysForModel (CPA_Actor *pModel, CStringList &rlstOfRefAlways)
{
if (!pModel || !pModel->m_fn_bIsAModel ())
return;
CPA_EdIR_Brain *pclBrain = ((EdActors_EditorActorModel *)pModel->m_fn_pclGetEditorActor())->m_pclBrain;
if (pclBrain)
{
// behaviours
POSITION posInIBehaviours = pclBrain->m_clListOfIntelligenceBehaviours.GetHeadPosition ();
while (posInIBehaviours)
{
CPA_EdIR_MainBehaviour *pMainBehaviour = pclBrain->m_clListOfIntelligenceBehaviours.GetNext (posInIBehaviours);
ASSERT (pMainBehaviour);
mfn_vExtractAlwaysModelsFromBehaviour (pMainBehaviour->m_csText, rlstOfRefAlways);
}
// reflex
POSITION posInRBehaviours = pclBrain->m_clListOfReflexBehaviours.GetHeadPosition ();
while (posInRBehaviours)
{
CPA_EdIR_MainBehaviour *pMainBehaviour = pclBrain->m_clListOfReflexBehaviours.GetNext (posInRBehaviours);
ASSERT (pMainBehaviour);
mfn_vExtractAlwaysModelsFromBehaviour (pMainBehaviour->m_csText, rlstOfRefAlways);
}
// declarations
POSITION posInDBehaviours = pclBrain->m_clListOfDeclarations.GetHeadPosition ();
while (posInDBehaviours)
{
CPA_EdIR_MainBehaviour *pMainBehaviour = pclBrain->m_clListOfDeclarations.GetNext (posInDBehaviours);
ASSERT (pMainBehaviour);
mfn_vExtractAlwaysModelsFromBehaviour (pMainBehaviour->m_csText, rlstOfRefAlways);
}
// macros
POSITION posInMBehaviours = pclBrain->m_clListOfMacros.GetHeadPosition ();
while (posInMBehaviours)
{
CPA_EdIR_MainBehaviour *pMainBehaviour = pclBrain->m_clListOfMacros.GetNext (posInMBehaviours);
ASSERT (pMainBehaviour);
mfn_vExtractAlwaysModelsFromBehaviour (pMainBehaviour->m_csText, rlstOfRefAlways);
}
// subroutines
POSITION posInSBehaviours = pclBrain->m_clListOfSubrs.GetHeadPosition ();
while (posInSBehaviours)
{
CPA_EdIR_MainBehaviour *pMainBehaviour = pclBrain->m_clListOfSubrs.GetNext (posInSBehaviours);
ASSERT (pMainBehaviour);
mfn_vExtractAlwaysModelsFromBehaviour (pMainBehaviour->m_csText, rlstOfRefAlways);
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vCheckModelToUpdateAlwFile
// Date : 98/07/16
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void EdActors_MyDocument::mfn_vCheckModelToUpdateAlwFile (CPA_Actor *pModel)
{
if (!pModel || !pModel->m_fn_bIsAModel ())
return;
CStringList lstOfRefAlways;
mfn_vFillRefAlwaysForModel (pModel, lstOfRefAlways);
CStringList lstOfReferencedAlwaysNotLoaded;
CPA_BaseObject *pObject = NULL;
POSITION pos = lstOfRefAlways.GetHeadPosition ();
while (pos)
{
CString csRefAlwaysName = lstOfRefAlways.GetNext (pos);
pObject = m_clAlwaysList.fn_p_oFindObject (csRefAlwaysName);
if (NULL == pObject)
lstOfReferencedAlwaysNotLoaded.AddTail (csRefAlwaysName);
}
if (!lstOfReferencedAlwaysNotLoaded.IsEmpty ())
{
CDlgCleanAlwFile dlg (lstOfReferencedAlwaysNotLoaded, TASK_UPDATE_ALW_FILE);
if (IDOK == dlg.DoModal ())
{
//clean the alw file
CStringList &rlstOfAlwaysToBeLoaded = lstOfReferencedAlwaysNotLoaded; //the dialog fills the list with the always to be removed
//change the name in order not to propagate confusion
g_pclInterface->M_GetEditManager ()->AskFor (new ModifUpdateAlwFile (g_pclInterface, rlstOfAlwaysToBeLoaded));
}
}
}
// Shaitan => state list in the level
//////////////////////
// Update References//
//////////////////////
//************************************************************************
void EdActors_MyDocument::m_fn_vUpdateReferencesForAllActions (void)
{
POSITION pos, pos1, pos2;
CPA_DLLBase *pclIADLL;
CPA_BaseObject *pCurrentModel;
CPA_BaseObject *pCurrentFamily;
CPA_BaseObject *pCurrentInstance;
CPA_List<CPA_BaseObject> clListOfModels;
CPA_List<CPA_BaseObject> clListOfFamilies;
CPA_List<CPA_BaseObject> clListOfInstances;
pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
// make sure that all AIs have been parsed to update the references
clListOfFamilies.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfFamilies, "", C_szFamilyTypeName);
pos = clListOfFamilies.GetHeadPosition();
while (pos)
{
pCurrentFamily = clListOfFamilies.GetNext(pos);
clListOfModels.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfModels, "", C_szActorModelTypeName, pCurrentFamily);
pos1 = clListOfModels.GetHeadPosition();
while (pos1)
{
pCurrentModel = clListOfModels.GetNext(pos1);
clListOfInstances.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfInstances, "", C_szActorInstanceTypeName, pCurrentModel);
pos2 = clListOfInstances.GetHeadPosition();
if (pos2)
{
pCurrentInstance = clListOfInstances.GetNext(pos2);
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis=pCurrentModel;
stCom.pvData=pCurrentInstance;
pclIADLL->OnQueryAction(g_pclInterface,C_uiAI_ProcessModifiedIA,(long)(&stCom));
}
}
}
}
// status bar message
M_GetMainWnd()->UpdateStatus("All references of actions in all AIs were updated", C_STATUSPANE_INFOS, C_STATUS_NORMAL);
}
//////////////////////
// Update State List//
//////////////////////
//************************************************************************
void EdActors_MyDocument::m_fn_vUpdateListOfUsedActionsForFamily (CPA_Family *pFamily)
{
POSITION pos, pos1;
CPA_Action *pAction;
CPA_Actor *pCurrentInstance;
CPA_BaseObject *pCurrentModel;
CPA_List<CPA_BaseObject> clListOfModels;
CPA_List<CPA_BaseObject> clListOfInstances;
char szSectionName[SCR_CV_ui_Cfg_MaxLenName];
char szMessage[256];
// clear the list of actions used by this family
pFamily->m_oListOfUsedActions.RemoveAll();
// first, check the actions referenced in the AI
pos = pFamily->m_oListOfActions.GetHeadPosition();
while (pos)
{
pAction = pFamily->m_oListOfActions.GetNext(pos);
//if someone is referencing this action, it must be added in the list
CList<CPA_BaseObject *, CPA_BaseObject *> oFatherList;
int iNbFathers = g_oCoherenceManager.m_fn_iGetFatherList(pAction, &oFatherList);
if (iNbFathers > 0)
pFamily->m_oListOfUsedActions.AddTail(pAction);
}
// then, check the initial action of each instance of the family
clListOfModels.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfModels, "", C_szActorModelTypeName, pFamily);
pos = clListOfModels.GetHeadPosition();
while (pos)
{
pCurrentModel = clListOfModels.GetNext(pos);
clListOfInstances.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfInstances, "", C_szActorInstanceTypeName, pCurrentModel);
pos1 = clListOfInstances.GetHeadPosition();
while (pos1)
{
pCurrentInstance = (CPA_Actor *) clListOfInstances.GetNext(pos1);
// check initial action
tdstEngineObject *p_stObject = (tdstEngineObject*) pCurrentInstance->GetStruct();
tdxHandleToState hState = fn_h3dDataGetInitialState(p_stObject->h_3dData);
CPA_State *pState = (CPA_State *) g_pclInterface->GetMainWorld()->fn_p_oFindObjectWithEngine(hState, C_szStateTypeName);
pAction = pState->mfn_p_oGetAction();
if (!pFamily->m_oListOfUsedActions.Find(pAction))
pFamily->m_oListOfUsedActions.AddTail(pAction);
}
}
// notifies the STL section for saving
if (pFamily->m_oListOfUsedActions.GetCount() > 0)
{
sprintf(szSectionName,"%s\\%s\\Families\\%s\\%s.stl^%s",
fn_szGetLevelsDataPath(),
fn_p_szGetLevelName(),
pFamily->GetName(),
pFamily->GetName(),
C_SectionCreateListOfState);
SCR_fn_v_SvL1_RegisterNotify(szSectionName, s_m_fn_vCallBackSaveStateList, pFamily, SCR_EA_Ntfy_AddOrRebuildSection);
}
// status bar message
sprintf(szMessage, "List of states updated for family %s", pFamily->GetName());
M_GetMainWnd()->UpdateStatus(szMessage, C_STATUSPANE_INFOS, C_STATUS_NORMAL);
}
// End Shaitan => state list in the level
// Shaitan => module list in the level
//////////////////////
// Update TBL List //
//////////////////////
//************************************************************************
void EdActors_MyDocument::m_fn_vUpdateListOfUsedObjectTablesForFamily (CPA_Family *pFamily)
{
POSITION pos, pos1;
EditorObjectTable *pObjectTable;
CPA_Actor *pCurrentInstance;
CPA_BaseObject *pCurrentModel;
CPA_List<CPA_BaseObject> clListOfModels;
CPA_List<CPA_BaseObject> clListOfInstances;
char szMessage[256];
// clear the list of object tables used by this family
pFamily->m_oListOfUsedObjectTables.RemoveAll();
// first, check the object tables referenced in the AI
pos = pFamily->m_oListOfObjectTables.GetHeadPosition();
while (pos)
{
pObjectTable = pFamily->m_oListOfUsedObjectTables.GetNext(pos);
//if someone is referencing this action, it must be added in the list
CList<CPA_BaseObject *, CPA_BaseObject *> oFatherList;
int iNbFathers = g_oCoherenceManager.m_fn_iGetFatherList(pObjectTable, &oFatherList);
if (iNbFathers > 0)
pFamily->m_oListOfUsedObjectTables.AddTail(pObjectTable);
}
// then, check the initial object table of each instance of the family
clListOfModels.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfModels, "", C_szActorModelTypeName, pFamily);
pos = clListOfModels.GetHeadPosition();
while (pos)
{
pCurrentModel = clListOfModels.GetNext(pos);
clListOfInstances.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfInstances, "", C_szActorInstanceTypeName, pCurrentModel);
pos1 = clListOfInstances.GetHeadPosition();
while (pos1)
{
pCurrentInstance = (CPA_Actor *) clListOfInstances.GetNext(pos1);
// check initial action
tdstEngineObject *p_stObject = (tdstEngineObject*) pCurrentInstance->GetStruct();
tdxHandleToObjectsTablesList hObjectTable = fn_h3dDataGetInitialObjectsTable(p_stObject->h_3dData);
pObjectTable = (EditorObjectTable *) g_pclInterface->GetMainWorld()->fn_p_oFindObjectWithEngine(hObjectTable, C_szObjectTableTypeName);
if (!pFamily->m_oListOfUsedObjectTables.Find(pObjectTable))
pFamily->m_oListOfUsedObjectTables.AddTail(pObjectTable);
}
}
// check also the default object table of the family
if (pFamily->GetStruct())
{
tdxHandleToObjectsTablesList hObjectTable = fn_vGetDefaultObjectsTableOfFamily((tdxHandleToFamilyList) pFamily->GetStruct());
pObjectTable = (EditorObjectTable *) g_pclInterface->GetMainWorld()->fn_p_oFindObjectWithEngine(hObjectTable, C_szObjectTableTypeName);
if (!pFamily->m_oListOfUsedObjectTables.Find(pObjectTable))
pFamily->m_oListOfUsedObjectTables.AddTail(pObjectTable);
}
// status bar message
sprintf(szMessage, "List of object tables updated for family %s", pFamily->GetName());
M_GetMainWnd()->UpdateStatus(szMessage, C_STATUSPANE_INFOS, C_STATUS_NORMAL);
}
//////////////////////
// Update PO List //
//////////////////////
//************************************************************************
void EdActors_MyDocument::m_fn_vUpdateListOfUsedPOsForFamily (CPA_Family *pFamily)
{
POSITION pos, pos1;
CPA_State *pState;
CPA_Actor *pCurrentInstance;
CPA_Action *pAction;
CPA_Animation *pAnimation;
CPA_BaseObject *pPO;
CPA_BaseObject *pCurrentModel;
EditorObjectTable *pObjectTable;
CPA_List<CPA_BaseObject> clListOfModels;
CPA_List<CPA_BaseObject> clListOfInstances;
MS_tdxHandleTo3dData h_3dData = NULL;
tdxHandleToObjectsTablesList hObjectTable;
tdxHandleToObjectsTableElement hOTElement;
struct tdstAnim3d_ *p_stCurrentAnim;
struct tdstFrame3d_ *p_stCurrentFrame3d;
struct tdstElement3d_ *p_stCurrentElement3d;
unsigned short uwCurrentFrame;
unsigned char ucElement;
short wArrayOfIndexes[500];
short wMaxElement = 500;
short wIndex;
char szSectionName[SCR_CV_ui_Cfg_MaxLenName];
char szMessage[256];
// clear the list of POs used by this family
pFamily->m_oListOfUsedPOs.RemoveAll();
for (wIndex = 0; wIndex < wMaxElement; wIndex++)
wArrayOfIndexes[wIndex] = 0;
// get an instance of this family
clListOfModels.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfModels, "", C_szActorModelTypeName, pFamily);
pos = clListOfModels.GetHeadPosition();
if (pos)
{
pCurrentModel = clListOfModels.GetNext(pos);
clListOfInstances.RemoveAll();
g_pclInterface->GetMainWorld()->fn_lFindObjects(&clListOfInstances, "", C_szActorInstanceTypeName, pCurrentModel);
pos1 = clListOfInstances.GetHeadPosition();
if (pos1)
{
pCurrentInstance = (CPA_Actor *) clListOfInstances.GetNext(pos1);
h_3dData = /*(struct tdstEngineObject_ *) */pCurrentInstance->GetStruct()->h_3dData;
}
}
if (h_3dData == NULL)
return;
// first, build the list of used indexes
pos = pFamily->m_oListOfUsedActions.GetHeadPosition();
while (pos)
{
pAction = pFamily->m_oListOfUsedActions.GetNext(pos);
// for each state of the action
pos1 = pAction->m_oListOfStates.GetHeadPosition();
while (pos1)
{
pState = pAction->m_oListOfStates.GetNext(pos1);
// get the corresponding animation
pAnimation = pState->mfn_p_oGetAnimation();
// check engine animation
p_stCurrentAnim = (pAnimation) ? (struct tdstAnim3d_ *) pAnimation->GetData() : NULL;
if (p_stCurrentAnim)
{
fn_vFindUsedIndexes(wArrayOfIndexes, wMaxElement, p_stCurrentAnim, h_3dData);
}
}
}
// then build the corresponding list of POs
pos = pFamily->m_oListOfUsedObjectTables.GetHeadPosition();
while (pos)
{
// get object table
pObjectTable = pFamily->m_oListOfUsedObjectTables.GetNext(pos);
hObjectTable = (tdxHandleToObjectsTablesList) pObjectTable->GetData();
// check each index
for (wIndex = 0; wIndex < wMaxElement; wIndex++)
{
if (wArrayOfIndexes[wIndex] == 1)
{
hOTElement = fn_d_hGetElementByNumberInObjectsTable(hObjectTable, wIndex);
if ((fn_wObjectsTableGetTypeOfTarget(hOTElement) == C_wTdO_PhysicalObject) ||
(fn_wObjectsTableGetTypeOfTarget( hOTElement ) == C_wTdO_Mirror))
{
// get corresponding PO
pPO = g_pclInterface->GetMainWorld()->fn_p_oFindObjectWithEngine(fn_hObjectsTableGetTarget(hOTElement), C_szPhysicalObjectTypeName);
// add it to the list
if (pPO && !pFamily->m_oListOfUsedPOs.Find(pPO))
pFamily->m_oListOfUsedPOs.AddTail(pPO);
}
}
}
}
// notifies the OTL section for saving
if (pFamily->m_oListOfUsedPOs.GetCount() > 0)
{
sprintf(szSectionName,"%s\\%s\\Families\\%s\\%s.otl^%s",
fn_szGetLevelsDataPath(),
fn_p_szGetLevelName(),
pFamily->GetName(),
pFamily->GetName(),
C_SectionCreateListOfPOs);
SCR_fn_v_SvL1_RegisterNotify(szSectionName, s_m_fn_vCallBackSavePOList, pFamily, SCR_EA_Ntfy_AddOrRebuildSection);
}
// status bar message
sprintf(szMessage, "List of POs updated for family %s", pFamily->GetName());
M_GetMainWnd()->UpdateStatus(szMessage, C_STATUSPANE_INFOS, C_STATUS_NORMAL);
}
// End Shaitan => module list in the level
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : ModifUpdateAlwFile
// Date : 98/07/16
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
ModifUpdateAlwFile::ModifUpdateAlwFile (CPA_Actor_Editor_Interface *pInterface, CStringList &rlstAlwObjects, BOOL pBlock/* = FALSE*/)
: CPA_Modif (UPDATE_ALW_FILE, "UpdateAlwFile", pBlock)
{
m_pInterface = pInterface;
m_lstAlwObjects.AddHead (&rlstAlwObjects);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : Undo
// Date : 98/07/16
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL ModifUpdateAlwFile::Undo ()
{
ASSERT (m_pInterface);
int iReinitDialog = 0;
Position posAlw = m_pInterface->m_clDocument.m_clAlwaysList.GetHeadPosition ();
while (posAlw)
{
CPA_Actor *pAlways = (CPA_Actor *)m_pInterface->m_clDocument.m_clAlwaysList.GetNext (posAlw);
ASSERT (pAlways);
BOOL bRemoveIt = NULL != m_lstAlwObjects.Find (pAlways->GetName ());
//remove the always that are choosed to be removed
if (bRemoveIt)
iReinitDialog = m_pInterface->mfn_bUnloadAlwaysFromLevel (pAlways) ? posAlw = m_pInterface->m_clDocument.m_clAlwaysList.GetHeadPosition (), //there is a bug in the list implementatin, so I have to reinitialize the list pos after I delete an element
iReinitDialog + 1 : iReinitDialog;
}
if (0 < iReinitDialog)
{
ASSERT (m_pInterface->m_clDocument.m_pclDialogList);
m_pInterface->m_clDocument.m_pclDialogList->fn_vReinitDialog ();
}
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : Do
// Date : 98/07/16
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL ModifUpdateAlwFile::Do ()
{
int iReinitDialog = 0;
POSITION pos = m_lstAlwObjects.GetHeadPosition ();
while (pos)
{
CString csAlwName = m_lstAlwObjects.GetNext (pos);
if (csAlwName.IsEmpty ())
continue;
CPA_UnloadedAlways *pUAlways = NULL;
BOOL bFound = FALSE;
Position posUA = m_pInterface->m_clDocument.m_clUnloadedAlwaysList.GetHeadPosition ();
while (posUA)
{
pUAlways = (CPA_UnloadedAlways *)m_pInterface->m_clDocument.m_clUnloadedAlwaysList.GetNext (posUA);
if (!csAlwName.CompareNoCase(pUAlways->mfn_csGetUAlwaysName()))
{
bFound = TRUE;
break;
}
}
if (!bFound)
return FALSE;
ASSERT (pUAlways);
m_pInterface->m_clDocument.m_clUnloadedAlwaysList.fn_bRemoveObject (pUAlways);
m_pInterface->mfn_vLoadAlways (pUAlways);
pUAlways->mfn_vSetLoaded (TRUE);
iReinitDialog++;
}
if (0 < iReinitDialog)
m_pInterface->m_clDocument.m_pclDialogList->fn_vReinitDialog ();
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink