// The one and only file to be touched to accomodate this editor with your project
////////////////////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include <limits.h>
#include <float.h>

/////////////////////////////////////////////////////
//////// !!!!!!!!!!!! DANGER !!!!!!!!!!! ////////////
/////////////////////////////////////////////////////
#define _ED_CAR_MUST_DEFINE_STRUCT_
#include "EdAllAct.hpp"
/////////////////////////////////////////////////////
//////// !!!!!!!!!!!! End DANGER !!!!!!!!!!! ////////
/////////////////////////////////////////////////////

#include "EDACDef.hpp"

#include "_AInterf.hpp"
#include "EDACDoc.hpp"
#include "EDACMStr.hpp"
#include "EDACActr.hpp"
#include "EDACModl.hpp"
#include "EDACStrg.hpp"
#include "EDACSpec.hpp"
#include "EDACClBk.hpp"
#include "Hlp_Flds.h"

//External Modules
#include "CTL.h"
#include "ErO.h"
//End of External Modules

#include "x:\cpa\Main\inc\_EditId.h"

#undef CPA_WANTS_IMPORT
#undef CPA_EXPORT
#define CPA_WANTS_EXPORT
    #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

// Shaitan FastC {
void fn_vNothingEngine (struct tdstEngineObject_ *p_stObject)
{

}

void fn_vNothingEditor (EdActors_ActorMiniStructure *)
{
	
}
//End Shaitan FastC }

//**********************************************************************************************
void EdActors_MyDocument::m_fn_vFillMiniStructureList()
{
	EdActors_MiniStructure *pclMiniStructure;
	EdActors_MiniStructureList *pclMSGroup;
	CTL_Editor_Control *pclAddedControl;

	//.................................
	//	Group 1 MS List
	//.................................
	pclMSGroup = m_clListOfMSLists.m_fn_pclAddElement();

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("3D Data", MS_MANIABILITY_ALWAYS_ALLOCATED);

//Stefan Dumitrean 20-07-98 ( OAC buttons ) 
//at every control I added a new unsigned char parameter, just after the control name parameter
//0 - is not part of a pair, 1 - initial, 2 - current
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Control Translation Vector"*/
//	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Control_Translation");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Current Action"*/
	pclMiniStructure->m_fn_pclAddStateControl(LEVEL_2, EDAC_ONLY_INSTANCES, READ_WRITE, "Current_Action", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Initial Action"*/
	pclMiniStructure->m_fn_pclAddStateControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Initial_Action", 1, IDH_FIELD_STDGAME_INITIAL_ACTION);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Current Object Table"*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_ONLY_INSTANCES, READ_WRITE, "Object_Table", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Initial Object Table"*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Object_Table_Init", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Current Frame"*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_3,READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Current_Frame");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Repeat Anim."*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_3,READ_ONLY, AUTO_SPACE, EDAC_DUAL, TRUE, "Repeat_Anim");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Next Event"*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_3,READ_ONLY, AUTO_SPACE, EDAC_DUAL, TRUE, "Next_Event");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Draw Mask"*/
	pclMiniStructure->m_fn_pclAddMaskedControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Draw_Mask", 0, TRUE, IDH_FIELD_3DDATA_DRAWMASK);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  /*"Shadow Scale X"*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Shadow_Scale_X", 0, TRUE, IDH_FIELD_3DDATA_SHADOW_SCALE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  /*"Shadow Scale Y"*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Shadow_Scale_Y", 0, TRUE, IDH_FIELD_3DDATA_SHADOW_SCALE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Shadow Material"*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_DUAL, READ_WRITE, "Shadow_Material", 0, TRUE, IDH_FIELD_3DDATA_SHADOW_MATERIAL);
	((CTL_Editor_EnumControl *)pclAddedControl)->m_pub_fn_vMustSortNamesInComboBox(TRUE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Shadow Quality"*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_DUAL, READ_WRITE, "Shadow_Quality", 0, TRUE, IDH_FIELD_3DDATA_SHADOW_QUALITY);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Shadow Height"*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Shadow_Height", 0, TRUE, IDH_FIELD_3DDATA_SHADOW_HEIGHT);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Current Position"*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_3, READ_ONLY, EDAC_ONLY_INSTANCES, "Crt_Position");

// ANNECY MT 12/06/98 {
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    /* Brain Computation Frequency */
    pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Brain_Computation_Frequency", 0);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    /* Light Computation Frequency */
    pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Light_Computation_Frequency", 0);
// END ANNECY MT }
	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Standard", MS_MANIABILITY_ALWAYS_ALLOCATED);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Family Type",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(-1, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_3, READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Family_Type");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Model Type",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(-1, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_3, READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Model_Type");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Perso. Type",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(-1, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_3, READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Perso_Type");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Last Trame",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, LONG_INT, /*UN*/SIGNED_INT, LEVEL_3, READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Last_Trame");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Hit Points",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Hit_Points", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Hit Points Init.",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Initial_Hit_Points", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Hit Points Max",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Hit_Points_Max", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Hit Points Max Init.",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Initial_Hit_Points_Max", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Hit Points Max Max",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Hit_Points_Max_Max");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Desactivate At All",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_3, READ_ONLY, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Desactivate_At_All");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Activable",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_3, READ_ONLY, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Activable");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Active",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_3, READ_ONLY, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Active");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Init Flag Out of Zone",*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "ObjectinitInit_Restricted");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Init Flag Dead or Taken",*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "ObjectinitInit");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Special Position Flag",*/
	//pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "SpecialPosFlag", IDH_FIELD_STDGAME_SPECIAL_POS_FLAG);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Platform Type",*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Platform_Type", 0, TRUE, IDH_FIELD_STDGAME_PLATFORM_TYPE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Linked to Sector",*/
	//pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_DUAL, READ_WRITE, "Linked_To_Sector", IDH_FIELD_STDGAME_LINKED_TO_SECTOR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ANNECY Bart#02 20/04/98 {
	/*"TractionFactor",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Traction_Factor");
	/*"Draw Mask"*/
	pclMiniStructure->m_fn_pclAddMaskedControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Actor_Capabilities", 0, TRUE, IDH_FIELD_STDGAME_CAPABILITIES);
	//pclMiniStructure->m_fn_pclAddIntegerControl(0, ULONG_MAX, LONG_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Actor_Capabilities");
//ENDANNECY Bart#02 }
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Transparency Zone Min",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Transparency_Zone_Min");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Transparency Zone Max",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Transparency_Zone_Max");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ANNECY MT - 22/10/98 {
	/*"Too Far Limit",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Too_Far_Limit");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// END ANNECY MT }
//ANNECY BBB 20/11/97 {
	/*"Custom bits" and "Initial Custom bits", interleaved*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Unseen Frozen Anim Player (1)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Unseen Frozen Anim Player (1)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Need Module Matrices (2)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Need Module Matrices (2)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Movable (3)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Movable (3)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Projectile (4)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Projectile (4)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "RayTrace Hit (5)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial RayTrace Hit (5)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Targetable (6)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Targetable (6)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Cannot crush Principal Actor (7)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Cannot crush Principal Actor (7)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Pickable (8)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Pickable (8)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "ActorHasAShadow (9)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial ActorHasAShadow (9)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "ShadowOnMe (10)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial ShadowOnMe (10)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Prunable (11)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Prunable (11)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_ONLY,  SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Out Of visibility [internal use] (12)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_ONLY,  SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Out Of visibility [internal use] (12)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Unseen Frozen (13)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Unseen Frozen (13)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No Anim Player (14)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No Anim Player (14)" , 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Fightable (15)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Fightable (15)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No Meca (16)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No Meca (16)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No AI (17)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No AI (17)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Destroy when Anim ended (18)" , 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Destroy when Anim ended (18)" , 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No Anim Player When Too Far (19)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No Anim Player When Too Far (19)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No AI Player When Too Far (20)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No AI Player When Too Far", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Unfreezable (21)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Unfreezable (21)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_ONLY,  SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Uses Transparency Zone (22)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Uses Transparency Zone (22)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No Meca When Too Far (23)" , 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial No Meca When Too Far (23)" , 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Sound When Invisible (24)", 2,FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Sound When Invisible (24)", 1,FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "CustomBit_25", 2);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial_CustomBit_25", 1);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Camera Hit (26)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Camera Hit (26)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "CanPushPrincipalActor (27)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial_CanPushPrincipalActor (27)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Designer bit 1 (28)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Designer bit 1 (28)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Designer bit 2 (29)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Designer bit 2 (29)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Designer bit 3 (30)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Designer bit 3 (30)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Designer bit 4 (31)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial Designer bit 4 (31)", 1, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "PrincipalActor (32)", 2, FALSE);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Initial PrincipalActor (32)", 1, FALSE);
	//---------------------------------------------------------------------------------------------
//ENDANNECY BBB 20/11/97 }

// Shaitan FastC {
	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Brain", MS_MANIABILITY_ALWAYS_ALLOCATED);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	//"Fast C Run",
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_ONLY_MODELS, TRUE, "FastC_Run", FALSE);
	//"Fast C Function",
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_1, READ_ONLY, SINGLE_LINE, EDAC_ONLY_MODELS, TRUE, "FastC_Index", FALSE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//End Shaitan FastC }

	//.................................
	//	Group 2 MS List
	//.................................
	pclMSGroup = m_clListOfMSLists.m_fn_pclAddElement();

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Dynamics", MS_MANIABILITY_NORMAL);

//ANNECY jt {
	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Current Mechanics"*/
//	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_3, EDAC_DUAL, READ_ONLY, "Mechanics_Type");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Object Type"*/
//	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Object_Type");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Is Mobile"*/
//	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Is_Mobile");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Can Hang something on"*/
//	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Can_Hang_Smthg_On");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Env. Stable"*/
//	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Stable_Env", IDH_FIELD_DYNAM_STABLE_ENV);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Mechanic_Size", 0, TRUE, IDH_FIELD_UNKNOWN_BIS);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Collision", 1, FALSE);



	pclMiniStructure->m_fn_pclAddDecimalControl(0, 1, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Slide x");
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 1, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Slide y");
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 1, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Slide z");

//ENDANNECY jt }

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Sector Info", MS_MANIABILITY_ALWAYS_ALLOCATED);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Current Sector",*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_ONLY_INSTANCES, READ_ONLY, "Current_Sector");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//ANNECY BBB 17/10/97 {
	//*********************************************************************************************
	//*********************************************************************************************
	//------------------------- Adds a new mini-structure in the list -----------------------------
	//*********************************************************************************************
	//*********************************************************************************************


	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Anim Effect", MS_MANIABILITY_NORMAL);

	//---------------------------------------------------------------------------------------------
	/*"shift phase",*/
	pclMiniStructure->m_fn_pclAddVectorControl(0.0001, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Shift_Phase");
	//---------------------------------------------------------------------------------------------
	/*"shift max",*/
	pclMiniStructure->m_fn_pclAddVectorControl(0.0, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Shift_Max");
	//---------------------------------------------------------------------------------------------
	/*"shift plus",*/
	pclMiniStructure->m_fn_pclAddVectorControl(0.0001, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Shift_Plus");
	//---------------------------------------------------------------------------------------------
//ENDANNECY BBB 17/10/97 }

	//.................................
	//	Group 3 MS List
	//.................................
	pclMSGroup = m_clListOfMSLists.m_fn_pclAddElement();

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Light", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Light type",*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Light_Type", 0, TRUE, IDH_FIELD_LIGHT_TYPE);
//ANNECY CT 13/01/98 {
	//---------------------------------------------------------------------------------------------
	/*"LocalLight",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE,"LocalLight", 2);
	//---------------------------------------------------------------------------------------------
	/*"LocalLight Init",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE,"LocalLight_Init", 1, IDH_FIELD_LIGHT_LOCAL_LIGHT);
	//---------------------------------------------------------------------------------------------
	/*"OnlyLocalLight",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE,"OnlyLocalLight", 2);
	//---------------------------------------------------------------------------------------------
	/*"OnlyLocalLight Init",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE,"OnlyLocalLight_Init", 1, IDH_FIELD_LIGHT_ONLY_LOCAL_LIGHT);
	//---------------------------------------------------------------------------------------------
//ENDANNECY CT }
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Girophare",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Girophare", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Girophare Init",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Girophare_Init", 1, IDH_FIELD_LIGHT_GYROPHARE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Pulsing",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "Pulsing", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Pulsing Init",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "Pulsing_Init", 1, IDH_FIELD_LIGHT_PULSE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Offset Vector",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, EDAC_ONLY_INSTANCES, "Offset_Vector", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Offset Vector Init",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Offset_Vector_Init", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Angle Vector",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, EDAC_ONLY_INSTANCES, "Angle_Vector", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Angle Vector Init",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Angle_Vector_Init", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 	/*"Step Giro",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Step_Giro", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  /*"Step Giro Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Step_Giro_Init", 1, IDH_FIELD_LIGHT_STEP_GYRO);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 	/*"Step Pulse",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Step_Pulse", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  /*"Step Pulse Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Step_Pulse_Init", 1, IDH_FIELD_LIGHT_STEP_PULSE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 	/*"Max Range Pulse",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Max_Range_Pulse", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  /*"Max Range Pulse Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Max_Range_Pulse_Init", 1, IDH_FIELD_LIGHT_MAX_RANGE_PULSE);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Angle Giro",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_ONLY, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Angle_Giro", 2);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Angle Giro Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Angle_Giro_Init", 1, IDH_FIELD_LIGHT_ANGLE_GYRO);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"OnOff Init",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "OnOff_Init", 0, TRUE, IDH_FIELD_LIGHT_ON_OFF);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Color Init R",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0.0, 1.0, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Init_Color_R", 0, TRUE, IDH_FIELD_LIGHT_COLOR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Color Init G",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0.0, 1.0, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Init_Color_G", 0, TRUE, IDH_FIELD_LIGHT_COLOR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Color Init B",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0.0, 1.0, FLOAT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Init_Color_B", 0, TRUE, IDH_FIELD_LIGHT_COLOR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"xNear Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Near_Init", 0, TRUE, IDH_FIELD_LIGHT_NEAR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"xFar Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Far_Init", 0, TRUE, IDH_FIELD_LIGHT_FAR);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Little Alpha Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Little_Alpha_Init", 0, TRUE, IDH_FIELD_LIGHT_LITTLE_ALPHA);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Big Alpha Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Big_Alpha_Init", 0, TRUE, IDH_FIELD_LIGHT_BIG_ALPHA);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Little Tangent Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Little_Tangent_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Big Tangent Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Big_Tangent_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//CHINA WFQ (MT) 16-02-98 {
	/*"Min Internal Pos",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Min_Internal_Pos_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Max Internal Pos",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Max_Internal_Pos_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Min External Pos",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Min_External_Pos_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Max External Pos",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "Max_External_Pos_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Intensity Min Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Intensity_Min_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Intensity Max Init",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Intensity_Max_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ENDCHINA WFQ }
	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Collision Set", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Character Priority",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Character_Priority");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Collision Flag",*/
// ANNECY AV {
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_With_Map", 2);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_With_Map_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_With_Projectile", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_With_Projectile_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_With_Secondary_Character", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_With_Secondary_Character_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_With_Main_Character", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_With_Main_Character_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Force_Collision_When_Not_Moving", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Force_Collision_When_Not_Moving_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_With_Other_Sectors", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_With_Other_Sectors_Init", 1);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "No_Collision_Zde_With_Projectile", 2);
    pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "No_Collision_Zde_With_Projectile_Init", 1);
// END ANNECY AV }
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_ONLY_INSTANCES, TRUE, "Collision_Frequency", 2);
	pclMiniStructure->m_fn_pclAddIntegerControl(0, UCHAR_MAX, CHAR_INT, UNSIGNED_INT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, TRUE, "Collision_Frequency_Init", 1);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"ZDe",*/
	pclMiniStructure->m_fn_pclAddObjectListControl(LEVEL_1, READ_WRITE, EDAC_DUAL, TRUE, FALSE, FALSE, C_szZdeName);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"ZDm",*/
	pclMiniStructure->m_fn_pclAddObjectListControl(LEVEL_1, READ_WRITE, EDAC_DUAL, TRUE, FALSE, FALSE, C_szZdmName);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"ZDd",*/
	pclMiniStructure->m_fn_pclAddObjectListControl(LEVEL_1, READ_WRITE, EDAC_DUAL, TRUE, FALSE, FALSE, C_szZddName);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"ZDr",*/
	pclMiniStructure->m_fn_pclAddObjectListControl(LEVEL_1, READ_WRITE, EDAC_DUAL, TRUE, FALSE, FALSE, C_szZdrName);
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Ways", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Ways",*/
	pclAddedControl = pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_DUAL, READ_ONLY, "Reseau");
	pclMiniStructure->m_fn_pclAddIntegerControl(CHAR_MIN, CHAR_MAX, CHAR_INT, SIGNED_INT, LEVEL_2, READ_ONLY, AUTO_SPACE, EDAC_DUAL, FALSE, "Index");
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2,READ_ONLY, AUTO_SPACE, EDAC_DUAL, FALSE,"Circulaire");

	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	//.................................
	//	Group 4 MS List
	//.................................
	pclMSGroup = m_clListOfMSLists.m_fn_pclAddElement();

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
//ANNECY CB
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Camera", MS_MANIABILITY_NORMAL);

	//---------------------------------------------------------------------------------------------
	/*"Shift Target ",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, EDAC_ONLY_INSTANCES, "ShiftTarget", 2);
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "ShiftTarget_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Shift Pos ",*/
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, EDAC_ONLY_INSTANCES, "ShiftPos", 2);
	pclMiniStructure->m_fn_pclAddVectorControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, EDAC_DUAL, "ShiftPos_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Dist Min",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "DistMin", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "DistMin_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Dist Max",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "DistMax", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "DistMax_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Bound Dist Min",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "BoundDist_Min", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "BoundDistMin_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Bound Dist Max",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "BoundDist_Max", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "BoundDistMax_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Angle Alpha",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Alpha", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Alpha_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Angle Shift Alpha",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Shift_Alpha", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "ShiftAlpha_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Angle Theta",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Theta", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Theta_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Angle Shift Theta",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "ShiftTheta", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(0, 2*EDAC_PI, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "ShiftTheta_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Linear Speed Inc/Dec",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "LinearSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "LinearSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "LinearIncreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "LinearIncreaseSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "LinearDecreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "LinearDecreaseSpeed_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Angular Speed Limit Min/Max/Inc/Dec",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "AngularSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "AngularSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "AngularIncreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "AngularIncreaseSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "AngularDecreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "AngularDecreaseSpeed_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Target Speed Limit Min/Max/Inc/Dec",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "TargetSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "TargetSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "TargetIncreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "TargetIncreaseSpeed_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "TargetDecreaseSpeed", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "TargetDecreaseSpeed_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"DNM Flags",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, SHORT_INT, SIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "DNMFlags", 2);
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, SHORT_INT, SIGNED_INT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "DNMFlags_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"IA Flags",*/
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, SHORT_INT, SIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, TRUE, "IAFlags", 2);
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, SHORT_INT, SIGNED_INT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, TRUE, "IAFlags_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Focal",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Focal", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Focal_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"ZMinMax",*/
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "ZMin", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "ZMin_Init", 1);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "ZMax", 2);
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "ZMax_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Type of Viewport",*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_2, EDAC_ONLY_INSTANCES, READ_WRITE, "Viewport_Type", 2);
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "ViewportType_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Channel"*/
	pclMiniStructure->m_fn_pclAddIntegerControl(CHAR_MIN, CHAR_MAX, CHAR_INT, SIGNED_INT, LEVEL_2, READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE, "Channel", 2);
	pclMiniStructure->m_fn_pclAddIntegerControl(CHAR_MIN, CHAR_MAX, CHAR_INT, SIGNED_INT, LEVEL_1, READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE, "Channel_Init", 1);
	//---------------------------------------------------------------------------------------------
	/*"Camera is Active"*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2,READ_WRITE, AUTO_SPACE, EDAC_ONLY_INSTANCES, FALSE,"IsActive", 2);
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_1,READ_WRITE, AUTO_SPACE, EDAC_DUAL, FALSE,"IsActive_Init", 1);
	//---------------------------------------------------------------------------------------------
//ENDANNECY CB

	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Micro", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Is Active",*/
	pclMiniStructure->m_fn_pclAddBooleanControl(LEVEL_2, READ_ONLY, SINGLE_LINE, EDAC_DUAL, FALSE, "Is_Active");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("PrtSource", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Activation"*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Activation");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"Part Gen"*/
	pclMiniStructure->m_fn_pclAddEnumControl(LEVEL_1, EDAC_DUAL, READ_WRITE, "Particle_Gen");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Sound", MS_MANIABILITY_NORMAL);

	//++++++++++++++++++++++++++++++Describes the mini-structure +++++++++++++++++++++++++++++++
	/*"Satur Distance"*/
    // ROMTEAM corrections (Nicu 06-02-98) {
    //pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Satur_Distance");
    pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Satur_Distance_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*"BackGround Distance"*/
    //pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_2, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "BackGround_Distance");
    pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "BackGround_Distance_Init");
	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    // END ROMTEAM corrections (Nicu) }
	// CHINA QZY (MT) 26/02/98 {
	//------------------------------------------------------------------------------------------
	//------------------------- Adds a new mini-structure in the list --------------------------
	//------------------------------------------------------------------------------------------
	pclMiniStructure = pclMSGroup->m_fn_pclAddElement("Magnet", MS_MANIABILITY_NORMAL);

	pclMiniStructure->m_fn_pclAddDecimalControl(0, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Far_Init");
	pclMiniStructure->m_fn_pclAddDecimalControl(0, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Near_Init");
	pclMiniStructure->m_fn_pclAddDecimalControl(-FLT_MAX, FLT_MAX, FLOAT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Strength_Init");
	pclMiniStructure->m_fn_pclAddIntegerControl(0, LONG_MAX, LONG_INT, SIGNED_INT, LEVEL_1, READ_WRITE, SINGLE_LINE, EDAC_DUAL, FALSE, "Duration_Init");
	// ENDCHINA QZY }
}

//**********************************************************************************************
// For each actor : constructs the MS list, and sets the (motor) allocation and desallocation
// functions,and the (editor) filling function
void EdActors_EditorActor::m_fn_vConstructListOfMS()
{
	EdActors_ActorMiniStructure *pclNewActorMS;
	EdActors_ActorMiniStructureList *pclAMSList;

	//Creates the list of lists of AMS
	CString csGroupName;

	//Sets the Actor MS list and the filling and allocation functions

	//------------------------------------------------------------------------------------------
	//.................................
	//	Group 1 MS List
	//.................................
	csGroupName.Format("%s%i", g_c_csGroupName, 1);
	pclAMSList = m_clListOfAMSLists.m_fn_pclAddList(csGroupName);

 	pclNewActorMS = pclAMSList->m_fn_pclAddElement("3D_Data");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS2;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_v3dDataAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_v3dDataFree;
	pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &EDACT_fn_v3dDataAfterAllocation;

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Standard_Game");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS1;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vStdGameAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vStdGameFree;
	pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &EDACT_fn_vStdGameAfterAllocation;

// Shaitan FastC {

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Brain");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS20;
	if (m_fn_tdeGetActorType() == EDCAR_ACTOR_TYPE_MODEL)
	{
		pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vBrainAlloc;
		pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vBrainFree;
		pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &EDACT_fn_vBrainAfterAllocation;
	}
	else
	{
		pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vNothingEngine;
		pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vNothingEngine;
		pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &fn_vNothingEditor;
	}

//End Shaitan FastC }

	//------------------------------------------------------------------------------------------
	//.................................
	//	Group 2 MS List
	//.................................
	csGroupName.Format("%s%i", g_c_csGroupName, 2);
	pclAMSList = m_clListOfAMSLists.m_fn_pclAddList(csGroupName);

 	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Dynamics");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS3;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vDynamAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vDynamFree;
	pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &EDACT_fn_vDynamicsAfterAllocation;

 	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Sect_Info");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS15;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vSectInfoAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vSectInfoFree;

//ANNECY BBB 17/10/97 {
  pclNewActorMS = pclAMSList->m_fn_pclAddElement("Anim_Effect");
  pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS18;
  pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vAnimEffectAlloc;
  pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vAnimEffectFree;
//ENDANNECY BBB 17/10/97 }

    //------------------------------------------------------------------------------------------
	//.................................
	//	Group 3 MS List
	//.................................
	csGroupName.Format("%s%i", g_c_csGroupName, 3);
	pclAMSList = m_clListOfAMSLists.m_fn_pclAddList(csGroupName);

 	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Light");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS5;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vLightAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vLightFree;

 	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Collision_Set");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS8;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vCollSetAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vCollSetFree;

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Ways");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS9;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vMSWayAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vMSWayFree;

	//------------------------------------------------------------------------------------------
	//.................................
	//	Group 4 MS List
	//.................................
	csGroupName.Format("%s%i", g_c_csGroupName, 4);
	pclAMSList = m_clListOfAMSLists.m_fn_pclAddList(csGroupName);

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Camera");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS7;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &CAM_fn_vCineinfoAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &CAM_fn_vCineinfoFree;
	pclNewActorMS->m_td_pfn_vAfterAllocationSpecialFunction = &EDACT_fn_vCineinfoAfterAllocation;

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Micro");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS10;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vMicroAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vMicroFree;

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("PrtSource");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS16;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vMSPrtSrcAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vMSPrtSrcFree;

	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Sound");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS17;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vMSSoundAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vMSSoundFree;

// CHINA QZY (MT) 26/02/98 {
	pclNewActorMS = pclAMSList->m_fn_pclAddElement("Magnet");
	pclNewActorMS->m_td_pfn_vFillFunction = &fn_vFillMS19;
	pclNewActorMS->m_td_pfn_vAllocationFunction = &fn_vMSMagnetAlloc;
	pclNewActorMS->m_td_pfn_vUnallocationFunction = &fn_vMSMagnetFree;
// ENDCHINA QZY }
}

//****************************************************************
//Sets all MS Pointers to NULL
void EdActors_EditorActor::m_fn_vSetMSPointersToNULL()
{
	m_fn_ptdstGetMotorActor()->h_3dData = NULL;
	m_fn_ptdstGetMotorActor()->h_StandardGame = NULL;
	m_fn_ptdstGetMotorActor()->h_Brain = NULL;
	m_fn_ptdstGetMotorActor()->h_Dynam = NULL;
	m_fn_ptdstGetMotorActor()->h_Cineinfo = NULL;
	m_fn_ptdstGetMotorActor()->h_CollSet = NULL;
	m_fn_ptdstGetMotorActor()->h_MSWay = NULL;
	m_fn_ptdstGetMotorActor()->h_MSLight = NULL;
	m_fn_ptdstGetMotorActor()->h_SectInfo = NULL;
	m_fn_ptdstGetMotorActor()->h_Micro = NULL;
	m_fn_ptdstGetMotorActor()->h_MSPrtSrc = NULL;
	m_fn_ptdstGetMotorActor()->h_MSSound = NULL;
//ANNECY BBB 17/10/97 {
    m_fn_ptdstGetMotorActor()->h_AnimEffect = NULL;
//ENDANNECY BBB 17/10/97 }
// CHINA QZY (MT) 26/02/98 {
	m_fn_ptdstGetMotorActor()->h_MSMagnet = NULL;
// ENDCHINA QZY }
}

//----------------------------------------------------------
//-------------------- Owner Data --------------------------
//----------------------------------------------------------
#define OAC_M_AddOwnerData(Data)	\
	OAC_AddOwnerDataToData(Data, pclActor, pclActorMS);
//----------------------------------------------------------
//----------------------------------------------------------

//**********************************************************************************************
void fn_vFillMS1(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT(	p_tdstActor	!= NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);
//ANNECY Bart#02 20/04/98 {
 	CTL_Editor_MaskList *pclListOfMaskDescriptors = &(g_pclInterface->m_clDocument.m_clListOfMasksDescriptors);
//ENDANNECY Bart#02 }

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;
//ANNECY Bart#02 20/04/98 {
    CTL_Editor_MaskDescriptor *pclMaskDescriptorForActorCapabilities = pclListOfMaskDescriptors->m_fn_pclGetMaskDescriptorByName("Actor_Capabilities");
//ENDANNECY Bart#02 }

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "Family_Type"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "Model_Type"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "Perso_Type"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, /*UN*/SIGNED_INT, "Last_Trame"));

		OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Hit_Points"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Initial_Hit_Points", pclCurrentBaseData));

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Hit_Points_Max");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Initial_Hit_Points_Max", pclCurrentBaseData));

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Hit_Points_Max_Max"));
		/*
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Desactivate_At_All"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Activable"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Active"));
		*/
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "Desactivate_At_All"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "Activable"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "Active"));

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("ObjectinitInit_Restricted"), "Flag_Out_of_Zone"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("ObjectinitInit"), "Flag_Dead_or_Taken"));
		//OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("SpecialPosFlag"), "Special_Pos_Flag"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("Platform_Type"), "Platform_Type"));
		//OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("LinkedToSector"), "Linked_To_Sector"));
//ANNECY Bart#02 20/04/98 {
		OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Traction_Factor"));

    //OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, UNSIGNED_INT, "Actor_Capabilities"));

 		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddMaskedData(pclMaskDescriptorForActorCapabilities, "Actor_Capabilities"));

//ENDANNECY Bart#02 }
		
		OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Transparency_Zone_Min"));
		OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Transparency_Zone_Max"));

// ANNECY MT - 22/10/98 {
		OAC_M_AddOwnerData(pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Too_Far_Limit"));
// END ANNECY MT }

		//OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Linked_To_Sector"));
//ANNECY BBB 20/11/97 {
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "CustomBit_1");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "Initial_CustomBit_1", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "CustomBit_2");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "Initial_CustomBit_2", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "CustomBit_3");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "Initial_CustomBit_3", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "CustomBit_4");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "Initial_CustomBit_4", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "CustomBit_5");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "Initial_CustomBit_5", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "CustomBit_6");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "Initial_CustomBit_6", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "CustomBit_7");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "Initial_CustomBit_7", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "CustomBit_8");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "Initial_CustomBit_8", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "CustomBit_9");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "Initial_CustomBit_9", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "CustomBit_10");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "Initial_CustomBit_10", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "CustomBit_11");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "Initial_CustomBit_11", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "CustomBit_12");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "Initial_CustomBit_12", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "CustomBit_13");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "Initial_CustomBit_13", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "CustomBit_14");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "Initial_CustomBit_14", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "CustomBit_15");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "Initial_CustomBit_15", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "CustomBit_16");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "Initial_CustomBit_16", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "CustomBit_17");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "Initial_CustomBit_17", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "CustomBit_18");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "Initial_CustomBit_18", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "CustomBit_19");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "Initial_CustomBit_19", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "CustomBit_20");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "Initial_CustomBit_20", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "CustomBit_21");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "Initial_CustomBit_21", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "CustomBit_22");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "Initial_CustomBit_22", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "CustomBit_23");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "Initial_CustomBit_23", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "CustomBit_24");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "Initial_CustomBit_24", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "CustomBit_25");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x01, "Initial_CustomBit_25", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "CustomBit_26");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x02, "Initial_CustomBit_26", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "CustomBit_27");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x04, "Initial_CustomBit_27", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "CustomBit_28");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x08, "Initial_CustomBit_28", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "CustomBit_29");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x10, "Initial_CustomBit_29", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "CustomBit_30");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x20, "Initial_CustomBit_30", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "CustomBit_31");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x40, "Initial_CustomBit_31", pclCurrentBaseData));
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "CustomBit_32");
		OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData(0x80, "Initial_CustomBit_32", pclCurrentBaseData));
//ENDANNECY BBB 20/11/97 }
		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_StandardGame == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_StandardGame));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->otObjectFamilyType)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->otObjectModelType)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->otObjectPersonalType)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ulLastTrame)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucHitPoints)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucStdGameGetHitPointsInit(p_tdstActor->h_StandardGame)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucHitPointsMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucStdGameGetHitPointsMaxInit(p_tdstActor->h_StandardGame)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucHitPointsMaxMax)));
		/*
 		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->bf1IsDesactivateAtAll)));
 		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->bf1IsActivable)));
 		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->bf1IsActive)));
		*/
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)((char *)(&(p_tdstActor->h_StandardGame->ucMiscFlags))));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)((char *)(&(p_tdstActor->h_StandardGame->ucMiscFlags))));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)((char *)(&(p_tdstActor->h_StandardGame->ucMiscFlags))));

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->eInitFlagWhenOutOfZone)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->eInitFlagWhenDeadOrTaken)));
		//(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucSpecialPositionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucPlatFormType)));
		//BBB: (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucLinkedToSector)));
		//(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->bLinkedToSector)));
//ANNECY Bart#02 20/04/98 {
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucTractionFactor)));

    //(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ubf32Capabilities)));
    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ubf32Capabilities)));
//ENDANNECY Bart#02 }
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucTransparencyZoneMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucTransparencyZoneMax)));
// ANNECY MT - 22/10/98 {
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_StandardGame->ucTooFarLimit)));
// END ANNECY MT }
//ANNECY BBB 20/11/97 {
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 0 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 0 ) );

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 1 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 1 ) );

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 2 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 2 ) );

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)(&(p_tdstActor->h_StandardGame->ulCustomBits)) ) + 3 ) );
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) ( ( (char *)fn_p_ulStdGameGetCustomBitsInit(p_tdstActor->h_StandardGame) ) + 3 ) );
//ENDANNECY BBB 20/11/97 }

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS2(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);
 	CTL_Editor_MaskList *pclListOfMaskDescriptors = &(g_pclInterface->m_clDocument.m_clListOfMasksDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;
		CTL_Editor_Data *pclAddedData;
 		CTL_Editor_EnumDescriptor *pclEnumDescriptorForOT = pclActor->m_pub_fn_pclGetEnumDescriptorForObjectsTables();
 		CTL_Editor_EnumDescriptor *pclEnumDescriptorForGameMaterials = pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName(g_c_csGameMaterialEnumDescriptorName);
 		CTL_Editor_MaskDescriptor *pclMaskDescriptorForDrawMask = pclListOfMaskDescriptors->m_fn_pclGetMaskDescriptorByName("Draw_Mask");
 		CTL_Editor_EnumDescriptor *pclEnumDescriptorFoShadowQuality = pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("Shadow_Quality");

//		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Control_Translation"));
		pclCurrentBaseData = OAC_fn_pclAddStateData(pclActorMS->m_pclDataList, "Current_Action|Current_State");
		//CallBack
		pclCurrentBaseData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(OAC_fn_vCurrentActionHasChanged);
		OAC_M_AddOwnerData(pclCurrentBaseData);

		pclAddedData = OAC_fn_pclAddStateData(pclActorMS->m_pclDataList, "Initial_Action|Initial_State", pclCurrentBaseData);
		//CallBack
		pclAddedData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(OAC_fn_vInitialActionHasChanged);
		OAC_M_AddOwnerData(pclAddedData);

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclEnumDescriptorForOT, "Object_Table");
		//CallBack
		pclCurrentBaseData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(OAC_fn_vCurrentObjectTableHasChanged);
		OAC_M_AddOwnerData(pclCurrentBaseData);

		pclAddedData = pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclEnumDescriptorForOT, "Object_Table_Init", pclCurrentBaseData);
		//CallBack
		pclAddedData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(OAC_fn_vInitialObjectTableHasChanged);
		OAC_M_AddOwnerData(pclAddedData);

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Current_Frame"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Repeat_Anim"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Next_Event"));
 		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddMaskedData(pclMaskDescriptorForDrawMask, "Draw_Mask"));
 		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Shadow_Scale_X"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Shadow_Scale_Y"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclEnumDescriptorForGameMaterials, "Shadow_Material"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclEnumDescriptorFoShadowQuality, "Shadow_Quality"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Shadow_Height"));
 		pclAddedData = pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Crt_Position");
		OAC_M_AddOwnerData(pclAddedData);
		//CallBacks
		pclAddedData->m_pub_fn_vSetDataMustBeRead_CallBack(OAC_fn_bVectorDataMustBeRead);
		pclAddedData->m_pub_fn_vSetDataMustBeWritten_CallBack(OAC_fn_bVectorDataMustBeWritten);
// ANNECY MT 12/06/98 {
        pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Brain_Computation_Frequency");
		OAC_M_AddOwnerData(pclCurrentBaseData);
        pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Light_Computation_Frequency");
		OAC_M_AddOwnerData(pclCurrentBaseData);
// END ANNECY MT }


		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_3dData == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_3dData));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

//		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->stControlTranslationVertex)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->h_CurrentState)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->h_InitialState)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->h_CurrentObjectsTable)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->h_InitialObjectsTable)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->uwCurrentFrame)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->ucRepeatAnimation)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->ucNextEvent)));
		//ANNECY VL 08/04/98{
		//(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->lDrawMask)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->lDrawMaskInit)));
		//ENDANNECY VL}
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->xShadowScaleX)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->xShadowScaleY)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->p_stShadowMaterial)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->xShadowQuality)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->xSHWHeight)));

		MTH3D_tdstVector *p_tdstPositionVector = NULL;
		if ( pclActorMS->m_pclParentActor->m_fn_bIsAnInstance() )
		{
			if (p_tdstActor->h_3dData->p_stGLIObjectAbsoluteMatrix == NULL)
			{
				if (pclActor->m_pclActor->m_pub_fn_pclGetSuperObject())
					fn_v3dDataSetAbsoluteMatrix(p_tdstActor->h_3dData, HIE_fn_hGetSuperObjectGlobalMatrix(pclActor->m_pclActor->m_pub_fn_pclGetSuperObject()->GetStruct()));
			}
			p_tdstPositionVector = &((POS_tdstCompletePosition *)p_tdstActor->h_3dData->p_stGLIObjectAbsoluteMatrix)->stTranslationVector;
		}

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(p_tdstPositionVector));

// ANNECY MT - 12/06/98 {
        (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->ucBrainComputationFrequency)));

        (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_3dData->ucLightComputationFrequency)));
// END ANNECY MT }
		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS3(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();
	DNM_tdstDynamics *p_stDynamic = p_tdstActor->h_Dynam ? p_tdstActor->h_Dynam->p_stDynamics : NULL;

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);

		// End of CTL Specific
		///
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("Mechanic_Size"), "Size"));
		
		CTL_Editor_Data* pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x40, "Collision");
		OAC_M_AddOwnerData(pclCurrentBaseData);
//		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x40, "Collision", pclCurrentBaseData));


		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Slide_x"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Slide_y"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Slide_z"));

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_Dynam == NULL )
	{

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_Dynam));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Dynam->p_stDynamics->m_tdstDynamicsBaseBlock.ulEndFlags)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr( (void *) (((long)&(p_tdstActor->h_Dynam->p_stDynamics->m_tdstDynamicsBaseBlock.ulEndFlags))+1));


		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Dynam->p_stDynamics->m_tdstDynamicsAdvancedBlock.m_xSlideFactorX)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Dynam->p_stDynamics->m_tdstDynamicsAdvancedBlock.m_xSlideFactorY)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Dynam->p_stDynamics->m_tdstDynamicsAdvancedBlock.m_xSlideFactorZ)));

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS5(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("LightType"), "Light_Type"));

//ANNECY CT 13/01/98 {
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("LocalLight");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("LocalLight_Init", pclCurrentBaseData);
		OAC_M_AddOwnerData(pclCurrentBaseData);
		pclCurrentBaseData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(EDACTORS_fn_vCallBackInitialLocalLightHasChanged);

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("OnlyLocalLight");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("OnlyLocalLight_Init", pclCurrentBaseData);
		OAC_M_AddOwnerData(pclCurrentBaseData);
		pclCurrentBaseData->m_pub_fn_vSetDataChangedSpecialCallBackFunction(EDACTORS_fn_vCallBackInitialOnlyLocalLightHasChanged);
//ENDANNECY CT }

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Girophare");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Girophare_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Pulsing");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Pulsing_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Offset_Vector");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Offset_Vector_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Angle_Vector");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Angle_Vector_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Step_Giro");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Step_Giro_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Step_Pulse");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Step_Pulse_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Max_Range_Pulse");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Max_Range_Pulse_Init", pclCurrentBaseData));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Angle_Giro");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Angle_Giro_Init", pclCurrentBaseData));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("OnOff_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Init_Color_R"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Init_Color_G"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Init_Color_B"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Near_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Far_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Little_Alpha_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Big_Alpha_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Little_Tangent_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Big_Tangent_Init"));
//CHINA WFQ (MT) 16/02/98 {
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Min_Internal_Pos_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Max_Internal_Pos_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Min_External_Pos_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Max_External_Pos_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Intensity_Min_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Intensity_Max_Init"));
//ENDCHINA WFQ }
		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_MSLight == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_MSLight));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		void	*pvMotorData;
		pvMotorData=fn_p_lMSLightGetTypeInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

//ANNECY CT 13/01/98 {
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->bLocalLight)));

		pvMotorData=fn_p_ucMSLightGetLocalLightInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->bOnlyLocalLight)));

		pvMotorData=fn_p_ucMSLightGetOnlyLocalInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);
//ENDANECY CT}

        (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->bGiroPhare)));

		pvMotorData=fn_p_ucMSLightGetGiroPhareInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->bPulsing)));

		pvMotorData=fn_p_ucMSLightGetPulsingInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->stOffsetVect)));

		pvMotorData=fn_p_stMSLightGetOffsetVectInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->stAngle)));

		pvMotorData=fn_p_stMSLightGetAngleInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->xStepGiro)));

		pvMotorData=fn_p_xMSLightGetStepGiroInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->xStepPulse)));

		pvMotorData=fn_p_xMSLightGetStepPulseInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->xMaxRangePulse)));

		pvMotorData=fn_p_xMSLightGetMaxRangePulseInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSLight->xGiroAngle)));

		pvMotorData=fn_p_xMSLightGetGiroAngleInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetGiroAngleInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(fn_p_xMSLightGetColorRInit(p_tdstActor->h_MSLight));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(fn_p_xMSLightGetColorGInit(p_tdstActor->h_MSLight));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(fn_p_xMSLightGetColorBInit(p_tdstActor->h_MSLight));

		pvMotorData=fn_p_xMSLightGetNearInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetFarInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetLittleAlphaInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetBigAlphaInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetLittleTangentInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetBigTangentInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);
//CHINA WFQ (MT) 16/02/98 {
		pvMotorData=fn_p_stMSLightGetInterMinInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_stMSLightGetInterMaxInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_stMSLightGetExterMinInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_stMSLightGetExterMaxInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetIntensityMinInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSLightGetIntensityMaxInit(p_tdstActor->h_MSLight);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);
//ENDCHINA WFQ }
		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS6(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{

}

//**********************************************************************************************
//ANNECY CB
void fn_vFillMS7(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "ShiftTarget");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "ShiftTarget_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "ShiftPos");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "ShiftPos_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "DistMin");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "DistMin_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "DistMax");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "DistMax_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "BoundDist_Min");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "BoundDistMin_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "BoundDist_Max");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "BoundDistMax_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Alpha");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Alpha_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Shift_Alpha");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ShiftAlpha_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Theta");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Theta_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ShiftTheta");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ShiftTheta_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearIncreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearIncreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearDecreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "LinearDecreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularIncreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularIncreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularDecreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "AngularDecreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetIncreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetIncreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetDecreaseSpeed");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "TargetDecreaseSpeed_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(SHORT_INT, SIGNED_INT, "DNMFlags");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(SHORT_INT, SIGNED_INT, "DNMFlags_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(SHORT_INT, SIGNED_INT, "IAFlags");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(SHORT_INT, SIGNED_INT, "IAFlags_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Focal");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Focal_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ZMin");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ZMin_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ZMax");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "ZMax_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("TypeOfViewport"), "Viewport_Type");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("TypeOfViewport"), "ViewportType_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, SIGNED_INT, "Channel"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, SIGNED_INT, "Channel_Init"));
		/*---------------------------------------------------------------------------------------*/
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("IsActive");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("IsActive_Init", pclCurrentBaseData));
		/*---------------------------------------------------------------------------------------*/
		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_Cineinfo == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_Cineinfo));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->stShiftTarget)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->stShiftTarget)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->stShiftPos)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->stShiftPos)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xDistMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xDistMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xDistMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xDistMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xBoundDistMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xBoundDistMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xBoundDistMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xBoundDistMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngleAlpha)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngleAlpha)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngleShiftAlpha)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngleShiftAlpha)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngleTheta)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngleTheta)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngleShiftTheta)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngleShiftTheta)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xLinearSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xLinearSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xLinearIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xLinearIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xLinearDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xLinearDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngularSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngularSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngularIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngularIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xAngularDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xAngularDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xTargetSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xTargetSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xTargetIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xTargetIncreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xTargetDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xTargetDecreaseSpeed)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->uwDNMFlags)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->uwDNMFlags)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->uwIAFlags)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->uwIAFlags)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xFocal)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xFocal)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xZMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xZMin)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->xZMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->xZMax)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->eTypeOfViewport)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->eTypeOfViewport)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->cChannel)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->cChannel)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hCurrent->bIsActive)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Cineinfo->hInit->bIsActive)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}
//ENDANNECY CB

//**********************************************************************************************
void fn_vFillMS8(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, UNSIGNED_INT, "Character_Priority"));
// ANNECY AV {
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x01, "No_Collision_With_Map"                );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x01, "No_Collision_With_Map_Init", pclCurrentBaseData));

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x02, "No_Collision_With_Projectile"         );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x02, "No_Collision_With_Projectile_Init", pclCurrentBaseData));

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x04, "No_Collision_With_Secondary_Character");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x04, "No_Collision_With_Secondary_Character_Init", pclCurrentBaseData));

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x08, "No_Collision_With_Main_Character"	  );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x08, "No_Collision_With_Main_Character_Init", pclCurrentBaseData));

        pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x10, "Force_Collision_When_Not_Moving"	  );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x10, "Force_Collision_When_Not_Moving_Init", pclCurrentBaseData));

        pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x20, "No_Collision_With_Other_Sectors"	  );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x20, "No_Collision_With_Other_Sectors_Init", pclCurrentBaseData));

        pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x40, "No_Collision_Zde_With_Projectile"	  );
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBitFieldBooleanData	(0x40, "No_Collision_Zde_With_Projectile_Init", pclCurrentBaseData));
// END ANNECY AV }
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData	(CHAR_INT, UNSIGNED_INT, "Collision_Frequency");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData	(CHAR_INT, UNSIGNED_INT, "Collision_Frequency_Init", pclCurrentBaseData));

		pclCurrentBaseData = OAC_fn_pclAddObjectListData(pclActorMS->m_pclDataList, C_szZdeName);
    OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);

		pclCurrentBaseData = OAC_fn_pclAddObjectListData(pclActorMS->m_pclDataList, C_szZdmName);
    OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);

		pclCurrentBaseData = OAC_fn_pclAddObjectListData(pclActorMS->m_pclDataList, C_szZddName);
    OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);

		pclCurrentBaseData = OAC_fn_pclAddObjectListData(pclActorMS->m_pclDataList, C_szZdrName);
    OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_CollSet == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_CollSet));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCharacterPriority)));
// ANNECY AV {
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollisionFlag)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCharacterCollisionFlagInit(p_tdstActor->h_CollSet)));
// END ANNECY AV }
   		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->ucCollComputeFrequency)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_ucCollSetGetCollComputeFrequencyInit(p_tdstActor->h_CollSet)));

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->hZdeList)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->hZdmList)));
 		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->hZddList)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_CollSet->hZdrList)));

		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS9(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
 CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;
//		pclCurrentBaseData = OAC_fn_pclAddObjectListData(pclActorMS->m_pclDataList, C_szWayName);
//    OAC_M_AddOwnerData(pclCurrentBaseData);
//		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);
    pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName(g_c_csGraphEnumDescriptorName), "Reseau");
    OAC_M_AddOwnerData(pclCurrentBaseData);
    OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(CHAR_INT, SIGNED_INT, "Index"));
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Circulaire");
		OAC_M_AddOwnerData(pclCurrentBaseData);

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

 if ( p_tdstActor->h_MSWay == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_MSWay));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSWay->m_hPath)));
    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSWay->m_lIndex)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSWay->m_bIsCircular)));

		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS10(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("Is_Active"));

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_Micro == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_Micro));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Micro->bIsActive)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS15(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName(g_c_csSectorsEnumDescriptorName), "Current_Sector"));

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_SectInfo == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_SectInfo));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_SectInfo->hCurrentSector)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS16(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	CTL_Editor_EnumDescriptorList *pclListOfEnumDescriptors = &(g_pclInterface->m_clDocument.m_clListOfEnumDescriptors);

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName("PrtSource_Activation"), "Activation"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddEnumData(pclListOfEnumDescriptors->m_fn_pclGetEnumDescriptorByName(g_c_csPartGenEnumDescriptorName), "Particle_Gen"));

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	if ( p_tdstActor->h_MSPrtSrc == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_MSPrtSrc));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSPrtSrc->ucGeneratorActivation)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_MSPrtSrc->p_stParticleGenerator)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//**********************************************************************************************
void fn_vFillMS17(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	if ( !pclActorMS->m_bDataCreated )
	{
// ROMTEAM corrections (Nicu 06-02-98) {
        //OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "Satur_Distance"));
        //OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "BackGround_Distance"));

		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);

		OAC_FloatData *d = new OAC_FloatData(FLOAT, "Satur_Distance_Init", pclActorMS->m_pclDataList);
		pclActorMS->m_pclDataList->AddTail(d);
		OAC_M_AddOwnerData(d);

		d = new OAC_FloatData(FLOAT, "BackGround_Distance_Init", pclActorMS->m_pclDataList);
		pclActorMS->m_pclDataList->AddTail(d);
		OAC_M_AddOwnerData(d);

		//ANNECY CHRISTOPHE MODIFICATION
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		//ANNECY END CHRISTOPHE MODIFICATION
// END ROMTEAM corrections (Nicu) }

        pclActorMS->m_bDataCreated = TRUE;
	}

	if ( p_tdstActor->h_MSSound == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_MSSound));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_xMSSoundGetSaturationDistanceInit(p_tdstActor->h_MSSound)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(fn_p_xMSSoundGetBackGroundDistanceInit(p_tdstActor->h_MSSound)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}

//ANNECY BBB 17/10/97 {
//**********************************************************************************************
void fn_vFillMS18(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	if ( !pclActorMS->m_bDataCreated )
	{
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Shift_Phase"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Shift_Max"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddVectorData(FLOAT, "Shift_Plus"));

		pclActorMS->m_bDataCreated = TRUE;
	}

  if ( p_tdstActor->h_AnimEffect == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
    pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_AnimEffect));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_AnimEffect->stShiftPhase)));
    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_AnimEffect->stShiftMax)));
    (pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_AnimEffect->stShiftPlus)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}
//ENDANNECY BBB 17/10/97 }

// CHINA QZY (MT) 26/02/98 {
//**********************************************************************************************
void fn_vFillMS19(EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

	ERROR_ASSERT (p_tdstActor != NULL );

	if ( !pclActorMS->m_bDataCreated )
	{
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific

		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Far_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Near_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddDecimalData(FLOAT, "Strength_Init"));
		OAC_M_AddOwnerData(pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, UNSIGNED_INT, "Duration_Init"));
		pclActorMS->m_bDataCreated = TRUE;

		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
	}

	if ( p_tdstActor->h_MSMagnet == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		void	*pvMotorData;
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_MSMagnet));

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		
		pvMotorData=fn_p_xMSMagnetGetFarInit(p_tdstActor->h_MSMagnet);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSMagnetGetNearInit(p_tdstActor->h_MSMagnet);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_xMSMagnetGetStrengthInit(p_tdstActor->h_MSMagnet);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);

		pvMotorData=fn_p_ulMSMagnetGetDurationInit(p_tdstActor->h_MSMagnet);
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(pvMotorData);
	
		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}
// ENDCHINA QZY }

// Shaitan FastC {
//**********************************************************************************************
void fn_vFillMS20 (EdActors_EditorActor *pclActor, EdActors_ActorMiniStructure *pclActorMS)
{
	CAR_EDIT_TDSTACTOR *p_tdstActor;

	if ( !pclActorMS->m_bDataCreated )
	{
		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(OAC_fn_vDataHasBeenChanged);
		// End of CTL Specific
		///

		CTL_Editor_Data *pclCurrentBaseData;

		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddBooleanData("FastC_Run");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);
		pclCurrentBaseData = pclActorMS->m_pclDataList->m_fn_pclAddIntegerData(LONG_INT, SIGNED_INT, "FastC_Index");
		OAC_M_AddOwnerData(pclCurrentBaseData);
		OAC_fn_tdeSetLink(pclCurrentBaseData, OAC_LINK_MODE__ALWAYS_LINKED);

		pclActorMS->m_bDataCreated = TRUE;

		////
		// CTL Specific
		CTL_fn_vSetDefaultCallBackFunctionWhenDataHasChanged(NULL);
		// End of CTL Specific
		///
	}

	// specific init for the model
	if ( pclActor->m_fn_tdeGetActorType() == EDCAR_ACTOR_TYPE_MODEL)
	{
		p_tdstActor = pclActor->m_fn_ptdstGetMotorActor();

		if (p_tdstActor->h_Brain == NULL)
			fn_vBrainAlloc(p_tdstActor);
	}
	else
	{
		p_tdstActor = ((EdActors_EditorActorInstance *) pclActor)->m_fn_pclGetModel()->GetStruct();
	}
	
	if (p_tdstActor->h_Brain == NULL )
	{
		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();
		while ( pos != NULL )
			(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr(NULL);

		pclActorMS->m_tdeState = MS_STATE_UNALLOCATED;
	}
	else
	{
		//Sets Base Address
		pclActorMS->m_fn_vSetBaseAddress((void *)&(p_tdstActor->h_Brain));

		if (p_tdstActor->h_Brain->p_stMind->p_stAIModel == NULL)
			p_tdstActor->h_Brain->p_stMind->p_stAIModel = fn_p_stAllocAIModel();

		pclActorMS->m_bIsReallyAllocated = TRUE;

		POSITION pos = pclActorMS->m_pclDataList->GetHeadPosition();

		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Brain->p_stMind->p_stAIModel->CFast_bIsC)));
		(pclActorMS->m_pclDataList->GetNext(pos))->m_fn_vSetMotorDataPtr((void *)(&(p_tdstActor->h_Brain->p_stMind->p_stAIModel->CFast_lFunction)));

		//Checks if the end of the list was reached
		ERROR_ASSERT( pos == NULL );

 		pclActorMS->m_tdeState = MS_STATE_CLOSED;

		if ( !pclActorMS->m_bDataInitialized )
			pclActorMS->m_pub_fn_vInitializeAllData();
	}
}
//End Shaitan FastC }

//**********************************************************************************************
//Constructs the objects representing the enum definitions
void EdActors_MyDocument::m_fn_vConstructListOfEnumDescriptors()
{
	CTL_Editor_EnumDescriptor *pclEnumDescriptor;

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("ObjectinitInit", sizeof(tdeObjectinitInit));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Always", OI_Always);
	pclEnumDescriptor->m_fn_pclAddElement("Out Of Action Zone", OI_WhenPlayerGoOutOfActionZone);
	pclEnumDescriptor->m_fn_pclAddElement("Player is dead", OI_WhenPlayerIsDead);
	pclEnumDescriptor->m_fn_pclAddElement("Map just Loaded", OI_WhenMapJustLoaded);
	pclEnumDescriptor->m_fn_pclAddElement("Never Back When Taken", OI_NeverBackWhenTaken);
//	pclEnumDescriptor->m_fn_pclAddElement("Saved Game Just Loaded", OI_WhenSavedGameJustLoaded);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("ObjectinitInit_Restricted", sizeof(tdeObjectinitInit));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Out Of Action Zone", OI_WhenPlayerGoOutOfActionZone);
	pclEnumDescriptor->m_fn_pclAddElement("Never Back When Taken", OI_NeverBackWhenTaken);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ANNECY AV CLEAN_MEC {
/*
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("EnvironmentState", sizeof(DNM_tdeEnvironmentState));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Air", DNM_EnvAir);
	pclEnumDescriptor->m_fn_pclAddElement("Water", DNM_EnvWater);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
*/
// END ANNECY AV }

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ANNECY CB
#if 0
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("CameraStates", sizeof(e_ucCameraStates));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Go to optimal", CAM_e_State_GoToOptimal);
	pclEnumDescriptor->m_fn_pclAddElement("Undefined", CAM_e_State_Undefined);
	pclEnumDescriptor->m_fn_pclAddElement("Doom", CAM_e_State_Doom);
	pclEnumDescriptor->m_fn_pclAddElement("Fixe targeted", CAM_e_State_FixeTargeted);
//	pclEnumDescriptor->m_fn_pclAddElement("Looking", CAM_e_State_Looking);
	pclEnumDescriptor->m_fn_pclAddElement("Apex", CAM_e_State_Apex);
	pclEnumDescriptor->m_fn_pclAddElement("Fixed", CAM_e_State_Fixed);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
#endif
//ENDANNECY CB

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("TypeOfViewport", sizeof(e_ucListViewport));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("No Viewport", CAM_e_NoViewport);
	pclEnumDescriptor->m_fn_pclAddElement("Main", CAM_e_MainViewport);
	pclEnumDescriptor->m_fn_pclAddElement("Secondary", CAM_e_SecondaryViewport);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	/*
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("StreamType", sizeof(STR_tdeStreamType));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Error", STR_Stream_Error);
	pclEnumDescriptor->m_fn_pclAddElement("Cylinder Linear", STR_Stream_CylinderLinear);
	pclEnumDescriptor->m_fn_pclAddElement("Cylinder Radial", STR_Stream_CylinderRadial);
	pclEnumDescriptor->m_fn_pclAddElement("Cone", STR_Stream_Cone);
	pclEnumDescriptor->m_fn_pclAddElement("Cone Radial", STR_Stream_ConeRadial);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
	*/
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ANNECY AV CLEAN_MEC {
/*
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("FluidEnvironment", sizeof(DNM_tdeFluidEnvironment));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Error", DNM_Fluid_Error);
	pclEnumDescriptor->m_fn_pclAddElement("Air", DNM_Fluid_Air);
	pclEnumDescriptor->m_fn_pclAddElement("Water", DNM_Fluid_Water);
	pclEnumDescriptor->m_fn_pclAddElement("Lava", DNM_Fluid_Lava);
	pclEnumDescriptor->m_fn_pclAddElement("Undefined", DNM_Fluid_Undefined);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("MechanicsType", sizeof(DNM_tdeMechanicsID));

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Error", DNM_eMIC_Error);
	pclEnumDescriptor->m_fn_pclAddElement("Walk", DNM_ePtWalk);
	pclEnumDescriptor->m_fn_pclAddElement("Swim", DNM_ePtSwim);
	pclEnumDescriptor->m_fn_pclAddElement("Ski", DNM_ePtSki);
	pclEnumDescriptor->m_fn_pclAddElement("Camera", DNM_eCamera);
	pclEnumDescriptor->m_fn_pclAddElement("Jump", DNM_ePtJump);
	pclEnumDescriptor->m_fn_pclAddElement("Fly", DNM_ePtFly);
	pclEnumDescriptor->m_fn_pclAddElement("Lift", DNM_ePtLift);
	pclEnumDescriptor->m_fn_pclAddElement("Platform", DNM_ePtPlatform);
	pclEnumDescriptor->m_fn_pclAddElement("Move", DNM_ePtMove);
	pclEnumDescriptor->m_fn_pclAddElement("Helicopter", DNM_ePtHelicopter);
	pclEnumDescriptor->m_fn_pclAddElement("Stone", DNM_eSoStone);
	pclEnumDescriptor->m_fn_pclAddElement("Shooting", DNM_ePtShooting);
	pclEnumDescriptor->m_fn_pclAddElement("Hoo", DNM_eHook);
	pclEnumDescriptor->m_fn_pclAddElement("Raf", DNM_eRaft);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
*/
// END ANNECY AV }

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("CreatingMode", 4/*long*/);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Iso with distorsion", GLI_C_lIsoCamWithDistorsion);
	pclEnumDescriptor->m_fn_pclAddElement("Iso without distorsion", GLI_C_lIsoCamWithoutDistorsion);
	pclEnumDescriptor->m_fn_pclAddElement("Pers with distorsion", GLI_C_lPersCamWithDistorsion);
	pclEnumDescriptor->m_fn_pclAddElement("Pers without distorsion", GLI_C_lPersCamWithoutDistorsion);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("LightType", 4/*long*/);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Parallel", GLI_C_lParallelLight);
	pclEnumDescriptor->m_fn_pclAddElement("Spherical", GLI_C_lSphericalLight);
	pclEnumDescriptor->m_fn_pclAddElement("Hot Spot", GLI_C_lHotSpotLight);
	pclEnumDescriptor->m_fn_pclAddElement("Ambient", GLI_C_lAmbientLight);
	pclEnumDescriptor->m_fn_pclAddElement("ParallelBox", GLI_C_lParallelLight_With_Limit);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	//pclEnumDescriptor = new CTL_Editor_EnumDescriptor("SpecialPosFlag", 1/*unsigned char*/);

	//Adds strings to describe enum
	//pclEnumDescriptor->m_fn_pclAddElement("None", 0);
	//pclEnumDescriptor->m_fn_pclAddElement("Ed", 1);
	//pclEnumDescriptor->m_fn_pclAddElement("Camera", 2);

	//m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("Shadow_Quality", 2/*short*/);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("No shadow", 0);
	pclEnumDescriptor->m_fn_pclAddElement("Simple calculation", 1);
	pclEnumDescriptor->m_fn_pclAddElement("Complete calculation", 2);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//ANNECY jt {
/*
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("Dynam_Object_Type", 1);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Solid", DNM_C_lObjectType_Solid);
	pclEnumDescriptor->m_fn_pclAddElement("Liquid", DNM_C_lObjectType_Liquid);
	pclEnumDescriptor->m_fn_pclAddElement("Gas", DNM_C_lObjectType_Gas);
	pclEnumDescriptor->m_fn_pclAddElement("Plasma", DNM_C_lObjectType_Plasma);
	pclEnumDescriptor->m_fn_pclAddElement("Unknown", 0);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
*/
//ENDANNECY jt }


	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("PrtSource_Activation", 1);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Off", 0);
	pclEnumDescriptor->m_fn_pclAddElement("On", 1);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ANNECY AV {
/*
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("Collision_Flag", 1);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Only with Map", 0);
	pclEnumDescriptor->m_fn_pclAddElement("Map and Actors", 1);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
*/
// END ANNECY AV }

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("Platform_Type", 1);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("None", C_ucPlatFormType_None);
	pclEnumDescriptor->m_fn_pclAddElement("Standard", C_ucPlatFormType_StandardPlatForm);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);


	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("Mechanic_Size", 0);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Base", C_ucMechanic_Base);
	pclEnumDescriptor->m_fn_pclAddElement("Advanced", C_ucMechanic_Advanced);
	pclEnumDescriptor->m_fn_pclAddElement("Complex", C_ucMechanic_Complex );

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

/*
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor("LinkedToSector", 1);

	//Adds strings to describe enum
	pclEnumDescriptor->m_fn_pclAddElement("Nothing", 0);
	pclEnumDescriptor->m_fn_pclAddElement("turn", 1);
	pclEnumDescriptor->m_fn_pclAddElement("turn and save", 2);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
*/
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csActorsEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	m_pub_fn_vUpdateActorsEnumDescriptor();

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csBoxSetEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csInstanciatedItemEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csGameMaterialEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csSectorsEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csPartGenEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclEnumDescriptor = new CTL_Editor_EnumDescriptor(g_c_csGraphEnumDescriptorName, 4/*long*/);

	m_clListOfEnumDescriptors.AddTail(pclEnumDescriptor);

}

//**********************************************************************************************
//Constructs the objects representing the Masks definitions
void EdActors_MyDocument::m_fn_vConstructListOfMaskDescriptors()
{
	CTL_Editor_MaskDescriptor *pclAddedMaskDesc;

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	pclAddedMaskDesc = m_clListOfMasksDescriptors.m_pub_fn_pclAddMaskDescriptor("Draw_Mask");

	//Adds strings to describe Mask
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Textured", GLI_C_lIsTextured);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Gouraud", GLI_C_lIsGouraud);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not wired", GLI_C_lIsNotWired);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not grided", GLI_C_lIsNotGrided);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not doted", GLI_C_lIsNotDoted);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not outlined", GLI_C_lIsNotOutlined);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("** unused **", GLI_C_lIsUseShadow);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Draw Collide Info", GLI_C_lIsNotDrawCollideInformation);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Draw Collide Info Light", GLI_C_lIsNotDrawCollideInformationLight);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Force Color Material", GLI_C_lIsNotForceColorMaterial);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Testing Backface", GLI_C_lIsTestingBackface);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Compute Specular", GLI_C_lIsNotComputeSpecular);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Invert Backfaces", GLI_C_lNotInvertBackfaces);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not Light Alpha Sensitive", GLI_C_lIsNotLightAlphaSensitive);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not visible in mirrors", GLI_C_lIsNotVisibleInSymetricWorld);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Not visible in real world", GLI_C_lIsNotVisibleInRealWorld);
	//ANNECY VL 08/04/98{
	pclAddedMaskDesc->m_pub_fn_pclAddMask("No Sinus Effect", GLI_C_lHasNotSinusEffect);
	//ENDANNECY VL}

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//ANNECY Bart#02 20/04/98 {
	pclAddedMaskDesc = m_clListOfMasksDescriptors.m_pub_fn_pclAddMaskDescriptor("Actor_Capabilities");

	//Adds strings to describe Mask
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Translater", 0x1);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Marcher", 0x2);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Courir", 0x4);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Reculer", 0x8);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Sauter", 0x10);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Voler", 0x20);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Accrocher", 0x40);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Suspendre", 0x80);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Nager", 0x100);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Balancer", 0x200);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Bloquer", 0x400);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Teleporter", 0x800);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Glisser", 0x1000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Aspirer", 0x2000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_14", 0x4000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_15", 0x8000);

	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_16", 0x10000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_17", 0x20000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_18", 0x40000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_19", 0x80000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_20", 0x100000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_21", 0x200000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_22", 0x400000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_23", 0x800000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_24", 0x1000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_25", 0x2000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_26", 0x4000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_27", 0x8000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_28", 0x10000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_29", 0x20000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("custom_30", 0x40000000);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Has_All_Capabilities", 0x80000000);
//ENDANNECY Bart#02 }

	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*	pclAddedMaskDesc = m_clListOfMasksDescriptors.m_pub_fn_pclAddMaskDescriptor("Dynamics_Object_Type");

	//Adds strings to describe Mask
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Is Mobile", GLI_C_lIsTextured);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Unknown type", GLI_C_lIsGouraud);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Solid", GLI_C_lIsGouraud);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Liquid", GLI_C_lIsGouraud);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Gas", GLI_C_lIsGouraud);
	pclAddedMaskDesc->m_pub_fn_pclAddMask("Plasma", GLI_C_lIsGouraud);
*/}

