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

2248 lines
70 KiB
C++
Raw Blame History

/////////////////////////////////////////////////
// _Actors.cpp
//
// Implementation file - Actors DLL Object
//
// Programmation : YB
/////////////////////////////////////////////////
#include "StdAfx.h"
#include "_AInterf.hpp"
#include "IncGAM.h"
#include "TFa.h"
#include "DPT.h"
#include "EDACStrg.hpp"
#include "EDACInst.hpp"
#include "EDACModl.hpp"
#include "EDACVwAc.hpp"
#include "EDACDgIf.hpp"
#include "EDACDgQu.hpp"
#include "Defines.hpp"
//-----------------IR-------------------------
#include "EdIRStrg.hpp"
#include "EdIRFrm.hpp"
#include "EdIRDVVw.hpp"
#include "EdIRBeEn.hpp"
//BEGIN ROMTEAM Cristi Petrescu 98-05-
#include "ai_intf.hpp"
//END ROMTEAM Cristi Petrescu 98-05-
//--------------------------------------------
#include "EDACActr.hpp"
#include "OPD.h"
#include "OGd.h"
#include "ErO.h"
#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
static const CString s_g_c_csAntiSlash = "\\";
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//******************************************************************************
//******************************************************************************
DeclareTemplateStatic(EdActors_tdhHandleToActor);
//******************************************************************************
//******************************************************************************
// Del function
//******************************************************************************
void fn_vDelete(EdActors_tdhHandleToActor hObj)
{
// !!!! For actors, deletion is made in Editor's objects !!!!
}
//CPA2 Stegaru Cristian 98-06
CString CPA_Actor::m_csINIFileName = "Objects\\Actors\\Actors.ini";
CString CPA_Actor::m_csHideVariableSection = "HideVariableSection";
//End CPA2 Stegaru Cristian 98-06
//******************************************************************************
void CPA_Actor::StaticInit()
{
CPA_EdMot<EdActors_tdhHandleToActor>::Init(NULL, NULL, fn_vDelete);
SCR_fn_v_RdL0_RegisterCallback( M_MAKECHAR(g_c_csActorScriptModelSectionName),
EdActors_MyDocument::m_fn_tdeCallBackLoadModel,
SCR_CRC_c_RdL0_ForSection);
SCR_fn_v_RdL0_RegisterCallback( M_MAKECHAR(g_c_csMSSection),
EdActors_ActorMiniStructure::m_fn_tdeCallBackLoad,
SCR_CRC_c_RdL0_ForSection);
//For fields in Watch ("elv" file)
SCR_fn_v_RdL0_RegisterCallback( M_MAKECHAR(g_c_csEdActors_ActorInWatchSectionName),
EdActors_MyDocument::m_fn_tdeCallBackLoadFieldsInWatch,
SCR_CRC_c_RdL0_ForSection);
}
//******************************************************************************
//******************************************************************************
// CPA_Actor normal constructor
//******************************************************************************
//******************************************************************************
CPA_Actor::CPA_Actor( EdActors_tdhHandleToActor hObj,
EdActors_EditorActor *pclEditorActor,
CString csType,
CPA_Actor *pclBaseModel,
CPA_Family *pclBaseFamily,
CPA_SuperObject *_p_oSuperObject,
CString csName,
BOOL _bActorIsAvailable /*= TRUE*/
)
: CPA_SaveObject( g_pclInterface,
csType,
E_ss_Responsible
),
CPA_EdMot<EdActors_tdhHandleToActor>(hObj)
{
////////////////////
// Specific inits //
////////////////////
// Init members //
//To be able to save
m_bIsAnAlways = FALSE;
m_bIsAGenDoor = FALSE;
m_bDisplayZone = FALSE;
m_pclIsolatedSuperObject = NULL;
m_pclSectionSubObject = NULL;
m_pri_pclCurrentObjectTable = NULL;
m_pri_pclInitialObjectTable = NULL;
m_pri_pclCurrentAction = NULL;
m_pri_pclInitialAction = NULL;
m_pri_pclCurrentState = NULL;
m_pri_pclInitialState = NULL;
m_pclSuperObject = NULL;
m_pri_pclFamily = pclBaseFamily;
m_bIsAnInstance = ( csType.Compare(g_c_csActorType) == 0 );
m_pri_bIsCommon = FALSE;
m_pri_bIsInFix = FALSE;
m_pri_bIsAlwaysActive = FALSE;
// ANNECY MT - 19/11/98 {
m_pri_bIsInAllSubMaps = FALSE;
// END ANNECY MT }
m_pri_bHasBeenModified = FALSE;
m_bCheckZonesAgainstBV = TRUE;
////////////////
// Base inits //
////////////////
//Section object
SetSectionData(this);
SetCallBackSave(s_m_fn_vCallBackSaveActor);
SetDataPath((char *)LPCTSTR(g_pclInterface->m_clDocument.m_pub_csCommonDataPath));
//Base objet
CPA_SaveObject *pclActorsOwner = NULL;
if ( csType.CompareNoCase(g_c_csActorType) == 0 )
pclActorsOwner = (CPA_SaveObject *)pclBaseModel;
else if ( csType.CompareNoCase(g_c_csActorModelType) == 0 )
pclActorsOwner = (CPA_SaveObject *)pclBaseFamily;
fn_bSetOwner(pclActorsOwner);
//Name
if (fn_eRename(csName) != E_mc_None )
SetDefaultValidName();
m_bHideVariable = FALSE;
mfn_vLoadFromINI ();
if ( _p_oSuperObject != NULL )
{
m_pub_fn_vSetSuperObject(_p_oSuperObject);
_p_oSuperObject->SetObject(this);
}
//*****************************
//** Creation of an Instance **
//*****************************
if ( csType.Compare(g_c_csActorType) == 0 )
{
EdActors_EditorActorInstance *pclNewEditorInstance = new EdActors_EditorActorInstance(pclBaseModel,
this,
hObj,
_p_oSuperObject);
//Adds in the List
g_pclInterface->m_clDocument.m_clInstancesList.fn_bAddObject(this);
if ( pclBaseModel != NULL )
m_bIsAGenDoor = pclBaseModel->m_fn_bIsAGenDoor();
}
//*************************
//** Creation of a Model **
//*************************
else if ( csType.Compare(g_c_csActorModelType) == 0 )
{
//Creates Editor's Model
EdActors_EditorActorModel *pclNewEditorModel = NULL;
if ( pclBaseFamily != NULL )
pclNewEditorModel = new EdActors_EditorActorModel(pclBaseFamily,this);
else
pclNewEditorModel = new EdActors_EditorActorModel(this);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Creation of a Model",
"CPA_Actor::CPA_Actor(...)",
E_ERROR_GRAVITY_FATAL,
"Editor Model has not been created (Pointer is NULL)");
ERROR_ASSERT( pclNewEditorModel != NULL );
//Sets internal Pointer
m_pclEditorActor = pclNewEditorModel;
EdActors_tdhHandleToActor hActor = (EdActors_tdhHandleToActor)(pclNewEditorModel->m_fn_ptdstGetMotorActor());
fn_vUpdateData(hActor);
SetEngineStruct(hActor);
//Adds in the List
g_pclInterface->m_clDocument.m_clModelsList.fn_bAddObject(this);
if (!g_pclInterface->m_clDocument.m_pLoadedModel)
g_pclInterface->m_clDocument.m_pLoadedModel = this;
//Tells Material Editor about the Model creation
CPA_DLLBase *p_clGameMaterialDLL = g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLMaterialName);
if( p_clGameMaterialDLL != NULL )
p_clGameMaterialDLL->OnQueryAction(g_pclInterface, (WPARAM)C_cCreateNewGameMaterial, 0);
}
//For Object Tables
m_pub_fn_vConstructEnumDescriptorForObjectsTables();
//Updates List Dialog
// g_pclInterface->m_clDocument.m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
fn_vUpdateSectionName();
//First notification
if ( m_fn_bIsAModel() )
{
//If Model is loaded from a file
if ( pclBaseFamily == NULL )
SetExistingSection(TRUE);
else
SetExistingSection(FALSE);
}
else
{
//If Instance is loaded from a file
if ( hObj != NULL )
SetExistingSection(TRUE);
else
SetExistingSection(FALSE);
}
//Internal Section Object
m_pclSectionSubObject = new CPA_SectionObject("",
(char *)LPCTSTR(g_pclInterface->m_clDocument.m_pub_csCommonDataPath),
s_m_fn_vCallBackSaveActor,
this,
fn_bSectionExists());
if ( pclBaseFamily != NULL )
m_pclSectionSubObject->SetReferencedSectionName(m_pri_fn_csComputeReferencedFileName());
if ( ( fn_bCanBeNotified() )
&& ( !fn_bSectionExists() )
&& ( _bActorIsAvailable )
)
fn_vNotifySave();
// !! Bidon !!
//Sets Inital OT
/* if ( m_fn_bIsAModel() && _bActorIsAvailable )
{
//m_pub_fn_vConstructEnumDescriptorForObjectsTables();
EditorObjectTable *pclOT = NULL;
CString csOTName;
if ( m_pub_fn_pclGetEnumDescriptorForObjectsTables()->GetCount() > 0 )
{
CString csOTName = m_pub_fn_pclGetEnumDescriptorForObjectsTables()->GetHead()->m_pub_fn_csGetString();
pclOT = (EditorObjectTable *)g_pclInterface->GetMainWorld()->fn_p_oFindObject(csOTName, C_szObjectTableTypeName);
}
m_pub_fn_vSetInitialObjectTable(pclOT);
}
*/ // !! End Bidon !!
}
//******************************************************************************
//******************************************************************************
// CPA_Actor Copy constrcutor
//******************************************************************************
//******************************************************************************
// !! Only works with Models !!
//******************************************************************************
CPA_Actor::CPA_Actor(CPA_Actor *_pclSourceActor,
CPA_SuperObject *_p_oSuperObject,
CString _csName)
: CPA_SaveObject( g_pclInterface,
_pclSourceActor->GetType(),
E_ss_Responsible
),
CPA_EdMot<EdActors_tdhHandleToActor>((EdActors_tdhHandleToActor)NULL)
{
////////////////////
// Specific inits //
////////////////////
// Init members //
//To be able to save
m_bIsAnAlways = _pclSourceActor->m_bIsAnAlways;
m_bIsAGenDoor = FALSE; //An init function will be called
m_bDisplayZone = FALSE;
m_pclIsolatedSuperObject = NULL;
m_pclSectionSubObject = NULL;
m_pri_pclCurrentObjectTable = _pclSourceActor->m_pri_pclCurrentObjectTable;
m_pri_pclInitialObjectTable = _pclSourceActor->m_pri_pclInitialObjectTable;
m_pri_pclCurrentAction = _pclSourceActor->m_pri_pclCurrentAction;
m_pri_pclInitialAction = _pclSourceActor->m_pri_pclInitialAction;
m_pri_pclCurrentState = _pclSourceActor->m_pri_pclCurrentState;
m_pri_pclInitialState = _pclSourceActor->m_pri_pclInitialState;
m_pclSuperObject = NULL;
m_pri_pclFamily = _pclSourceActor->m_pub_fn_pclGetFamily();
m_bIsAnInstance = _pclSourceActor->m_bIsAnInstance;
m_pri_bIsCommon = FALSE;
m_pri_bIsInFix = FALSE;
m_pri_bIsAlwaysActive = FALSE;
// ANNECY MT - 19/11/98 {
m_pri_bIsInAllSubMaps = FALSE;
// END ANNECY MT }
m_pri_bHasBeenModified = FALSE;
////////////////
// Base inits //
////////////////
//Section object
SetSectionData(this);
SetCallBackSave(s_m_fn_vCallBackSaveActor);
SetDataPath((char *)LPCTSTR(g_pclInterface->m_clDocument.m_pub_csCommonDataPath));
//Base objet
CPA_SaveObject *pclActorsOwner = NULL;
// if ( m_bIsAnInstance )
// pclActorsOwner = (CPA_SaveObject *)_pclSourceActor->m_pub_fn_pclGetModel();
// else
pclActorsOwner = (CPA_SaveObject *)m_pri_pclFamily;
fn_bSetOwner(pclActorsOwner);
//Name
if ( fn_eRename(_csName) != E_mc_None )
SetDefaultValidName();
if ( _p_oSuperObject != NULL )
m_pub_fn_vSetSuperObject(_p_oSuperObject);
//*************************
//** Copy of an Instance **
//*************************
if ( _pclSourceActor->GetType().Compare(g_c_csActorType) == 0 )
{
/* EdActors_EditorActorInstance *pclNewEditorInstance = new EdActors_EditorActorInstance(pclBaseModel,
this,
hObj,
_p_oSuperObject);
//Adds in the List
g_pclInterface->m_clDocument.m_clInstancesList.fn_bAddObject(this);
if ( pclBaseModel != NULL )
m_bIsAGenDoor = pclBaseModel->m_fn_bIsAGenDoor();
*/
}
//*********************
//** Copy of a Model **
//*********************
else if ( _pclSourceActor->GetType().Compare(g_c_csActorModelType) == 0 )
{
//Creates Editor's Model
EdActors_EditorActorModel *pclNewEditorModel = NULL;
//Calls the copy contructor
pclNewEditorModel = new EdActors_EditorActorModel(_pclSourceActor->m_fn_pclGetEditorModel(), this);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Copy of a Model",
"CPA_Actor::CPA_Actor(...) <Copy constructor>",
E_ERROR_GRAVITY_FATAL,
"Editor Model has not been created (returned Pointer is NULL)");
ERROR_ASSERT( pclNewEditorModel != NULL );
//Sets internal Pointer
m_pclEditorActor = pclNewEditorModel;
EdActors_tdhHandleToActor hActor = (EdActors_tdhHandleToActor)(pclNewEditorModel->m_fn_ptdstGetMotorActor());
fn_vUpdateData(hActor);
SetEngineStruct(hActor);
//Adds in the List
g_pclInterface->m_clDocument.m_clModelsList.fn_bAddObject(this);
//Tells Material Editor about the Model creation
// CPA_DLLBase *p_clGameMaterialDLL = g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLMaterialName);
// if( p_clGameMaterialDLL != NULL )
// p_clGameMaterialDLL->OnQueryAction(g_pclInterface, (WPARAM)C_cCreateNewGameMaterial, 0);
}
//For Object Tables
m_pub_fn_vConstructEnumDescriptorForObjectsTables();
//Updates List Dialog
// g_pclInterface->m_clDocument.m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
fn_vUpdateSectionName();
//First notification
//Is never loaded
SetExistingSection(FALSE);
//Internal Section Object
m_pclSectionSubObject = new CPA_SectionObject("",
(char *)LPCTSTR(g_pclInterface->m_clDocument.m_pub_csCommonDataPath),
s_m_fn_vCallBackSaveActor,
this,
fn_bSectionExists());
m_pclSectionSubObject->SetReferencedSectionName(m_pri_fn_csComputeReferencedFileName());
if ( ( fn_bCanBeNotified() )
&& ( !fn_bSectionExists() )
)
fn_vNotifySave();
}
//******************************************************************************
CPA_Actor::~CPA_Actor()
{
// ANNECY MT 13-02-98 {
// Destroy from Coherence Manager
g_oCoherenceManager.m_fn_vDestroyObject(this);
// END ANNECY MT }
//Deletes Editor Actor
delete m_pclEditorActor;
}
//******************************************************************************
void CPA_Actor::SetEngineStruct(EdActors_tdhHandleToActor hObj)
{
SetStruct(hObj);
//Sets internal data
m_pclEditorActor->m_fn_vSetMotorActor(hObj);
}
// Specific
/////////////
//******************************************************************************
CPA_Actor *CPA_Actor::m_fn_pclGetModel()
{
if ( m_fn_bIsAnInstance() )
return ( (CPA_Actor *)GetOwner() );
else
return NULL;
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsAnInstance()
{
return ( m_bIsAnInstance );
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsAModel()
{
return ( !m_bIsAnInstance );
}
//******************************************************************************
EdActors_EditorActor *CPA_Actor::m_fn_pclGetEditorActor()
{
return m_pclEditorActor;
}
//******************************************************************************
void CPA_Actor::m_fn_vSetEditorActor(EdActors_EditorActor *p_clEditorActor)
{
m_pclEditorActor = p_clEditorActor;
}
//******************************************************************************
EdActors_EditorActorModel *CPA_Actor::m_fn_pclGetEditorModel()
{
if ( m_fn_bIsAModel() )
return (EdActors_EditorActorModel *)m_pclEditorActor;
else
return NULL;
}
//******************************************************************************
EdActors_EditorActorInstance *CPA_Actor::m_fn_pclGetEditorInstance()
{
if ( m_fn_bIsAnInstance() )
return (EdActors_EditorActorInstance *)m_pclEditorActor;
else
return NULL;
}
//******************************************************************************
//To set a new name for an Actor
BOOL CPA_Actor::m_fn_bRename(CString _csNewName)
{
BOOL bReturn = TRUE;
CString csNewName = _csNewName;
BOOL bIsLoadingWorld = g_pclInterface->GetInterface()->fn_bIsLoadingWorld();
if ( m_pub_fn_bCanBeRenamed() )
{
//ANNECY Shaitan RenameAlways (03.04.98) {
if (m_bIsAnAlways)
{
CString csPrefix = csNewName.Left(4);
if (!bIsLoadingWorld && (csPrefix.CompareNoCase("ALW_") != 0))
{
// if necessary, remove user prefix, and set always prefix
if (csPrefix.Compare(g_pclInterface->GetInterface()->GetUserPrefix()) == 0)
csNewName = "ALW_" + _csNewName.Mid(4);
else
csNewName = "ALW_" + _csNewName;
// rename actor
while (fn_eCheckValidity(csNewName) != E_mc_None)
csNewName = csNewName + "1";
}
}
//ENDANNECY Shaitan RenameAlways }
//Renames Object
if ( csNewName.Compare(GetName()) != 0 )
{
//For Level to be changed (deletes old section)
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this, FALSE);
if (m_bIsAnAlways && !bIsLoadingWorld)
g_pclInterface->GetInterface()->SetLoadingWorld(TRUE);
bReturn = ( fn_eRename(csNewName) == E_mc_None );
g_pclInterface->GetInterface()->SetLoadingWorld(bIsLoadingWorld);
}
if ( bReturn )
{
//Motor changes
if ( m_fn_bIsAnInstance() )
{
MS_tdxHandleToStandardGame h_StdGame = m_fn_pclGetEditorActor()->m_fn_ptdstGetMotorActor()->h_StandardGame;
tdObjectType otPersonalType = fn_otStandardGameGetPersonalType(h_StdGame);
fn_vChangePersonalTypeNameOfPersonalType(otPersonalType, (char *)LPCTSTR(csNewName));
}
//Editor's display update
g_pclInterface->m_clDocument.m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
g_pclInterface->m_clDocument.m_pclActorsView->m_fn_vUpdateActorName();
}
//For Level to be saved (adds new section)
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this, TRUE);
//Saves modifications in Watch Description
//if ( m_fn_bIsAnInstance() )
// g_pclInterface->m_clDocument.m_pri_fn_bSaveFieldsInWatch();
}
else
{
CString csMessage = CString("Actor '") + GetName() + "' can not be renamed !";
EdActors_InformationDialog InfoDial(&g_oBaseFrame, csMessage);
InfoDial.DoModal();
bReturn = FALSE;
}
return bReturn;
}
//******************************************************************************
//To finish loading a Model
void CPA_Actor::m_fn_vFinishLoading()
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Trying to load an incomplete Model",
"CPA_Actor::m_fn_vFinishLoading(...)",
E_ERROR_GRAVITY_FATAL,
"Actor must be a Model, but is an Instance");
ERROR_ASSERT( m_fn_bIsAModel() );
CString csCompleteName = m_fn_csGetFamilyName() + '\\' + GetName() + '\\' + GetName();
g_pclInterface->m_clDocument.m_fn_pclLoadModel(csCompleteName, this);
SetAvailable(TRUE);
//Updates display
g_pclInterface->m_clDocument.m_fn_vDisplayActor(m_pclEditorActor, ED_ACTORS_eModeOfActorSelection_Unknown);
}
//******************************************************************************
CString CPA_Actor::m_fn_csGetFamilyName()
{
return m_csFamilyName;
}
//******************************************************************************
void CPA_Actor::m_fn_vSetFamilyName(CString csNewFamilyName)
{
m_csFamilyName = csNewFamilyName;
}
//******************************************************************************
// Sets the Actor as an Always
void CPA_Actor::m_fn_vMakeAlways(BOOL bIsAnAlways /*= TRUE*/)
{
BOOL bIsLoadingWorld;
CString csName, csPrefix;
if (!m_fn_bCanBeAnAlways())
{
CString csMessage;
csMessage.Format("Actor %s cannot be set as always", GetName());
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Modifying Always Status of Actor",
"CPA_Actor::m_fn_vMakeAlways",
E_ERROR_GRAVITY_WARNING,
csMessage);
ERROR_ASSERT( FALSE );
}
else
{
if ( bIsAnAlways != m_bIsAnAlways )
{
m_bIsAnAlways = bIsAnAlways;
if ( m_bIsAnAlways )
{
//Adds it to the (internal) list of Always
g_pclInterface->m_clDocument.m_clAlwaysList.fn_bAddObject(this);
//Removes from Instances list
g_pclInterface->m_clDocument.m_clInstancesList.fn_bRemoveObject(this);
//ANNECY Shaitan RenameAlways (03.04.98) {
csPrefix = GetName().Left(4);
bIsLoadingWorld = g_pclInterface->GetInterface()->fn_bIsLoadingWorld();
if (!bIsLoadingWorld && (csPrefix.CompareNoCase("ALW_") != 0))
{
g_pclInterface->GetInterface()->SetLoadingWorld(TRUE);
// if necessary, remove user prefix, and set always prefix
if (csPrefix.Compare(g_pclInterface->GetInterface()->GetUserPrefix()) == 0)
csName = "ALW_" + GetName().Mid(4);
else
csName = "ALW_" + GetName();
// rename actor
while (fn_eRename(csName) != E_mc_None)
csName = csName + "1";
g_pclInterface->GetInterface()->SetLoadingWorld(bIsLoadingWorld);
}
//ENDANNECY Shaitan RenameAlways }
//Makes the motor modifications
if( !fn_ucIsAnAlwaysModel(m_fn_pclGetEditorActor()->m_fn_ptdstGetMotorActor()) )
{
fn_vAddAnAlwaysModel(m_fn_pclGetEditorActor()->m_fn_ptdstGetMotorActor());
//
fn_v3dDataInit(m_fn_pclGetEditorActor()->m_fn_ptdstGetMotorActor(), OTI_AlwaysCreated);
}
//Removes from hierarchy
if (!bIsLoadingWorld)
ERROR_VERIFY( g_pclInterface->GetInterface()->fn_bDeleteObjectInHierarchy(m_pub_fn_pclGetSuperObject(), FALSE) );
}
else
{
//Adds it to the (internal) list of Instances
g_pclInterface->m_clDocument.m_clInstancesList.fn_bAddObject(this);
//Removes from Always list
g_pclInterface->m_clDocument.m_clAlwaysList.fn_bRemoveObject(this);
//ANNECY Shaitan RenameAlways (03.04.98) {
csPrefix = GetName().Left(4);
bIsLoadingWorld = g_pclInterface->GetInterface()->fn_bIsLoadingWorld();
if (!bIsLoadingWorld && (csPrefix.Compare(g_pclInterface->GetInterface()->GetUserPrefix()) != 0))
{
g_pclInterface->GetInterface()->SetLoadingWorld(TRUE);
// if necessary, remove user prefix, and set always prefix
if (csPrefix.CompareNoCase("ALW_") == 0)
csName = g_pclInterface->GetInterface()->GetUserPrefix() + GetName().Mid(4);
else
csName = g_pclInterface->GetInterface()->GetUserPrefix() + GetName();
// rename actor
while (fn_eRename(csName) != E_mc_None)
csName = csName + "1";
g_pclInterface->GetInterface()->SetLoadingWorld(bIsLoadingWorld);
}
//ENDANNECY Shaitan RenameAlways }
//Removes from hierarchy
ERROR_VERIFY( g_pclInterface->GetInterface()->fn_bInsertObjectInHierarchy(m_pub_fn_pclGetSuperObject(), g_pclInterface->GetInterface()->GetSpecificInterface()->GetDynamicRoot(), FALSE) );
}
}
}
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsAnAlways()
{
return m_bIsAnAlways;
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bCanBeAnAlways()
{
if ( m_fn_bIsTheCurrentMotorCamera()
|| m_fn_bIsAPrincipalActor()
/*|| m_fn_bIsTheWorldActor()*/
/* || m_fn_bIsAGenDoor()*/
)
return FALSE;
if (!g_pclInterface->GetInterface()->fn_bIsLoadingWorld())
{
EdActors_EditorActorModel * pModel = m_fn_pclGetModel()->m_fn_pclGetEditorModel();
EdActors_EditorActorInstance * pInstance;
POSITION pos = pModel->m_clInstancesList.GetHeadPosition();
while (pos != NULL)
{
pInstance = pModel->m_clInstancesList.GetNext(pos);
if (pInstance->m_pclActor->m_fn_bIsAnAlways() && (pInstance->m_pclActor != this))
return FALSE;
}
}
return TRUE;
}
//******************************************************************************
//Get/Set for pointer on the SO isolated before engine mode
//Only useful for GenDoors type Actors
//******************************************************************************
CPA_SuperObject *CPA_Actor::m_fn_pclGetIsolatedSuperObject()
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Gets an isolated SuperObject",
"CPA_Actor::m_fn_pclGetIsolatedSuperObject(...)",
E_ERROR_GRAVITY_FATAL,
"Actor must be an Instance, but is a Model");
ERROR_ASSERT( m_fn_bIsAnInstance() );
return m_pclIsolatedSuperObject;
}
//******************************************************************************
void CPA_Actor::m_fn_vSetIsolatedSuperObject(CPA_SuperObject *pclNewIsolatedSO)
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Sets an isolated SuperObject",
"CPA_Actor::m_fn_vSetIsolatedSuperObject(...)",
E_ERROR_GRAVITY_FATAL,
"Actor must be an Instance, but is a Model");
ERROR_ASSERT( m_fn_bIsAnInstance() );
m_pclIsolatedSuperObject = pclNewIsolatedSO;
}
//******************************************************************************
void CPA_Actor::m_fn_vMakeGenDoor(BOOL bIsAGenDoor /*= TRUE*/)
{
m_bIsAGenDoor = bIsAGenDoor;
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsAGenDoor()
{
return m_bIsAGenDoor;
}
//Always active
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bIsAlwaysActive()
{
return m_pri_bIsAlwaysActive;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetAlwaysActive(BOOL _bAlwaysActive,
BOOL _bIsLoading /*= FALSE*/)
{
m_pri_bIsAlwaysActive = _bAlwaysActive;
//Notifies Level
if ( !_bIsLoading )
{
//Updates Motor
if ( m_pri_bIsAlwaysActive )
fn_vAddCharacterInAlwaysActiveCharacterList(m_pub_fn_hGetMotorSuperObject());
else
fn_vRemoveCharacterFromAlwaysActiveCharacterList(m_pub_fn_hGetMotorSuperObject());
//Notifies
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this, TRUE);
}
}
// ANNECY MT - 19/11/98 {
//In all SubMaps
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bIsInAllSubMaps()
{
return m_pri_bIsInAllSubMaps;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetInAllSubMaps(BOOL _bInAllSubMaps,
BOOL _bIsLoading /*= FALSE*/)
{
m_pri_bIsInAllSubMaps = _bInAllSubMaps;
//Notifies Level
if ( !_bIsLoading )
{
//Updates Motor
fn_vStdGameSetInAllSubMaps( M_GetMSHandle(m_pub_fn_hGetMotorSuperObject(), StandardGame) , m_pri_bIsInAllSubMaps);
//Notifies
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this, TRUE);
}
}
// END ANNECY MT }
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsTheCurrentMotorCamera()
{
// struct GLI_tdstCamera_ *p_stCamera;
return ( CAM_fn_hGetActiveCamera(CAM_e_MainViewport) == m_pub_fn_hGetMotorSuperObject() );
}
//******************************************************************************
BOOL CPA_Actor::m_fn_bIsAPrincipalActor()
{
return ( MC_fn_ucIsCharacterInMainCharacterList(m_pub_fn_hGetMotorSuperObject()) == 1 );
}
//******************************************************************************
/*BOOL CPA_Actor::m_fn_bIsTheWorldActor()
{
EdActors_ActorMiniStructure *pclWorldAMS = m_fn_pclGetEditorActor()->m_clListOfAMSLists.m_fn_pclGetAMSFromName("World");
if ( pclWorldAMS != NULL )
return (pclWorldAMS->m_fn_bIsAllocated());
else
return FALSE;
}*/
//******************************************************************************
void CPA_Actor::m_pub_fn_vAddChildsFromEngineChilds()
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, from engine objects",
"CPA_Actor::m_pub_fn_vAddChildsFromEngineChilds(...)",
E_ERROR_GRAVITY_FATAL,
"Actor must be an Instance, but is a Model");
ERROR_ASSERT( m_fn_bIsAnInstance() );
//Gets the motor SuperObject's childs, and creates the associated Editor objects
CPA_SuperObject *pclEdSo = m_pub_fn_pclGetSuperObject();
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, from engine objects",
"CPA_Actor::m_pub_fn_vAddChildsFromEngineChilds(...)",
E_ERROR_GRAVITY_FATAL,
"Actor has no Editor Super Object");
ERROR_ASSERT( pclEdSo != NULL );
//To respect Animation hierarchy
m_pri_fn_vBuildChildOfOneLevel(pclEdSo);
}
//******************************************************************************
void CPA_Actor::m_pri_fn_vBuildChildOfOneLevel(CPA_SuperObject *_pclEditorSoFather)
{
HIE_tdxHandleToSuperObject hMotorSOFather = (HIE_tdxHandleToSuperObject)_pclEditorSoFather->GetStruct();
long c_lI;
HIE_tdxHandleToSuperObject hChild;
HIE_M_ForEachChildOf(hMotorSOFather, hChild, c_lI)
{
CPA_SuperObject *pclNewModule = NULL;
if ( hChild->ulTypeOfLinkedObject == HIE_C_ulPO )
{
POInterface *p_oPODLL = (POInterface *)GetMainWorld()->GetObjectDLLWithName(C_szDLLPhysicalObjectName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding a module child to Actor, from engine objects",
"CPA_Actor::m_pri_fn_vBuildChildOfOneLevel(...)",
E_ERROR_GRAVITY_FATAL,
"Physical Objects DLL has not been found");
ERROR_ASSERT( p_oPODLL != NULL );
pclNewModule = p_oPODLL->GetNewEditorInstance( hChild );
pclNewModule->SetTypeSO(C_Protected);
}
else if ( hChild->ulTypeOfLinkedObject == HIE_C_ulSuperObject )
{
pclNewModule = g_pclInterface->GetInterface()->GetNewSuperObject( hChild,
E_ss_NoSave,
C_Protected,
"",
"");
}
if ( pclNewModule != NULL )
{
//Adds graphical SuperObject as Actor's child
_pclEditorSoFather->AddTail(pclNewModule, FALSE);
//Indicates that Module is Actor's property
//Modified by YB for Alexis (31/10/97)
pclNewModule->SetSuperObjectOwner(m_pub_fn_pclGetSuperObject());
//pclNewModule->SetSuperObjectOwner(_pclEditorSoFather);
pclNewModule->SetEditProtected(TRUE);
//Recursively adding curent father's childs
m_pri_fn_vBuildChildOfOneLevel(pclNewModule);
}
}
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vAddChildsForGenDoors()
{
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, for a Gen Doors type object",
"CPA_Actor::m_pub_fn_vAddChildsForGenDoors(...)",
E_ERROR_GRAVITY_FATAL,
"Actor must be an Instance, but is a Model");
ERROR_ASSERT( m_fn_bIsAnInstance() );
//Loads the ".MOD"
CString csModFileName = ((EdActors_EditorActorModel *)m_fn_pclGetModel()->m_fn_pclGetEditorActor())->m_fn_csGetBitmapName();
csModFileName = csModFileName.Left(csModFileName.GetLength() - 3) + "mod";
csModFileName = CString("EDT_Data\\") + g_pclInterface->m_clDocument.m_csModelsBitmapsPathForGenDoors + csModFileName;
//Loads the motor geometric object
SCR_tdst_Cxt_Values *p_stValues;
p_stValues = SCR_fnp_st_RdL0_AnalyseSection((char *)LPCTSTR(csModFileName),
SCR_CDF_uw_Anl_Normal);
GLI_tdstGeometricInfo *p_xGeometricInFile = (GLI_tdstGeometricInfo *)p_stValues->a_ulValues[0];
void *p_vMotorGeometricModuleLoaded = (void *)p_xGeometricInFile->hObject;
//Creates the editor Object and SO
CPA_ObjectDLLBase *p_cl3DGeomDLL = GetMainWorld()->GetObjectDLLWithName(C_szDLLGeometryName);
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, for a Gen Doors type object",
"CPA_Actor::m_pub_fn_vAddChildsForGenDoors(...)",
E_ERROR_GRAVITY_FATAL,
"3DGeom DLL can't be found");
ERROR_ASSERT( p_cl3DGeomDLL != NULL );
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, for a Gen Doors type object",
"CPA_Actor::m_pub_fn_vAddChildsForGenDoors(...)",
E_ERROR_GRAVITY_FATAL,
"The motor Geometric object for a Gen Door is not correct");
ERROR_ASSERT( p_vMotorGeometricModuleLoaded != NULL );
long lReturnedValue = p_cl3DGeomDLL->OnQueryAction( g_pclInterface,
(WPARAM)C_uiCreateGeometricObject,
(LPARAM)p_vMotorGeometricModuleLoaded);
Geometry3D *pclGeometricObject = (Geometry3D *)lReturnedValue;
ERROR_PREPARE_M(g_c_csActorModuleNameForErrors,
"Adding childs to Actor, for a Gen Doors type object",
"CPA_Actor::m_pub_fn_vAddChildsForGenDoors(...)",
E_ERROR_GRAVITY_FATAL,
"The Geometric object for a Gen Door is not correctly loaded");
ERROR_ASSERT( pclGeometricObject != NULL );
// pclGeometricObject->fn_bSetResponsibilityLevel(CPA_NoModif);
CPA_SuperObject *pclNewModule = g_pclInterface->GetInterface()->GetNewSuperObject(E_ss_NoSave,
C_Protected,
"",
"");
pclNewModule->SetObject(pclGeometricObject);
CPA_SuperObject *pclEdSo = m_pub_fn_pclGetSuperObject();
//Adds SuperObject as Actor's child
pclEdSo->AddTail(pclNewModule/*, FALSE*/);
//Indicates that Module is Actor's property
pclNewModule->SetSuperObjectOwner(pclEdSo);
pclNewModule->SetEditProtected(TRUE);
//Internal
m_fn_vSetIsolatedSuperObject(pclNewModule);
}
//******************************************************************************
//To remove editor childs
void CPA_Actor::m_pub_fn_vRemoveAllEditorChilds()
{
//Inits the recursive suppression
m_pri_fn_vRemoveAllChildsForOneSO(m_pclSuperObject);
}
//******************************************************************************
//To remove (recursively) editor childs of one SuperObject
void CPA_Actor::m_pri_fn_vRemoveAllChildsForOneSO(CPA_SuperObject *_pclEditorSoFather)
{
//Removes all childs...
CPA_SuperObject *pclCurrentEditorChild = _pclEditorSoFather->GetSuperObjectFirstChild();
CPA_SuperObject *pclNextEditorChild = pclCurrentEditorChild;
while ( pclNextEditorChild != NULL )
{
//Gets next before Isolate
pclNextEditorChild = _pclEditorSoFather->GetSuperObjectNextChild(pclCurrentEditorChild);
//Removes childs
m_pri_fn_vRemoveAllChildsForOneSO(pclCurrentEditorChild);
//Removes from Editor SO Childs
pclCurrentEditorChild->Isolate(FALSE);
pclCurrentEditorChild->fn_bUnValidate();
pclCurrentEditorChild = pclNextEditorChild;
}
}
//******************************************************************************
//To compare the two hierarchies (motor and editor) when back from motor mode
// returns TRUE only if hierarchies are the same
BOOL CPA_Actor::m_pub_fn_bCompareEditorAndMotorChilds()
{
//Inits recursive comparison
return ( m_pri_fn_bCompareOneLevelOfEditorAndMotorChilds(m_pclSuperObject));
}
//******************************************************************************
//To compare (recursively) editor and motor childs of ONE SuperObject
BOOL CPA_Actor::m_pri_fn_bCompareOneLevelOfEditorAndMotorChilds(CPA_SuperObject *_pclFatherSO)
{
BOOL bReturn = TRUE;
HIE_tdxHandleToSuperObject hMotorSO = (HIE_tdxHandleToSuperObject)_pclFatherSO->GetStruct();
CPA_SuperObject *pclCurrentEditorChild;
long c_lI;
HIE_tdxHandleToSuperObject hMotorChild;
HIE_tdxHandleToSuperObject hEditorChild;
pclCurrentEditorChild = _pclFatherSO->GetSuperObjectFirstChild();
HIE_M_ForEachChildOf(hMotorSO, hMotorChild, c_lI)
{
//Compares to Editor SO
if ( pclCurrentEditorChild != NULL )
{
hEditorChild = (HIE_tdxHandleToSuperObject)pclCurrentEditorChild->GetStruct();
if ( ( hEditorChild != hMotorChild )
|| ( hMotorChild->ulTypeOfLinkedObject != pclCurrentEditorChild->GetObjectType() )
)
//At least one child is different
bReturn = FALSE;
}
else
//There are more childs for Motor Actor
bReturn = FALSE;
bReturn = ( bReturn && m_pri_fn_bCompareOneLevelOfEditorAndMotorChilds(pclCurrentEditorChild) );
pclCurrentEditorChild = _pclFatherSO->GetSuperObjectNextChild(pclCurrentEditorChild);
}
if ( pclCurrentEditorChild != NULL )
//There are more childs in Editor SO
bReturn = FALSE;
return bReturn;
}
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bCanBeRenamed()
{
return ( /*( !m_fn_bIsAModel() ) //No Model can be renamed
&&*/ ( !m_fn_bIsTheCurrentMotorCamera() )
&& ( !m_fn_bIsAPrincipalActor() )
/*&& ( !m_fn_bIsTheWorldActor() )*/
);
}
//Object Tables
//******************************************************************************
CTL_Editor_EnumDescriptor *CPA_Actor::m_pub_fn_pclGetEnumDescriptorForObjectsTables()
{
return m_fn_pclGetEditorActor()->m_pub_fn_pclGetEnumDescriptorForObjectsTables();
}
//******************************************************************************
EditorObjectTable *CPA_Actor::m_pub_fn_pclGetCurrentObjectTable()
{
return m_pri_pclCurrentObjectTable;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetCurrentObjectTable(EditorObjectTable *pclNewOT)
{
m_pri_pclCurrentObjectTable = pclNewOT;
}
//******************************************************************************
EditorObjectTable *CPA_Actor::m_pub_fn_pclGetInitialObjectTable()
{
return m_pri_pclInitialObjectTable;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetInitialObjectTable(EditorObjectTable *pclNewOT)
{
// Shaitan => optimisation lists in the level
// set modification flag in the corresponding family
if (m_pri_pclInitialObjectTable && (pclNewOT != m_pri_pclInitialObjectTable))
((CPA_Family *) pclNewOT->GetOwner())->mfn_vSetModifiedPOList();
// End Shaitan => optimisation lists in the level
m_pri_pclInitialObjectTable = pclNewOT;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vConstructEnumDescriptorForObjectsTables()
{
if ( m_pub_fn_pclGetFamily() != NULL )
{
ERROR_ASSERT(m_pub_fn_pclGetEnumDescriptorForObjectsTables() != NULL);
//First adds the OT which has the Family's name...
short wIndex;
BOOL bFound = FALSE;
EditorObjectTable *pclCurrentOT;
POSITION pos = m_pub_fn_pclGetFamily()->m_oListOfObjectTables.GetHeadPosition();
while ( (pos != NULL) && (!bFound) )
{
pclCurrentOT = m_pub_fn_pclGetFamily()->m_oListOfObjectTables.GetNext(pos);
//Searches for Family name
CString csOTName = pclCurrentOT->GetName();
wIndex = csOTName.Find('.');
if ( wIndex != -1 )
csOTName = csOTName.Left(wIndex);
bFound = ( csOTName.CompareNoCase(m_pub_fn_pclGetFamily()->GetName()) == 0 );
}
if ( bFound )
m_pub_fn_pclGetEnumDescriptorForObjectsTables()->m_fn_pclAddElement(pclCurrentOT->GetName(), (long)pclCurrentOT->GetData());
//...then adds the other OT
pos = m_pub_fn_pclGetFamily()->m_oListOfObjectTables.GetHeadPosition();
while ( pos != NULL )
{
pclCurrentOT = m_pub_fn_pclGetFamily()->m_oListOfObjectTables.GetNext(pos);
//Searches for Family name
CString csOTName = pclCurrentOT->GetName();
wIndex = csOTName.Find('.');
if ( wIndex != -1 )
csOTName = csOTName.Left(wIndex);
if ( csOTName.CompareNoCase(m_pub_fn_pclGetFamily()->GetName()) != 0 )
m_pub_fn_pclGetEnumDescriptorForObjectsTables()->m_fn_pclAddElement(pclCurrentOT->GetName(), (long)pclCurrentOT->GetData());
}
//Add a reference for NULL Object Table
if ( m_pub_fn_pclGetEnumDescriptorForObjectsTables()->GetCount() == 0 )
m_pub_fn_pclGetEnumDescriptorForObjectsTables()->m_fn_pclAddElement("No Object Table", 0L);
}
}
//Action
//******************************************************************************
CPA_Action *CPA_Actor::m_pub_fn_pclGetCurrentAction()
{
return m_pri_pclCurrentAction;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetCurrentAction(CPA_Action *_pclNewAction)
{
m_pri_pclCurrentAction = _pclNewAction;
}
//******************************************************************************
CPA_Action *CPA_Actor::m_pub_fn_pclGetInitialAction()
{
return m_pri_pclInitialAction;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetInitialAction(CPA_Action *_pclNewAction)
{
// Shaitan => optimisation lists in the level
// set modification flag in the corresponding family
if (m_pri_pclInitialAction && (_pclNewAction != m_pri_pclInitialAction))
((CPA_Family *) _pclNewAction->GetOwner())->mfn_vSetModifiedStateList();
// End Shaitan => optimisation lists in the level
m_pri_pclInitialAction = _pclNewAction;
}
//State
//******************************************************************************
CPA_State *CPA_Actor::m_pub_fn_pclGetCurrentState()
{
return m_pri_pclCurrentState;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetCurrentState(CPA_State *_pclNewState)
{
m_pri_pclCurrentState = _pclNewState;
if ( ( m_fn_bIsAnInstance() )
&& ( _pclNewState != NULL )
&& ( !(g_pclInterface->GetInterface()->fn_bIsLoadingWorld()) )
)
{
tdxHandleToState hDefaultState = (tdxHandleToState)_pclNewState->GetData();
if ( ( hDefaultState != NULL ) && ( M_bEditorsActive() ) )
{
fn_v3dDataSetCurrentState(M_GetMSHandle(m_pub_fn_hGetMotorSuperObject(), 3dData), hDefaultState);
// PLA_fn_vInitNewState( m_pub_fn_hGetMotorSuperObject(),
// hDefaultState);
}
}
}
//******************************************************************************
CPA_State *CPA_Actor::m_pub_fn_pclGetInitialState()
{
return m_pri_pclInitialState;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetInitialState(CPA_State *_pclNewState,
BOOL _bMustNotifyLevel /*= FALSE*/)
{
m_pri_pclInitialState = _pclNewState;
//Notifies Level when initial state has been changed
if ( ( _bMustNotifyLevel )
&& ( m_fn_bIsAnInstance() )
&& ( !(g_pclInterface->GetInterface()->fn_bIsLoadingWorld()) )
)
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this);
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vUpdateObjectTablesList(EditorObjectTable *pclOT /* NULL*/)
{
if ( pclOT != NULL )
{
CTL_Editor_EnumElement *pclCurrentElement;
POSITION pos = m_pub_fn_pclGetEnumDescriptorForObjectsTables()->GetHeadPosition();
while ( pos != NULL )
{
pclCurrentElement = m_pub_fn_pclGetEnumDescriptorForObjectsTables()->GetNext(pos);
if ( pclCurrentElement->m_pub_fn_csGetElementName() == pclOT->GetName() )
pclCurrentElement->m_pub_fn_vSetValue((long)pclOT->GetData());
}
}
}
//******************************************************************************
HIE_tdxHandleToSuperObject CPA_Actor::m_pub_fn_hGetMotorSuperObject()
{
ERROR_ASSERT( m_fn_bIsAnInstance() );
if ( m_pclSuperObject != NULL )
return (HIE_tdxHandleToSuperObject)m_pclSuperObject->GetData();
else
{
//Tries to get Motor Super Object from Motor data
MS_tdxHandleToStandardGame h_StdGame = ((struct tdstEngineObject_ *)GetData())->h_StandardGame;
HIE_tdxHandleToSuperObject hHandleToReturn = fn_h_StandardGameGetSuperObject(h_StdGame);
return hHandleToReturn;
}
}
//******************************************************************************
CPA_SuperObject *CPA_Actor::m_pub_fn_pclGetSuperObject()
{
return m_pclSuperObject;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetSuperObject(CPA_SuperObject *pclNewSO)
{
m_pclSuperObject = pclNewSO;
}
//******************************************************************************
CPA_Family *CPA_Actor::m_pub_fn_pclGetFamily()
{
return m_pri_pclFamily;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetFamily(CPA_Family *pclNewFamily)
{
if ( ( m_pri_pclFamily == NULL ) && ( pclNewFamily != NULL ) )
{
m_pri_pclFamily = pclNewFamily;
//For a Model, sets the Family as Model's owner
if ( !m_fn_bIsAnInstance() )
fn_bSetOwner((CPA_SaveObject *)pclNewFamily);
//For Object Tables edition
if ( pclNewFamily->fn_bIsAvailable() )
m_pub_fn_vConstructEnumDescriptorForObjectsTables();
//Updates section name
SetReferencedSectionName(m_pri_fn_csComputeReferencedSectionName());
if ( m_pclSectionSubObject != NULL )
m_pclSectionSubObject->SetReferencedSectionName(m_pri_fn_csComputeReferencedFileName());
}
}
/*//******************************************************************************
//Returns the name of a Designer Variable, knowing its ID
// ... For IAD ...
CString CPA_Actor::m_pub_fn_csGetDsgVarNameFromID(long _lID)
{
//-----------------IR-------------------------
ERROR_ASSERT( m_fn_bIsAnInstance() );
return m_fn_pclGetModel()->m_fn_pclGetEditorModel()->m_pclBrain->m_fn_csGetDsgVarName(_lID);
#else
return "Error in OAc (-->YB)";
//--------------------------------------------
}
//******************************************************************************
//Displays the IA editor with the good behaviour
// ... For IAD ...
void CPA_Actor::m_pub_fn_vShowBehaviour(struct tdstNodeInterpret_ *_pstNode)
{
//-----------------IR-------------------------
ERROR_ASSERT( m_fn_bIsAnInstance() );
m_fn_pclGetModel()->m_fn_pclGetEditorModel()->m_pclBrain->m_fn_vShowBehaviour(_pstNode);
//--------------------------------------------
}*/
//******************************************************************************
CPA_tdoNameList *CPA_Actor::m_pub_fn_pclGetNameList(CString _csName)
{
return m_fn_pclGetEditorActor()->m_fn_p_oGetNameList(_csName);
}
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bCanBeInstantiated()
{
ERROR_ASSERT( m_fn_bIsAModel() );
return ( TRUE/*!m_fn_bIsTheWorldActor()*/ );
}
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bIsCommon()
{
ERROR_ASSERT( m_fn_bIsAnInstance() );
return m_pri_bIsCommon;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetCommon(BOOL _bCommon /*= TRUE*/,
BOOL _bIsLoading /*= FALSE*/)
{
ERROR_ASSERT( m_fn_bIsAnInstance() );
if ( m_pri_bIsCommon != _bCommon )
{
//Notifies previous Section
if ( !_bIsLoading )
fn_vNotifyUnSave();
//Changes section name
m_pri_bIsCommon = _bCommon;
if ( m_pclSectionSubObject != NULL )
m_pclSectionSubObject->SetReferencedSectionName(m_pri_fn_csComputeReferencedFileName());
fn_vUpdateSectionName();
//Notifies new Section
if ( !_bIsLoading )
fn_vNotifySave();
if ( !_bIsLoading )
{
g_pclInterface->m_clDocument.m_fn_vNotifyLevel(this, TRUE);
//An actor which is not in Common cannot be in Fix
if ( !m_pri_bIsCommon )
{
if ( m_pub_fn_bIsInFix() )
m_pub_fn_vSetInFix(FALSE);
}
}
}
}
//
//******************************************************************************
BOOL CPA_Actor::m_pub_fn_bIsInFix()
{
ERROR_ASSERT( m_fn_bIsAnInstance() );
return m_pri_bIsInFix;
}
//******************************************************************************
void CPA_Actor::m_pub_fn_vSetInFix(BOOL _bIsInFix /*= TRUE*/,
BOOL _bIsLoading /*= FALSE*/)
{
ERROR_ASSERT( m_fn_bIsAnInstance() );
if ( m_pri_bIsInFix != _bIsInFix )
{
//Changes and notifies new section
m_pri_bIsInFix = _bIsInFix;
//Notifies FIX file
if ( !_bIsLoading )
g_pclInterface->m_clDocument.m_fn_vNotifyFixFile();
}
}
//******************************************************************************
//Returns the number of Instances of a Model, and -1 for an Instance
long CPA_Actor::m_pub_fn_lGetNumberOfInstances()
{
long lValueToReturn = -1;
if ( m_fn_bIsAModel() )
lValueToReturn = m_fn_pclGetEditorModel()->m_clInstancesList.GetCount();
return lValueToReturn;
}
//******************************************************************************
//Checks Model before Instanciation
BOOL CPA_Actor::m_pub_fn_bCheckModelForInstanciation()
{
BOOL bReturn = TRUE;
if ( m_fn_bIsAModel() )
{
if ( !m_fn_bIsAGenDoor() )
{
CString csMessage;
CString csAction = "Instanciation of Model '";
csAction += GetName() + "'\n";
//Checks the Initial Action of the Model
if ( m_pub_fn_pclGetInitialAction() == NULL )
{
csMessage = csAction + "This Model has no Initial Action !\n(Check this in Group_1 >> 3dData MS)\nDo you want to continue anyway ?";
EdActors_QuestionDialog QuestionDial(&g_oBaseFrame, csMessage);
bReturn = ( QuestionDial.DoModal() == IDYES );
}
//Checks the Initial state of the Model
else
{
if ( m_pub_fn_pclGetInitialAction()->m_p_oDefaultState == NULL )
{
csMessage = csAction + "This Model has no Initial State !\n(Check this in Group_1 >> 3dData MS)\nDo you want to continue anyway ?";
EdActors_QuestionDialog QuestionDial(&g_oBaseFrame, csMessage);
bReturn = ( QuestionDial.DoModal() == IDYES );
}
}
//Checks the Initial Objects Table of the Model
if ( bReturn )
{
if ( m_pub_fn_pclGetInitialObjectTable() == NULL )
{
csMessage = csAction + "This Model has no Initial Object Table !\n(Check this in Group_1 >> 3dData MS)\nDo you want to continue anyway ?";
EdActors_QuestionDialog QuestionDial(&g_oBaseFrame, csMessage);
bReturn = ( QuestionDial.DoModal() == IDYES );
}
}
}
}
else
bReturn = FALSE;
return bReturn;
}
//******************************************************************************
//Indicates whether this Actor must be saved or not
BOOL CPA_Actor::m_pub_fn_bHasBeenModified()
{
return m_pri_bHasBeenModified;
}
//******************************************************************************
//To re-init the Actor as if it was in its intial state
void CPA_Actor::m_pub_fn_vReInitActor()
{
}
//******************************************************************************
CString CPA_Actor::fn_csComputeReferencedSectionName(const CString csNewName)
{
return m_pri_fn_csComputeReferencedSectionName(csNewName);
}
//******************************************************************************
CString CPA_Actor::m_pri_fn_csComputeReferencedSectionName(CString csName /*= ""*/,
CPA_Family *pclFamily /*= NULL*/)
{
CString csUsedName = ( csName.IsEmpty() ) ? GetName() : csName;
CPA_Family *pclUsedFamily = ( pclFamily == NULL ) ? m_pub_fn_pclGetFamily() : pclFamily;
CString csFamilyName = ( pclUsedFamily == NULL ) ? "No_Family" : pclUsedFamily->GetName();
CString csFileName;
if ( m_fn_bIsAnInstance() )
csFileName = csUsedName + g_csInstanceExtension;
else
csFileName = csUsedName + g_csModelExtension;
CString csTrueFileName;
if ( m_fn_bIsAnInstance() )
{
if ( m_pub_fn_bIsCommon() )
csTrueFileName = CString("_Common\\Families\\")
+ csFamilyName
+ s_g_c_csAntiSlash
+ m_fn_pclGetModel()->GetName()
+ s_g_c_csAntiSlash + C_ScriptCharacterDirectory
+ s_g_c_csAntiSlash + csFileName;
else
csTrueFileName = g_pclInterface->m_clDocument.m_fn_csGetLevelName()
+ s_g_c_csAntiSlash
+ CString("Families\\")
+ csFamilyName
+ s_g_c_csAntiSlash
+ m_fn_pclGetModel()->GetName()
+ s_g_c_csAntiSlash + C_ScriptCharacterDirectory
+ s_g_c_csAntiSlash + csFileName;
}
else
csTrueFileName = CString("_Common\\Families\\")
+ csFamilyName
+ s_g_c_csAntiSlash
+ csUsedName
+ s_g_c_csAntiSlash
+ csFileName;
CString csAction;
if ( m_fn_bIsAnInstance() )
csAction = C_SectionOneCharacters;
else
csAction = g_c_csActorScriptModelSectionName;
CString csReferencedSectioName = csTrueFileName + '^' + csAction + ':' + csUsedName;
return csReferencedSectioName;
}
//******************************************************************************
CString CPA_Actor::m_pri_fn_csComputeCompleteSectionName(CString csName /*= ""*/,
CPA_Family *pclFamily /*= NULL*/)
{
CString csUsedName = ( csName.IsEmpty() ) ? GetName() : csName;
CPA_Family *pclUsedFamily = ( pclFamily == NULL ) ? m_pub_fn_pclGetFamily() : pclFamily;
CString csFamilyName = ( pclUsedFamily == NULL ) ? "No_Family" : pclUsedFamily->GetName();
CString csFileName;
if ( m_fn_bIsAnInstance() )
csFileName = csUsedName + g_csInstanceExtension;
else
csFileName = csUsedName + g_csModelExtension;
CString csTrueFileName;
if ( m_fn_bIsAnInstance() )
csTrueFileName = g_pclInterface->m_clDocument.m_pub_csLevelDataPath
+ m_pri_fn_csComputeReferencedSectionName(csUsedName, pclUsedFamily);
else
csTrueFileName = g_pclInterface->m_clDocument.m_pub_csCommonDataPath
+ m_pri_fn_csComputeReferencedSectionName(csUsedName, pclUsedFamily);
CString csAction;
if ( m_fn_bIsAnInstance() )
csAction = C_SectionOneCharacters;
else
csAction = g_c_csActorScriptModelSectionName;
CString csCompleteSectioName = csTrueFileName + '^' + csAction + ':' + csUsedName;
return csCompleteSectioName;
}
//******************************************************************************
CString CPA_Actor::m_pri_fn_csComputeCompleteFileName(void)
{
CString csFileName = m_pri_fn_csComputeCompleteSectionName();
//Extracts File Name
short wIndex = csFileName.Find('^');
if ( wIndex != -1 )
csFileName = csFileName.Left(wIndex);
return csFileName;
}
//******************************************************************************
CString CPA_Actor::m_pri_fn_csComputeReferencedFileName(void)
{
CString csFileName = m_pri_fn_csComputeReferencedSectionName();
//Extracts File Name
short wIndex = csFileName.Find('^');
if ( wIndex != -1 )
csFileName = csFileName.Left(wIndex);
return csFileName;
}
//For Save
//******************************************************************************
void CPA_Actor::fn_vNotifySave(void)
{
if ( m_pclSectionSubObject != NULL )
{
m_pclSectionSubObject->fn_vWriteSection();
if ( !m_pri_bHasBeenModified )
{
m_pri_bHasBeenModified = TRUE;
g_pclInterface->m_clDocument.m_pclActorsView->m_pub_fn_vUpdateActorNameForModif(this);
}
}
}
//******************************************************************************
void CPA_Actor::fn_vNotifyUnSave(void)
{
if ( m_pclSectionSubObject != NULL )
{
m_pclSectionSubObject->fn_vDeleteSection();
if ( m_pri_bHasBeenModified )
{
m_pri_bHasBeenModified = FALSE;
g_pclInterface->m_clDocument.m_pclActorsView->m_pub_fn_vUpdateActorNameForModif(this);
}
}
}
//******************************************************************************
void CPA_Actor::fn_vNotifyRestore(void)
{
if ( m_pclSectionSubObject != NULL )
{
m_pclSectionSubObject->fn_vRestoreSection();
if ( !m_pri_bHasBeenModified )
{
m_pri_bHasBeenModified = TRUE;
g_pclInterface->m_clDocument.m_pclActorsView->m_pub_fn_vUpdateActorNameForModif(this);
}
}
}
//******************************************************************************
void CPA_Actor::fn_vNotifyRename(void)
{
if ( m_pclSectionSubObject != NULL )
{
m_pclSectionSubObject->fn_vRenameSection(m_pri_fn_csComputeReferencedFileName());
if ( !m_pri_bHasBeenModified )
{
m_pri_bHasBeenModified = TRUE;
g_pclInterface->m_clDocument.m_pclActorsView->m_pub_fn_vUpdateActorNameForModif(this);
}
}
//Update of main section name
SetReferencedSectionName(m_pri_fn_csComputeReferencedSectionName());
}
//******************************************************************************
void CPA_Actor::s_m_fn_vCallBackSaveActor(SCR_tdst_File_Description *_p_stFile,
char *_p_szSectionName,
void *_p_vData,
SCR_tde_Ntfy_Action _eAction)
{
CPA_Actor *p_clActor = (CPA_Actor *)_p_vData ;
switch ( _eAction )
{
case SCR_EA_Ntfy_AddSection:
case SCR_EA_Ntfy_AddOrModifySection:
case SCR_EA_Ntfy_AddOrRebuildSection:
case SCR_EA_Ntfy_RebuildSection:
case SCR_EA_Ntfy_ModifySection:
if ( p_clActor == NULL )
{
//Saves Motor Level
g_pclInterface->m_clDocument.m_fn_vSaveMotorLevel(_p_stFile, _p_szSectionName, _eAction);
}
else
{
//Saves Model
if ( p_clActor->m_fn_bIsAModel() )
{
//...
p_clActor->m_fn_pclGetEditorActor()->m_fn_vSaveActor(_p_stFile);
}
else
//For Instances, saves only motor Actor (in Motor File)
{
//Calls motor function
g_pclInterface->m_clDocument.m_fn_vSaveMotorInstance(_p_stFile, p_clActor);
}
p_clActor->m_pclSectionSubObject->fn_vSectionSaved();
}
break ;
case SCR_EA_Ntfy_DeleteIfExists:
case SCR_EA_Ntfy_DeleteSection:
if ( p_clActor != NULL )
p_clActor->m_pclSectionSubObject->fn_vSectionDeleted();
}
if ( p_clActor != NULL )
{
p_clActor->m_pri_bHasBeenModified = FALSE;
g_pclInterface->m_clDocument.m_pclActorsView->m_pub_fn_vUpdateActorNameForModif(p_clActor);
}
}
//******************************************************************************
//Virtual functions
//******************************************************************************
long CPA_Actor::GetDataType()
{
return HIE_C_ulActor;
}
//******************************************************************************
void *CPA_Actor::GetData()
{
return GetStruct();
}
// Shaitan Correction {
//******************************************************************************
void CPA_Actor::fn_vSetExistingSectionSubObject (BOOL bExist)
{
m_pclSectionSubObject->SetExistingSection(bExist);
}
//End Shaitan Correction }
//BEGIN ROMTEAM Cristi Petrescu 98-05-
/*
CPA_EdIR_DebugInfo *CPA_Actor::m_fn_pGetDebugInfo (tdstNodeInterpret *_pstNode)
{
EdActors_EditorActorModel *pModel = m_fn_pclGetEditorModel ();
ASSERT (pModel);
CPA_EdIR_Brain *pBrain = pModel -> m_pclBrain;
ASSERT (pBrain);
return pBrain -> m_clDebugInfoList . m_fn_pclGetDebugInfo (_pstNode);
}*/
//******************************************************************************
void CPA_Actor::m_fn_vMustBuildDebugInfo (BOOL bBuild)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = & bBuild;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_MustBuildDebugInfo, (long) (& stCom));
}
}
//******************************************************************************
CString CPA_Actor::m_fn_csGetBehaviourName (tdstNodeInterpret *_pstNode)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = _pstNode;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_GetBehaviourName, (long) (& stCom));
return stCom . csData;
}
return _T("");
}
//******************************************************************************
void CPA_Actor::m_fn_vClearExecutedNodes (CString csBehaviourName)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = & csBehaviourName;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_ClearExecutedNodes, (long) (& stCom));
}
}
//******************************************************************************
void CPA_Actor::m_fn_vSetOneExecutedNode (tdstNodeInterpret *_pstNode)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = _pstNode;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_SetOneExecutedNode, (long) (& stCom));
}
}
//******************************************************************************
void CPA_Actor::m_fn_vShowBehaviour (tdstNodeInterpret *_pstNode)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = _pstNode;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_ShowBehaviourByEngineNode, (long) (& stCom));
}
}
//******************************************************************************
void CPA_Actor::m_fn_vShowBehaviour (CString csBehaviourName)
{
CPA_DLLBase *pclIADLL=(CPA_DLLBase*)(g_pclInterface->GetMainWorld()->GetToolDLLWithName(C_szDLLAIEditorName));
if(pclIADLL!=NULL)
{
tdstActorsIACom stCom;
stCom.pvThis = this;
stCom.pvData = & csBehaviourName;
pclIADLL -> OnQueryAction (g_pclInterface, C_uiAI_ShowBehaviourByName, (long) (& stCom));
}
}
//END ROMTEAM Cristi Petrescu 98-05-
//******************************************************************************
void CPA_Actor::m_fn_vSetModelDefaultValues (void)
{
EdActors_EditorActorModel * pclEditorModel;
CTL_Editor_BooleanData * pclBooleanData;
CTL_Editor_IntegerData * pclIntegerData;
// check if it is a model
if (!m_fn_bIsAModel())
return;
pclEditorModel = m_fn_pclGetEditorModel();
// set default values for hit points
pclIntegerData = (CTL_Editor_IntegerData *) pclEditorModel->m_fn_p_oFindDataByName("Initial_Hit_Points");
pclIntegerData->mfn_lSetCurrentValue (3);
pclIntegerData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
pclIntegerData = (CTL_Editor_IntegerData *) pclEditorModel->m_fn_p_oFindDataByName("Initial_Hit_Points_Max");
pclIntegerData->mfn_lSetCurrentValue (3);
pclIntegerData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
pclIntegerData = (CTL_Editor_IntegerData *) pclEditorModel->m_fn_p_oFindDataByName("Hit_Points_Max_Max");
pclIntegerData->mfn_lSetCurrentValue (3);
pclIntegerData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
// set default values for transparency zone
pclIntegerData = (CTL_Editor_IntegerData *) pclEditorModel->m_fn_p_oFindDataByName("Transparency_Zone_Min");
pclIntegerData->mfn_lSetCurrentValue (20);
pclIntegerData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
pclIntegerData = (CTL_Editor_IntegerData *) pclEditorModel->m_fn_p_oFindDataByName("Transparency_Zone_Max");
pclIntegerData->mfn_lSetCurrentValue (30);
pclIntegerData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
// set default values for custom bits
pclBooleanData = (CTL_Editor_BooleanData *) pclEditorModel->m_fn_p_oFindDataByName("Initial_CustomBit_1");
pclBooleanData->mfn_bSetCurrentState (TRUE);
pclBooleanData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
pclBooleanData = (CTL_Editor_BooleanData *) pclEditorModel->m_fn_p_oFindDataByName("Initial_CustomBit_13");
pclBooleanData->mfn_bSetCurrentState (TRUE);
pclBooleanData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
pclBooleanData = (CTL_Editor_BooleanData *) pclEditorModel->m_fn_p_oFindDataByName("Initial_CustomBit_22");
pclBooleanData->mfn_bSetCurrentState (TRUE);
pclBooleanData->m_fn_vUpdateMotorData(CTL_UPDATE_REASON__DATA_MODIFIED_BY_USER, 0);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vSaveToINI
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void CPA_Actor::mfn_vSaveToINI ()
{
if (!m_fn_bIsAModel())
return;
CString csKeyValue = m_bHideVariable? "TRUE":"FALSE";
CString csINIFileName = M_GetMainApp()->m_csEditorDataPath + m_csINIFileName;
WritePrivateProfileString (m_csHideVariableSection, GetName (), csKeyValue, csINIFileName);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vLoadFromINI
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void CPA_Actor::mfn_vLoadFromINI ()
{
if (!m_fn_bIsAModel())
return;
char szKeyValue [10];
CString csINIFileName = M_GetMainApp()->m_csEditorDataPath + m_csINIFileName;
GetPrivateProfileString (m_csHideVariableSection, GetName (), "FALSE", szKeyValue, sizeof (szKeyValue), csINIFileName);
if (szKeyValue == CString ("TRUE"))
m_bHideVariable = TRUE;
else
m_bHideVariable = FALSE;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_bIsHideVarChecked
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPA_Actor::mfn_bIsHideVarChecked ()
{
if (m_fn_bIsAModel())
return m_bHideVariable;
else
{
CPA_Actor *pModel = m_fn_pclGetModel();
if (pModel)
return pModel->mfn_bIsHideVarChecked ();
else
return FALSE;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : mfn_vCheckHideVar
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
void CPA_Actor::mfn_vCheckHideVar (BOOL bHideVar)
{
if (m_fn_bIsAModel())
{
m_bHideVariable = bHideVar;
mfn_vSaveToINI ();
}
else
{
CPA_Actor *pModel = m_fn_pclGetModel();
if (pModel)
pModel->mfn_vCheckHideVar (bHideVar);
else
TRACE0 ("This actor doesn't have a model!\n");
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Method : fn_eCheckValidity
// Date : 98-06
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Description :
// Author : Stegaru Cristian - CPA
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Modification :
// Date :
// By :
//////////////////////////////////////////////////////////////////////////////////////////////////////
tdeMissingCriteria CPA_Actor::fn_eCheckValidity (const CString csNewName)
{
tdeMissingCriteria eResult = CPA_SaveObject::fn_eCheckValidity (csNewName);
if (eResult != E_mc_None)
return eResult;
// test here if the name is used for an unloaded always
//CPA2 Stegaru Cristian 98-06
//check unicity against the UnloadedAlwyas object's list
CPA_BaseObjectList * p_oBaseObjectList = GetEditor ()->GetBaseObjectList(g_c_csUnloadedAlwaysType);
if (p_oBaseObjectList)
{
CPA_Interface *pInterface = GetEditor()->GetInterface();
long lNbObjects = p_oBaseObjectList->fn_lFindObjects(NULL, csNewName, g_c_csUnloadedAlwaysType);
if (lNbObjects > 0) //name conflict
return E_mc_CustomValidity;
}
// name is valid
return E_mc_None;
}
//SHAITAN
void CPA_Actor::mfn_vUpdateAIModel (AI_tdstAIModel *p_stAIModel)
{
CAR_EDIT_TDSTACTOR *p_tdstActor = (CAR_EDIT_TDSTACTOR *) GetStruct();
p_tdstActor->h_Brain->p_stMind->p_stAIModel = p_stAIModel;
EdActors_ActorMiniStructure *pclModelMS = m_fn_pclGetEditorActor()->m_clListOfAMSLists.m_fn_pclGetAMSFromName("Brain");
POSITION pos = pclModelMS->m_pclDataList->GetHeadPosition();
(pclModelMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Brain->p_stMind->p_stAIModel->CFast_bIsC)));
(pclModelMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Brain->p_stMind->p_stAIModel->CFast_lFunction)));
}
void CPA_Actor::mfn_vUpdateAllInstancesForFastC (void)
{
if (!m_fn_bIsAModel())
return;
EdActors_EditorActorModel * pclEditorModel = m_fn_pclGetEditorModel();
// update model editor values
CTL_Editor_Data * pclData = pclEditorModel->m_fn_p_oFindDataByName("FastC_Run");
pclData->m_fn_vGetMotorData();
pclData = pclEditorModel->m_fn_p_oFindDataByName("FastC_Index");
pclData->m_fn_vGetMotorData();
// update all instances editor values
EdActors_EditorActorInstance *pclCurrentInstance;
POSITION InstancesPos = pclEditorModel->m_clInstancesList.GetHeadPosition();
while ( InstancesPos != NULL )
{
pclCurrentInstance = pclEditorModel->m_clInstancesList.GetNext(InstancesPos);
pclData = pclCurrentInstance->m_fn_p_oFindDataByName("FastC_Run");
pclData->m_fn_vGetMotorData();
pclData = pclCurrentInstance->m_fn_p_oFindDataByName("FastC_Index");
pclData->m_fn_vGetMotorData();
}
}
//SHAITAN
//******************************************************************************
//MakeAlways
//******************************************************************************
CPA_MakeAlways::CPA_MakeAlways (EdActors_MyDocument *pDocument, CPA_List<CPA_SuperObject> *pSOActors, BOOL bMakeAlways)
: CPA_Modif (0, "Make Always", FALSE)
{
CPA_SuperObject *pSupObj;
CPA_Actor *pActor;
POSITION pos;
m_pDocument = pDocument;
m_bMakeAlways = bMakeAlways;
// CPA2 ASilvescu 98-04-24
m_bIsCommon = FALSE;
// End CPA2 ASilvescu 98-04-24
pos = pSOActors->GetHeadPosition();
while (pos)
{
pSupObj = pSOActors->GetNext(pos);
pActor = (CPA_Actor *)pSupObj->GetObject();
m_lstActors.AddTail(pActor);
}
}
CPA_MakeAlways::CPA_MakeAlways (EdActors_MyDocument *pDocument, CPA_Actor *pActor, BOOL bMakeAlways)
: CPA_Modif (0, "Make Always", FALSE)
{
m_pDocument = pDocument;
m_bMakeAlways = bMakeAlways;
m_lstActors.AddTail(pActor);
}
CPA_MakeAlways::~CPA_MakeAlways (void)
{
}
BOOL CPA_MakeAlways::Do (void)
{
CPA_Actor *pActor;
POSITION pos = m_lstActors.GetHeadPosition();
while (pos)
{
pActor = m_lstActors.GetNext(pos);
//Notifies Level
m_pDocument->m_fn_vNotifyLevel(pActor, FALSE);
// make always
pActor->m_fn_vMakeAlways(m_bMakeAlways);
// CPA2 ASilvescu 98-04-24
m_bIsCommon = pActor->m_pub_fn_bIsCommon();
pActor->m_pub_fn_vSetCommon(m_bMakeAlways);
// End CPA2 ASilvescu 98-04-24
//Notifies Level
m_pDocument->m_fn_vNotifyLevel(pActor, TRUE);
// update dialog
m_pDocument->m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
}
return TRUE;
}
BOOL CPA_MakeAlways::Undo (void)
{
CPA_Actor *pActor;
POSITION pos = m_lstActors.GetHeadPosition();
while (pos)
{
pActor = m_lstActors.GetNext(pos);
//Notifies Level
m_pDocument->m_fn_vNotifyLevel(pActor, FALSE);
// make always
pActor->m_fn_vMakeAlways(!m_bMakeAlways);
// CPA2 ASilvescu 98-04-24
pActor->m_pub_fn_vSetCommon(m_bIsCommon);
// End CPA2 ASilvescu 98-04-24
//Notifies Level
m_pDocument->m_fn_vNotifyLevel(pActor, TRUE);
// update dialog
m_pDocument->m_pclDialogList->fn_vUpdateSelection(E_lrm_ReinitList);
}
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink