/*---------------------------------------------------------------------------*/
/* AI_Proto.c : */
/* author : Olivier Didelot.*/
/* date   : 30/01/1997*/
/* modify : 04/02/1997  Lint 0 warnings excepted those specified at the end of AIMacros.h*/
/* modify : 25/03/1997  minor changes to avoid non NULL pointers (for editor)*/
/* modify : Olivier Couvreur 23/04/97 MMG + DIR*/
/* modify : Olivier Couvreur 15/05/97 Safe second pass for DsgVar + ReinitAI*/
/*---------------------------------------------------------------------------*/
/*#define AI_D_DebugMalloc*/
 
#include "AIUseCPA.h"
 
#include "AI_Mmg.h"
#include "specif/AIOption.h"
#include "AIMacros.h"
#include "AI_Erm.h"
 
#include "StrIntel.h"
#include "Intell.h"
 
#include "Action.h"
#include "Operator.h"
#include "Cond.h"
#include "KeyWord.h"
#include "Procedur.h"
#include "Function.h"
#include "Fields.h"
 
#include "Convert.h"
 
#include "AI_Struc.h"
#define __DeclareGlobalVariableAIProto_h__
#include "AI_Proto.h"
#undef __DeclareGlobalVariableAIProto_h__
#include "ReadRule.h"
#include "DsgMem.h"
 
#define __DeclareGlobalVariableSafe_h__
#include "safe.h" /*BART*/
#undef __DeclareGlobalVariableSafe_h__
 
#ifdef ACTIVE_AIDEBUG   /*** DR ***/
#include "AID_Erm.h"
#include "AID_Main.h"
#include "specif/AID_Trac.h"
#endif
 
#ifdef U64 /*AR980625*/
/* LOL*/
#include "GLD/Specif/DisplMsg.h"
#else	/* MT300399 */
#include "SNA.h"
#include "GAM/Specif/Demos.h"
#include "PTC.h"
#endif
 
/*ANNECY CHRISTOPHE MODIFICATIONS CF XAVIER*/
#if defined(ACTIVE_EDITOR)
SCR_tdst_Link_Table *AI_fn_p_stGetDsgVarLinkTable(void)
{
	return &(g_stDefinesLinkTable);
}
#endif /* ACTIVE_EDITOR */
/*ANNECY END CHRISTOPHE MODIFICATIONS CF XAVIER*/
 
#ifdef ACTIVE_EDITOR
extern "C" ACP_tdxBool g_bUseSAIWithEditor;
#endif /* ACTIVE_EDITOR */
 
#if defined(ACTIVE_EDITOR)
/* To activate 2nd pass checking*/
#define ACTIVE_2NDPASS_CHECKING
#if defined(ACTIVE_2NDPASS_CHECKING)
  /*#pragma message("ACTIVE_2NDPASS_CHECKING is defined ==> editor will run automaticaly if an error occured in AI while loading")*/
#endif
#endif
 
#if defined(AI_USE_SCRIPT)
#define  M_GetLinkValueWithKey(lKey) SCR_M_ul_Link_GetValue( ((SCR_tdst_Link_Value *) (lKey)) )
#define  M_GetComportLinkValueWithKey(lKey) \
((SCR_M_e_Link_GetState((SCR_tdst_Link_Value *) (lKey) ) != SCR_ELS_Link_NotInitialized) ? \
fn_ulGetComportLinkValueWithKey((SCR_tdst_Link_Value *)(lKey)) : 0)
#endif /* AI_USE_SCRIPT */
 
#if defined(__DEBUG_AI__) || defined(ACTIVE_2NDPASS_CHECKING)
char szForErrorStringAt2ndPass[256];
#endif
 
#if defined(AI_USE_SCRIPT)
#if defined(ACTIVE_2NDPASS_CHECKING)
	#define M_TestLinkTableValue(p_stMind,lKey,szStr) \
	if (SCR_M_e_Link_GetState((SCR_tdst_Link_Value *) (lKey) ) == SCR_ELS_Link_NotInitialized) \
	{	\
        sprintf(szForErrorStringAt2ndPass,"%s in %s",szStr,AI_M_szGetPersoName((p_stMind))); \
		M_AIWarningErrorAndNeverStopForDebug(E_uwAIWarningReferenceNotLoaded,C_ucErmOpenInfoWindow, szForErrorStringAt2ndPass); \
        AI_M_ucErrorFlag((p_stMind))=1; \
		fn_vForceEditor(); \
    }
#elif defined(__DEBUG_AI__)
	#define M_TestLinkTableValue(p_stMind,lKey,szStr) \
	if (SCR_M_e_Link_GetState((SCR_tdst_Link_Value *) (lKey) ) == SCR_ELS_Link_NotInitialized) \
	{	\
        sprintf(szForErrorStringAt2ndPass,"%s in %s",szStr,AI_M_szGetPersoName((p_stMind))); \
		M_AIFatalErrorMsg(E_uwAIFatalReferenceNotLoaded, szForErrorStringAt2ndPass); \
	}
#else
	#define M_TestLinkTableValue(p_stMind,lKey,szStr)
#endif /* ACTIVE_2NDPASS_CHECKING */
#endif /* AI_USE_SCRIPT */
 
#define _WP_D_DEFINE_WAYPOINTS_
#include "WP_Func.h"
#undef  _WP_D_DEFINE_WAYPOINTS_ 
 
#if defined(__DEBUG_AI__)
#define AI_LOGFILE
#endif
 
#if defined(AI_LOGFILE) 
#include <stdio.h>
FILE *fpAILogFile=NULL;
#define AI_ANIM_LOGFILE "AI_ANIM.LOG"
 
FILE *fpAIUnusedComportLogFile=NULL;
#define AI_UNUSEDCOMPORT_LOGFILE "AI_UnusedComport.LOG"
 
#endif
 
#if defined(AI_USE_SCRIPT)
unsigned long fn_ulGetComportLinkValueWithKey(SCR_tdst_Link_Value *p_stLinkValue)
{
	/* Give the value 1 to long1.*/
	SCR_M_v_Link_SetAdditionalLong(p_stLinkValue, 4, 1);
	return SCR_M_ul_Link_GetValue(p_stLinkValue);
}
#endif /* AI_USE_SCRIPT */
 
void fn_vTestUnusedComport()
{
#if defined(AI_LOGFILE) 
	unsigned int uiPos = 0, i=0;
	SCR_tdst_Link_Value	*p_stLinkValue = NULL;
 
	/* Get first element of array */
	SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value, uiPos, p_stLinkValue, SCR_M_st_Link_GetDynamicArray(&g_stComportLinkTable));
	
	while (p_stLinkValue != NULL) /* p_sValue is NULL at the end of the array */
	{
		/* Test current retrieved value */
		if (SCR_M_e_Link_GetState(p_stLinkValue) == SCR_ELS_Link_Initialized)
		{
			if (SCR_M_ul_Link_GetAdditionalLong(p_stLinkValue, 4) == 0)
			{
				if (fpAIUnusedComportLogFile)
				{
					fprintf(fpAIUnusedComportLogFile,"%s\n",SCR_M_p_sz_Link_GetKey(p_stLinkValue));
				}
			}
		}
		
		/* Get next element */
		uiPos++;
		SCR_M_DyAr_GetNextElement(SCR_tdst_Link_Value, uiPos, p_stLinkValue, SCR_M_st_Link_GetDynamicArray(&g_stComportLinkTable));
	}
	if (fpAIUnusedComportLogFile)
	{
		fclose(fpAIUnusedComportLogFile);
		fpAIUnusedComportLogFile=NULL;
	}
#endif /* AI_LOGFILE*/
}
 
/* to delete later : not used*/
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void fn_vReinitComportMind(AI_tdxHandleToMind p_stMind)
{
	fn_vReinitComport(AI_M_p_stGetIntelligence(p_stMind));
	fn_vReinitComport(AI_M_p_stGetReflex(p_stMind));
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
unsigned long AI_ulSizeOfMind()
{
  return(sizeof(AI_tdstMind));
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
AI_tdstMind *fn_pstAllocMind(void)
{
	AI_tdstMind *p_stMind=NULL;
    MMG_fn_vAddMemoryInfo (MMG_C_lTypeAI , MMG_C_lSubTypeMind , NULL);
	M_AIAlloc(p_stMind, AI_tdstMind *, sizeof(AI_tdstMind));
	
	/* to be sure (for editor)*/
	AI_M_SetAIModel(p_stMind,NULL);
	AI_M_SetIntelligence(p_stMind,NULL);
	AI_M_SetReflex(p_stMind,NULL);
	AI_M_SetDsgMem(p_stMind,NULL);
 
    #if defined(ACTIVE_EDITOR)
    AI_M_ucErrorFlag(p_stMind)=0;           
    #endif
 
	AI_M_SetDoingIntel(p_stMind, 0);
 
#if defined(ACTIVE_EXEC_CHECKING) && defined(ACTIVE_EDITOR)
	fn_vReSetStopAIEngineFlag();
#endif
 
#ifdef ACTIVE_AIDEBUG /*** DR to initialize the trace ***/
/* Oliv' - use accessors instead of direct member - 25/11/1998*/
/*	p_stMind->p_stTrace=NULL;*/
	AI_M_SetTrace( p_stMind, NULL );
/* EndOfOliv'*/
	AIDebug_M_InitTrace( p_stMind );
	AIDebug_M_InitBuffer( p_stMind );
#endif
 
//XB 05/08/99
#ifndef D_THROW_CFAST_AI
//End XB
	p_stMind->CFast_lCmpMetaAction = 0; 
	p_stMind->CFast_lRfxMetaAction = 0; 
	p_stMind->CFast_lCmpMetaActionForMacro = 0; 
	p_stMind->CFast_lRfxMetaActionForMacro = 0; 
//XB 05/08/99
#endif /* D_THROW_CFAST_AI */
//End XB
 
	return p_stMind;
}
 
void fn_vFirstInitAIMemory()
{
	Erm_M_InitErrMsg(AI);
	Mmg_M_InitMmg(AI);
	
#if defined(AI_LOGFILE) 
	remove(AI_ANIM_LOGFILE);
	fpAILogFile=NULL;
	remove(AI_UNUSEDCOMPORT_LOGFILE);
	fpAIUnusedComportLogFile=NULL;
#endif
}
 
void fn_vInitAIFixMemory(unsigned long ulSize)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	#if !defined(U64)
		Mmg_M_InitSpecificBlock(AI, E_ucAIBlockFix, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
	#else /* !U64 */
		#ifdef CHECK_MEMORY
			Mmg_M_InitSpecificBlock(AI, E_ucAIBlockFix, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
		#else /* CHECK_MEMORY */
			Mmg_M_InitSpecificBlock(AI, E_ucAIBlockFix, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithoutFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
		#endif /* CHECK_MEMORY */
	#endif /* !U64 */
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
 
void fn_vInitAILevelMemory(unsigned long ulSize)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	#if !defined(U64)
		Mmg_M_InitSpecificBlock(AI, E_ucAIBlockLevel, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
	#else /* !U64 */
		#ifdef CHECK_MEMORY
			Mmg_M_InitSpecificBlock(AI, E_ucAIBlockLevel, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
		#else /* CHECK_MEMORY */
			Mmg_M_InitSpecificBlock(AI, E_ucAIBlockLevel, ulSize, C_ulDefaultMaxNbStaticMalloc, 4, C_BlockWithoutFreeFlag | C_Check_AlignementFlag | C_Check_OverflowFlag);
		#endif /* CHECK_MEMORY */
	#endif /* !U64 */
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void fn_vFreeAIFixMemory(void)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	Mmg_M_FreeBlock(AI, E_ucAIBlockFix);
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
void fn_vFreeAILevelMemory(void)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	Mmg_M_FreeBlock(AI, E_ucAIBlockLevel);
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void fn_vDeleteAIFixMemory(void)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	Mmg_M_DeleteBlock(AI, E_ucAIBlockFix);
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
void fn_vDeleteAILevelMemory(void)
{
#ifdef MODE_STATIC_MEM_FOR_AI
	Mmg_M_DeleteBlock(AI, E_ucAIBlockLevel);
#endif /* MODE_STATIC_MEM_FOR_AI*/
}
 
#if !defined(RETAIL) || defined(FINAL_VERSION_FOR_TESTERS)
void AI_PrintUsedStaticMemory(void)
{
	Mmg_M_PrintUsedStaticMemoryInModule(AI);
}
#endif /* !defined(RETAIL) || defined(FINAL_VERSION_FOR_TESTERS) */
 
/**************************************************************************/
/*XB*/
#ifdef CHECK_MEMORY
void AI_CheckMemory(void)
{
	Mmg_M_CheckMemory(AI);
}
#endif /* CHECK_MEMORY */
/*End XB*/
 
/**************************************************************************/
/* XB 02/06/99 */
#ifndef FINAL_VERSION
unsigned long AI_fn_ulGetUsedStaticMemory(void)
{
	return Mmg_M_GetUsedStaticMemory(AI);
}
#endif /* FINAL_VERSION */
/* End XB 02/06/99 */
 
/***************************************
 * Set the memory block used by the AI *
 ***************************************/
void AI_fn_vAIUseFixMemory(void)
{
 AI_g_ucMemoryBlockUsed = E_ucAIBlockFix;
}
 
void AI_fn_vAIUseLevelMemory(void)
{
 AI_g_ucMemoryBlockUsed = E_ucAIBlockLevel;
}
 
unsigned char AI_g_ucDynamicAlloc = FALSE;
 
void *AI_fn_p_vTrueAlloc(unsigned long ulSize)
{
 void *p_vPointer = NULL;
	
 M_AIChooseMemoryBlock();
 
#if defined(U64) && !defined(FINAL_VERSION)
 g_ucModuleIdForDebug=1;
#endif
 
 if (AI_g_ucDynamicAlloc||(p_vPointer = Mmg_fn_p_vAlloc4Ch(ulSize,C_ucMmgDefaultChannel))==NULL)
 {
  #if defined(_DEBUG)
  if (!AI_g_ucDynamicAlloc)
  {
   Erm_M_ClearLastError(C_ucErmDefaultChannel);
   M_AIWarningError(E_uwAIDebugDynamicAllocation,C_ucErmOpenInfoWindow);
   Erm_M_ClearLastError(C_ucErmDefaultChannel);
   AI_g_ucDynamicAlloc = TRUE;
  }
  Mmg_M_SetModeAlloc4Ch(AI,E_ucDynamic,C_ucMmgDefaultChannel);
  p_vPointer = Mmg_fn_p_vAlloc4Ch(ulSize,C_ucMmgDefaultChannel);
  #endif /* _DEBUG */
 }
 memset(p_vPointer,0,ulSize);
 
#if defined(U64) && !defined(FINAL_VERSION)
 g_ucModuleIdForDebug=0xff;
#endif
 
 return (p_vPointer);
}
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void *AI_fn_p_vTrueRealloc(void *p_vOldPointer,unsigned long ulSize)
{
 void *p_vPointer = NULL;
	
 M_AIChooseMemoryBlock();
 
 if (AI_g_ucDynamicAlloc||(p_vPointer = Mmg_fn_p_vRealloc4Ch(p_vOldPointer,ulSize,C_ucMmgDefaultChannel))==NULL)
 {
  #if defined(_DEBUG)
  if (!AI_g_ucDynamicAlloc)
  {
   Erm_M_ClearLastError(C_ucErmDefaultChannel);
   M_AIWarningError(E_uwAIDebugDynamicAllocation,C_ucErmOpenInfoWindow);
   Erm_M_ClearLastError(C_ucErmDefaultChannel);
   AI_g_ucDynamicAlloc = TRUE;
  }
  Mmg_M_SetModeAlloc4Ch(AI,E_ucDynamic,C_ucMmgDefaultChannel);
  p_vPointer = Mmg_fn_p_vAlloc4Ch(ulSize,C_ucMmgDefaultChannel);
  memcpy(p_vPointer,p_vOldPointer,ulSize);
  AI_fn_vTrueFree(p_vOldPointer);
  #endif /* _DEBUG */
 }
 return (p_vPointer);
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void AI_fn_vTrueFree(void *p_vPointer)
{
 #if defined(_DEBUG)
 unsigned short uwBlocId;
 void *p_vBeginBloc;
 #endif /* _DEBUG */
 
 #if defined(_DEBUG)
/* Mmg_fn_vTestMallocIntegrityAt(p_vPointer);*/
 #endif /*_DEBUG*/
 
 M_AIChooseMemoryBlock();
 #if defined(_DEBUG)
 Mmg_fn_vWhereIs((void*)p_vPointer,&uwBlocId,&p_vBeginBloc);
 if (uwBlocId==0xffff)
  Mmg_M_SetModeAlloc4Ch(AI,E_ucDynamic,C_ucMmgDefaultChannel);
 else
  Mmg_M_SetModeAlloc4Ch(AI,uwBlocId&0x00ff,C_ucMmgDefaultChannel);
 #endif /* _DEBUG */
 Mmg_fn_vFree4Ch(p_vPointer,C_ucMmgDefaultChannel);
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC - Oliv' */
void AI_fn_vMemoryLogFile(void *p_vPointer,unsigned char ucAction,char *szFile,unsigned long ulLine)
{
 #if defined(_DEBUG)&& defined(AI_D_DebugMalloc)
 static unsigned long AI_s_ulNumberOfAllocation = 0;
 FILE *p_stFile;
 char szFileName[30];
 unsigned short uwBlocId;
 void *p_vBeginBloc;
 
 Mmg_fn_vWhereIs((void*)p_vPointer,&uwBlocId,&p_vBeginBloc);
 sprintf(szFileName,"Mem%04x.log",uwBlocId);
 if ((p_stFile = fopen(szFileName,"rt"))!=NULL) 
  fclose(p_stFile);
 else
  AI_s_ulNumberOfAllocation = 0;
 p_stFile = fopen(szFileName,"at");
 if (p_stFile!=NULL)
 {
  if (ucAction==AI_C_ActionMalloc) 
  {
   AI_s_ulNumberOfAllocation++;
   fprintf(p_stFile,"Malloc  : Number=#%010d, Block=#%04x, Offset=%p (%20s,%10d)\n",AI_s_ulNumberOfAllocation,uwBlocId,(long)p_vPointer-(long)p_vBeginBloc,szFile,ulLine);
  }
  if (ucAction==AI_C_ActionRealloc) 
  {
   fprintf(p_stFile,"Realloc : Number=#%010d, Block=#%04x, Offset=%p (%20s,%10d)\n",AI_s_ulNumberOfAllocation,uwBlocId,(long)p_vPointer-(long)p_vBeginBloc,szFile,ulLine);
  }
  else if (ucAction==AI_C_ActionFree) 
  {
   AI_s_ulNumberOfAllocation--;
   fprintf(p_stFile,"Free    : Number=#%010d, Block=#%04x, Offset=%p (%20s,%10d)\n",AI_s_ulNumberOfAllocation,uwBlocId,(long)p_vPointer-(long)p_vBeginBloc,szFile,ulLine);
  }
  fclose(p_stFile);
 }
 
 #endif /* _DEBUG && AI_D_DebugMalloc */
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC - Oliv' */
 
void fn_vInitAI(ACP_tdxBool _bLoadSnapShot)
{
    /* init function pointers tables*/
#if !defined(OPTIMIZED_COMMAND)
	fn_vInitFieldEntries();
 	fn_vInitOperatorEntries();
	fn_vInitMetaActionEntries();
	fn_vInitProcedureEntries();
	fn_vInitConditionEntries();
	fn_vInitFunctionEntries();
	fn_vInitKeyWordEntries();
#endif
	
#ifdef ACTIVE_AIDEBUG   /*** DR ***/
	AIDebug_fnv_InitMain();
#endif /*ACTIVE_AIDEBUG*/
 
	/* Blocking action management*/
	g_ucNewActionReturn = C_ACTION_ENGINE_NOTDEFINED; /* to set the action type using the script*/
	g_ucUseDefaultActionReturn = TRUE;/* the g_ucNewActionReturn is not taking into account*/
	
#if defined(AI_USE_SCRIPT)
	SCR_fn_v_Link_InitTable(&g_stMacroLinkTable);	
 
	SCR_fn_v_Link_InitTable(&g_stComportLinkTable);	
	SCR_fn_v_Link_InitTable(&g_stModelLinkTable);
	SCR_fn_v_Link_InitTable(&g_stDsgVarLinkTable);
	SCR_fn_v_Link_InitTable(&g_stDefinesLinkTable);
 
#endif /* AI_USE_SCRIPT */
	if (!_bLoadSnapShot)
		fn_vReadAIDefines(C_DefineAIFiles);
}
 
/*---------------------------------------------------------------------------*/
/*                        Moteur d'intelligence du Perso.*/
/*---------------------------------------------------------------------------*/
ACP_tdxBool fn_bDoIntelligencePerso(HIE_tdxHandleToSuperObject p_SuperObjPerso)
{
	AI_tdstMind *p_stPerso = AI_M_stGetMindOfSuperObj(p_SuperObjPerso);
	AI_M_SetDoingIntel(p_stPerso, 1);
    
	/* to avoid problems*/
	if (AI_M_p_stGetIntelligence(p_stPerso)!=NULL)
	{
#ifdef ACTIVE_AIDEBUG   /*** DR ***/
		if ( AI_M_p_stGetReflex(p_stPerso) == NULL ) /*for mind with intelligence but no reflex*/
		{
#ifndef U64_AIDEBUG
			AIDebug_M_EnterEngineLoop( p_stPerso );
#else
			AIDebug_M_EnterEngineLoop( p_SuperObjPerso );
#endif /* U64_AIDEBUG */
		}
		AIDebug_M_SetReflexOrAI( p_stPerso, AI_M_bGetDoingIntel(p_stPerso) );
#endif /*ACTIVE_AIDEBUG*/
		return fn_bIntelligenceEngine(p_SuperObjPerso, AI_M_p_stGetIntelligence(p_stPerso));
	}
	else 
		return FALSE;
}
 
/*---------------------------------------------------------------------------*/
/*                           Moteur de reflexe du Perso.*/
/*---------------------------------------------------------------------------*/
ACP_tdxBool fn_bDoReflexPerso(HIE_tdxHandleToSuperObject p_SuperObjPerso)
{
	AI_tdstMind *p_stPerso = AI_M_stGetMindOfSuperObj(p_SuperObjPerso);
    
	AI_M_SetDoingIntel(p_stPerso, 0);
    
	/* to avoid problems*/
	if (AI_M_p_stGetReflex(p_stPerso)!=NULL)
	{
#ifdef ACTIVE_AIDEBUG   /*** DR ***/
#ifndef U64_AIDEBUG
		AIDebug_M_EnterEngineLoop( p_stPerso );
#else
		AIDebug_M_EnterEngineLoop( p_SuperObjPerso );
#endif /* U64_AIDEBUG */
		AIDebug_M_SetReflexOrAI( p_stPerso, AI_M_bGetDoingIntel(p_stPerso) );
#endif /*ACTIVE_AIDEBUG*/
		return fn_bIntelligenceEngine(p_SuperObjPerso, AI_M_p_stGetReflex(p_stPerso));
	}
	else
		return FALSE;
}
 
#if defined(AI_USE_SCRIPT)
void fn_vSecondPassOfTree(AI_tdxHandleToMind p_stMind,tdstTreeInterpret *p_stTree)
{
	unsigned short i;
	tdstNodeInterpret *p_stNode;
	long lKey;
 
#if !defined(__DEBUG_AI__)		        
    p_stMind=p_stMind;
#endif
	
	if (p_stTree != NULL)
	{
		for (i = 0; i < M_GetNbNodeInterpret(p_stTree); i++)
		{
			p_stNode = M_GetNodeInterpretN(p_stTree, i);
			lKey=M_lKeyLinkInterpret(p_stNode);
 
			switch (M_GetTypeInterpret(p_stNode))
			{			
 
			case E_ti_MacroRef:
				M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_p_stMacroInterpret(p_stNode) = (tdstMacro*) (M_GetLinkValueWithKey(lKey));
				break;
			case E_ti_ModelRef:
			    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_p_stModelInterpret(p_stNode) = (AI_tdstAIModel*) (M_GetLinkValueWithKey(lKey));
				break;
 
			case E_ti_DsgVar:
				M_SetTypeInterpret(p_stNode,E_ti_DsgVarRef);
				break;
 
			case E_ti_DsgVarRef:
			    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_lValueInterpret(p_stNode) = (long) (M_GetLinkValueWithKey(lKey));
				break;
 
			case E_ti_SuperObjectRef:
			    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_SuperObjectInterpret(p_stNode) = (HIE_tdxHandleToSuperObject)(M_GetLinkValueWithKey(lKey));
				break;
			
			case E_ti_PersoRef:
				{
					struct tdstEngineObject_ *p_stEngineObject;

					M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
					p_stEngineObject = M_p_stPersoRefInterpret(p_stNode) = (tdstEngineObject *)(M_GetLinkValueWithKey(lKey));
					#if defined (ACTIVE_EDITOR)
					/* if the reference is on an always */
					if ( p_stEngineObject && (p_stEngineObject != (void *)0x12345678) && fn_ucIsAnAlwaysObject(p_stEngineObject) )
					{
						/* look for the corresponding entry in the always table and mark it referenced */
						/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
						unsigned long				i;
						ALW_tdxHandleToModelList	h_AlwaysModelChild;
						/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
						LST2_M_DynamicForEachElementOf(&(g_stAlways.ALW_h_LstAlwaysModel),h_AlwaysModelChild,i)
						{
							if ( M_ObjectGetPersonalType(p_stEngineObject) == M_ObjectGetPersonalType(h_AlwaysModelChild->p_stAlwaysObject))
							{
								g_stAlways.d_bIsReferencedInLevel[i] = TRUE;
								break;
							}
						}
					}
					#endif /* ACTIVE_EDITOR */
				}
				break;
				
			case E_ti_ModuleRef:
				M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_lModuleInterpret(p_stNode) = (long)(M_GetLinkValueWithKey(lKey));
				break;
 
			case E_ti_ActionRef:
#if defined(AI_LOGFILE) 
				if (fpAILogFile)
				{
#ifdef _DEBUG_STRING_FOR_PLA_
					if (SCR_M_e_Link_GetState((SCR_tdst_Link_Value *) (lKey) ) != SCR_ELS_Link_NotInitialized) 					
					{
					  tdxHandleToState h_State =(tdxHandleToState) (M_GetLinkValueWithKey(lKey));
					  tdstAnim3d *p_stAnim=fn_p_stGetAnimInState(h_State);
					  fprintf(fpAILogFile,"%s : %s\n",p_stAnim->szAnimName,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
					}
#endif
				}
#endif
 
			    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_ActionInterpret(p_stNode) = (tdxHandleToState)(M_GetLinkValueWithKey(lKey));
				break;
				
			case E_ti_ComportRef:
			    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_ComportInterpret(p_stNode) = (tdstComport *)(M_GetComportLinkValueWithKey(lKey));
				break;
				
			case E_ti_WayPointRef:
	  		    M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_lWayPointInterpret(p_stNode) = (WP_tdhWayPoint)(M_GetLinkValueWithKey(lKey));
				break;
 
			case E_ti_ObjectTableRef:
				M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_lModuleInterpret(p_stNode) = (long)(M_GetLinkValueWithKey(lKey));
				break;
 
			case E_ti_GameMaterialRef:
				M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_GameMaterialInterpret(p_stNode) = (GMT_tdxHandleToGameMaterial)(M_GetLinkValueWithKey(lKey));
#ifndef U64
				DEMO_fn_vPutGMTInList ((GMT_tdxHandleToGameMaterial)(M_GetLinkValueWithKey(lKey)));
#endif
				break;
 
/* ANNECY MT - 25/09/98 {*/
			case E_ti_Graph:
				M_TestLinkTableValue(p_stMind,lKey,SCR_M_p_sz_Link_GetKey((SCR_tdst_Link_Value *) (lKey)));
				M_p_stGraphInterpret(p_stNode) = (WP_tdHandleOfGraph)(M_GetLinkValueWithKey(lKey));
				break;
/* END ANNECY MT }*/
			}
		}
	}
}
 
void CFast_vInitStaticTree ( struct tdstNodeInterpret_ *, long, struct tdstNodeInterpret_ * ) ;
 
void fn_vSecondPassOfScriptAI(AI_tdxHandleToMind p_stMind,tdstScriptAI *p_stScriptAI)
{
	unsigned long i;
	unsigned char j;
	tdstComport *p_stComport;
	
	/* Loop on comport.*/
 
	for (i = 0; i < M_GetScriptAINbComport(p_stScriptAI); i++)
	{
		p_stComport = M_GetScriptAIComportN(p_stScriptAI, i);
		
		/* Second pass on Schedule.*/
		fn_vSecondPassOfTree(p_stMind,M_GetComportSchedule(p_stComport));
		
		/* Second pass on Rules.*/
		for (j = 0; j < M_GetComportNbRules(p_stComport); j++)
		{
			fn_vSecondPassOfTree(p_stMind,M_GetComportRuleN(p_stComport, j));
		}
	}
  /* CFAST : init reference */
  CFast_vInitStaticTree ( p_stMind->p_stAIModel->CFast_dst_ParamArray, 
                          p_stMind->p_stAIModel->uwNbParamNode, 
                          p_stMind->p_stAIModel->CFast_dst_RefTreeArray) ; 
}
#endif /* AI_USE_SCRIPT */
 
void fn_vReinitDesignerVariablesWithFlags(AI_tdxHandleToMind p_stMind,tdeObjectTreeInit eObjIniType)
{
	if (p_stMind!=NULL)
	{
		/* if designer variable*/
		if (M_GetDsgMem(p_stMind)!=NULL)
		{
			char *ptrSrc=NULL;
			char *ptrDst=M_GetDsgMemBuffer(p_stMind);
			unsigned char ucVarId;
 
		    /* reinit current values*/
			if (M_GetDsgMemBufferInit(p_stMind)==NULL)
			{
				/* from init values in model */
				ptrSrc=M_GetDsgMemDefaultInit(p_stMind);
			}
			else
			{
				/* from init values in perso*/
				ptrSrc=M_GetDsgMemBufferInit(p_stMind);
			}        
 
			/* loop on each dsgvar*/
			for (ucVarId=0;ucVarId<M_GetNbDsgVar(p_stMind);ucVarId++)
			{
				tdeDsgVarTypeId eDsgVarType=M_GetDsgVarType(p_stMind,ucVarId);
				
				/* don't reinit list*/
				if (eDsgVarType==eDsgVarType_List)
				{
/* ANNECY MT - 05/10/98 {*/
					tdstList *p_stDstList=(tdstList*) ( (char*) (ptrDst+M_GetDsgVarOffset(p_stMind,ucVarId)) );
					tdstList *p_stSrcList=(tdstList*) ( (char*) (ptrSrc+M_GetDsgVarOffset(p_stMind,ucVarId)) );
 
					M_InitList(p_stDstList,M_ucGetMaxSizeOfList(p_stSrcList));
/* END ANNECY MT }*/
				}
				/*
				// don't reinit array
				else if (fn_GetDsgVarType(eDsgVarType)==E_vt_Array)
				{
				}
				*/
				else /* array too*/
				{
					tdeObjectTreeInit eFlags=M_GetDsgVarInitType(p_stMind,ucVarId);
			
					/* if we have to reinit this DsgVar*/
					if (eObjIniType<=eFlags)
					{
						/* Offset of value of DsgVar*/
						unsigned long ulMyVarOffset=M_GetDsgVarOffset(p_stMind,ucVarId);
						unsigned long ulMyVarSize;
 
						if (fn_GetDsgVarType(eDsgVarType)==E_vt_Array)
						{
							 tdstArray *p_stArray=(tdstArray*) M_GetDsgVarAddrDefault(p_stMind,ucVarId);
							 ulMyVarSize=fn_ulSizeOfDsgVar(eDsgVarType,M_ARRAY_SIZE(p_stArray));	
						}
						else
							ulMyVarSize=fn_ulSizeOfDsgVar(eDsgVarType,0);
						memcpy(ptrDst + ulMyVarOffset,ptrSrc + ulMyVarOffset,ulMyVarSize);
					}	  
				} 
			}
		}
	}
}
 
/* POTICHE*/
 
void FirstInitDesignerVariables(AI_tdxHandleToMind p_stMind)
{
	if (p_stMind!=NULL)
	{
		/* if designer variable*/
		if (M_GetDsgMem(p_stMind)!=NULL)
		{			
			/* copy current values*/
			if (M_GetDsgMemBufferInit(p_stMind)==NULL)
			{
				/* from init values in model */
				memcpy(M_GetDsgMemBuffer(p_stMind),M_GetDsgMemDefaultInit(p_stMind),M_GetDsgVarSize(p_stMind));
			}
			else
			{
				/* from init values in perso*/
				memcpy(M_GetDsgMemBuffer(p_stMind),M_GetDsgMemBufferInit(p_stMind),M_GetDsgVarSize(p_stMind));
			}
		}
	}
}
 
void ReinitDesignerVariables(AI_tdxHandleToMind p_stMind)
{
/* ANNECY MT - 11/09/98 {*/
	/*
	if (p_stMind!=NULL)
	{
		// if designer variable
		if (M_GetDsgMem(p_stMind)!=NULL)
		{
			// copy current values
			if (M_GetDsgMemBufferInit(p_stMind)==NULL)
			{
				// from init values in model 
				memcpy(M_GetDsgMemBuffer(p_stMind),M_GetDsgMemDefaultInit(p_stMind),M_GetDsgVarSize(p_stMind));
			}
			else
			{
				// from init values in perso
				memcpy(M_GetDsgMemBuffer(p_stMind),M_GetDsgMemBufferInit(p_stMind),M_GetDsgVarSize(p_stMind));
			}
		}
	}
	*/
	if (p_stMind!=NULL)
	{
		/* if designer variable*/
		if (M_GetDsgMem(p_stMind)!=NULL)
		{
			char *ptrSrc=NULL;
			char *ptrDst=M_GetDsgMemBuffer(p_stMind);
			unsigned char ucVarId;
			
			/* reinit current values*/
			if (M_GetDsgMemBufferInit(p_stMind)==NULL)
			{
				/* from init values in model */
				ptrSrc=M_GetDsgMemDefaultInit(p_stMind);
			}
			else
			{
				/* from init values in perso*/
				ptrSrc=M_GetDsgMemBufferInit(p_stMind);
			}        
			
			/* loop on each dsgvar*/
			for (ucVarId=0;ucVarId<M_GetNbDsgVar(p_stMind);ucVarId++)
			{
				tdeDsgVarTypeId		eDsgVarType	= M_GetDsgVarType(p_stMind,ucVarId);
				tdeObjectTreeInit	eFlags		= M_GetDsgVarInitType(p_stMind,ucVarId);
 
				if (eFlags != OTI_WhenGameStart)
				{
					/* Offset of value of DsgVar*/
					unsigned long ulMyVarOffset=M_GetDsgVarOffset(p_stMind,ucVarId);
					unsigned long ulMyVarSize;
 
					if (fn_GetDsgVarType(eDsgVarType)==E_vt_Array)
					{
						 tdstArray *p_stArray=(tdstArray*) M_GetDsgVarAddrDefault(p_stMind,ucVarId);
						 ulMyVarSize=fn_ulSizeOfDsgVar(eDsgVarType,M_ARRAY_SIZE(p_stArray));	
					}
					else
						ulMyVarSize=fn_ulSizeOfDsgVar(eDsgVarType,0);
					memcpy(ptrDst + ulMyVarOffset,ptrSrc + ulMyVarOffset,ulMyVarSize);
				}	  
			}
		}
	}	
	/**/
/* END ANNECY MT }*/
}
 
 
void fn_vInsertDsgvarOneDsgVarInSAI(char *p_MyVarAddr,tdeDsgVarTypeId eDsgVarType,SAI_tdeFlags eFlags)
{
	switch(eDsgVarType)
	{
		/* pointers*/
		case eDsgVarType_WayPoint:
		case eDsgVarType_Comport:
		case eDsgVarType_Action:
		case eDsgVarType_Perso:
		case eDsgVarType_GameMaterial:
		  SAI_fn_bInsertPointerInTable((void *) p_MyVarAddr, eFlags);
		  break;
		case eDsgVarType_List: 
	   	  /* never initialized so nothing to do*/
		  break;
		case eDsgVarType_PersoArray:
		case eDsgVarType_VectorArray:
		case eDsgVarType_FloatArray:
		case eDsgVarType_IntegerArray:
		case eDsgVarType_WayPointArray:
		case eDsgVarType_TextArray:
		  /* should not happen*/
		  break;
 
/* Oliv' 06/08/1998*/
#if !defined(U64)
 
		default:
  		  /* values*/
		  SAI_fn_bInsertArrayInTable((void *) p_MyVarAddr, fn_ulSizeOfDsgVar(eDsgVarType,0), eFlags);
		  break;
 
#else  /* U64 */
 
/* Oliv' - 07/07/1999 - remove boolean save (considered as char) */
		/*case eDsgVarType_Boolean:
			SAI_fn_bInsertBoolInTable( (void *)p_MyVarAddr,1, eFlags);
			break;*/
/*		case eDsgVarType_Boolean:
			SAI_fn_bInsertCharInTable ( (void *)p_MyVarAddr, eFlags );
osSyncPrintf( "Inserting Bool at 0x%x\n", p_MyVarAddr );
			break;*/
/* EndOfOliv' */
		default:
		{
			register unsigned long ulSize = fn_ulSizeOfDsgVar( eDsgVarType, 0 );
			switch( ulSize )
			{
				case 1 : SAI_fn_bInsertCharInTable ( (void *)p_MyVarAddr, eFlags );					break;
				case 2 : SAI_fn_bInsertShortInTable( (void *)p_MyVarAddr, eFlags );					break;
				case 4 : SAI_fn_bInsertLongInTable ( (void *)p_MyVarAddr, eFlags );					break;
				default: SAI_fn_bInsertArrayInTable( (void *)p_MyVarAddr, ulSize, eFlags );	break;
			}
		  break;
		}
 
#endif /* U64 */
/* EndOfOliv'*/
	}
}
 
void AI_fn_vInsertDsgVarInSAI(AI_tdstMind *p_stMind)
{
 
#ifdef ACTIVE_EDITOR
	if (g_bUseSAIWithEditor)
	{
#endif /* ACTIVE_EDITOR */
 
  if (p_stMind!=NULL)
  {
	/* if DsgVar exists*/
    if ( (AI_M_p_stGetDsgMem(p_stMind) != NULL) && (AI_M_p_stGetDsgVar(p_stMind)!=NULL) )
    {
	  unsigned char ucVarId;
	  /* DsgVar loop*/
      for (ucVarId=0;ucVarId<M_GetNbDsgVar(p_stMind);ucVarId++)
	  {
        SAI_tdeFlags eFlags=M_GetDsgVarSaveType(p_stMind,ucVarId);
		/* if we have to save this DsgVar*/
		if (eFlags!=(SAI_tdeFlags) 0)
		{
		  /* Adress of current value of this DsgVar*/
          char *p_MyVarAddr=(char*) M_GetDsgVarAddr(p_stMind,ucVarId);
		  tdeDsgVarTypeId eDsgVarType=M_GetDsgVarType(p_stMind,ucVarId);
 
		  /* array*/
		  if (fn_GetDsgVarType(eDsgVarType)==E_vt_Array)
		  {
			unsigned char ucIndex=0;
			tdstArray *p_stArray=(tdstArray*) p_MyVarAddr;
			tdeDsgVarTypeId eDsgVarTypeId=M_ARRAY_TYPE(p_stArray);
 
			for (ucIndex=0;ucIndex<M_ARRAY_SIZE(p_stArray);ucIndex++)
			{
				p_MyVarAddr=(char*) M_ARRAY_ELEMENT(p_stArray,ucIndex);
				fn_vInsertDsgvarOneDsgVarInSAI(p_MyVarAddr,eDsgVarTypeId,eFlags);
			}
		  }
		  else
		  {
			fn_vInsertDsgvarOneDsgVarInSAI(p_MyVarAddr,eDsgVarType,eFlags);
		  }
		}
	  }
	}
  }
 
#ifdef ACTIVE_EDITOR
	}
#endif /* ACTIVE_EDITOR */
 
 
}
 
#if defined(AI_USE_SCRIPT)
 
#define CHOOSE_MODEL_DSGVAR 0
#define CHOOSE_PERSO_DSGVAR 1
 
void fn_vSecondPassOfOneDsgVar(AI_tdxHandleToMind p_stMind,char *p_MyVarAddr,tdeDsgVarTypeId eDsgVarType)
{
	SCR_tdst_Link_Value *p_stKey=(SCR_tdst_Link_Value *) ( *((long*)p_MyVarAddr) );
  switch(eDsgVarType)
	{
	case eDsgVarType_GameMaterial:
		/* game material pas initialise*/
    if ( p_stKey != NULL )
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown game material reference");
      (*(C_TypeOfGameMaterial *)p_MyVarAddr) = (C_TypeOfGameMaterial) M_GetLinkValueWithKey(p_stKey);
		}
		break;
 
  case eDsgVarType_Perso:
		/* perso pas initialise*/
    if (p_stKey!=NULL) 
		{
      tdstEngineObject *p_stObject=NULL;
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown perso reference");
      if ( SCR_M_e_Link_GetState(p_stKey) == SCR_ELS_Link_Initialized )
      {
        p_stObject = (tdstEngineObject *) M_GetLinkValueWithKey(p_stKey);
        (*(C_TypeOfPerso *)p_MyVarAddr) = p_stObject ? M_GetSuperObject(p_stObject) : NULL;
      }
      else
        (*(C_TypeOfPerso *)p_MyVarAddr) = NULL;
		}
		break;
 
/* ANNECY OA - 13/08/99 { */
#ifndef U64		
  case eDsgVarType_SuperObject:
		/* super objet pas initialise*/
    if (p_stKey!=NULL) 
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown SuperObject reference");
      if ( SCR_M_e_Link_GetState(p_stKey) == SCR_ELS_Link_Initialized )
      {
        (*(C_TypeOfSuperObject *)p_MyVarAddr) = (HIE_tdxHandleToSuperObject) M_GetLinkValueWithKey(p_stKey);
      }
      else
        (*(C_TypeOfSuperObject *)p_MyVarAddr) = NULL;
		}
		break;
#endif
/* END ANNECY OA } */
  
  case eDsgVarType_WayPoint: 
    /* waypoint pas initialise*/
		if (p_stKey!=(SCR_tdst_Link_Value *) WP_C_hWayPointInvalid) 
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown waypoint reference");
      (*(C_TypeOfWayPoint *)p_MyVarAddr) = (C_TypeOfWayPoint) M_GetLinkValueWithKey(p_stKey);
		}
		break;
 
	case eDsgVarType_Comport: 
    /* comport pas initialisee*/
		if (p_stKey!=NULL) 
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown comport reference");
      *((C_TypeOfComport *)p_MyVarAddr) = (C_TypeOfComport) M_GetLinkValueWithKey(p_stKey);
		}
		break;
 
	case eDsgVarType_Action: 
    /* action pas initialisee*/
		if (p_stKey!=NULL) 
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown action reference");
      *((C_TypeOfAction *)p_MyVarAddr) = (C_TypeOfAction) M_GetLinkValueWithKey(p_stKey);
		}
		break;
 
	case eDsgVarType_Graph:
		/* graph not initialized*/
		if (p_stKey!=NULL) 
		{
      M_TestLinkTableValue(p_stMind,p_stKey,"DsgVar unknown graph reference");
      (*(C_TypeOfGraph *)p_MyVarAddr) = (C_TypeOfGraph) M_GetLinkValueWithKey(p_stKey);
		}
    break;
	}
}
 
void fn_vSecondPassOfDsgVar(AI_tdxHandleToMind p_stMind,unsigned char ucDsgVarId,unsigned char ucChoosePointer)
{
  if (p_stMind!=NULL)
  {
	tdeDsgVarTypeId eDsgVarType=M_GetDsgVarType(p_stMind,ucDsgVarId);
    char *p_MyVarAddr;
 
	if (ucChoosePointer==CHOOSE_MODEL_DSGVAR)
	{
	  p_MyVarAddr=(char*) M_GetDsgVarAddrDefault(p_stMind,ucDsgVarId);
	}
	else
	{
	  p_MyVarAddr=(char*) M_GetDsgVarAddrInit(p_stMind,ucDsgVarId);
	}
 
    /* array*/
	if (fn_GetDsgVarType(eDsgVarType)==E_vt_Array)
	{
		unsigned char ucIndex=0;
		tdstArray *p_stArray=(tdstArray*) p_MyVarAddr;
		tdeDsgVarTypeId eDsgVarTypeId=M_ARRAY_TYPE(p_stArray);
 
		for (ucIndex=0;ucIndex<M_ARRAY_SIZE(p_stArray);ucIndex++)
		{
			p_MyVarAddr=(char*) M_ARRAY_ELEMENT(p_stArray,ucIndex);
			fn_vSecondPassOfOneDsgVar(p_stMind,p_MyVarAddr,eDsgVarTypeId);
		}
	}
    else
	{
		fn_vSecondPassOfOneDsgVar(p_stMind,p_MyVarAddr,eDsgVarType);
	}
  }
}
 
 
void fn_vSecondPassOfDsgMem(AI_tdxHandleToMind p_stMind, ACP_tdxBool _bPersoInFix, enum tdeObjectTreeInit_ _eObjectInit)
{
	/* si il y a des variables designers*/
	if (M_GetDsgMem(p_stMind)!=NULL)
	{
		unsigned char ucDsgVarId;
		for (ucDsgVarId=0;ucDsgVarId<M_GetNbDsgVar(p_stMind);ucDsgVarId++)
		{
 
/* ANNECY MT - 11/09/98 {*/
#if !defined(ACTIVE_EDITOR)	/* {*/
			tdeObjectTreeInit eFlags=M_GetDsgVarInitType(p_stMind,ucDsgVarId);
 
			/* update type of reinit (OTI_WhenGameStart can be used only with actor in Fix)*/
			if (!_bPersoInFix && (eFlags == OTI_WhenGameStart))
				M_GetDsgVarInitType(p_stMind,ucDsgVarId)=OTI_MapLoaded;
#endif /* ACTIVE_EDITOR }			*/
/* END ANNECY MT }*/
 
			/* for model : default values*/
			/* so that perso are initialized only once in model */
			if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
			{
				fn_vSecondPassOfDsgVar(p_stMind,ucDsgVarId,CHOOSE_MODEL_DSGVAR);
			}
			
			/* for perso : special values*/
			if (M_GetDsgMemBufferInit(p_stMind)!=NULL)
			{
				fn_vSecondPassOfDsgVar(p_stMind,ucDsgVarId,CHOOSE_PERSO_DSGVAR);
			}
		}
		if (_bPersoInFix)
			fn_vReinitDesignerVariablesWithFlags(p_stMind, _eObjectInit);
		else
			fn_vReinitDesignerVariablesWithFlags(p_stMind, OTI_WhenGameStart);
	}
}
 
 
void fn_vSecondPassOfMacro(AI_tdxHandleToMind p_stMind, tdstMacro *p_stMacro)
{
	fn_vSecondPassOfTree(p_stMind, M_GetMacroInitTree(p_stMacro));
}
 
void fn_vSecondPassOfListMacro(AI_tdxHandleToMind p_stMind)
{
	unsigned char i;
	tdstListOfMacro *p_stListOfMacro = AI_M_p_stGetListOfMacroAIModel(AI_M_p_stGetAIModel(p_stMind));
	if ( p_stListOfMacro )
	for (i = 0; i < M_GetNbMacro(p_stListOfMacro); i++)
		fn_vSecondPassOfMacro(p_stMind, M_GetMacroN(p_stListOfMacro, i));
}
 
/* Comport init in model and for perso*/
void fn_vSecondPassOfComport(AI_tdxHandleToMind p_stMind,tdstIntelligence *p_stIntelligence)
{
  if (p_stIntelligence!=NULL)
  {
	tdstScriptAI *p_stScriptAI=*(p_stIntelligence->p_p_stScriptAI);
    unsigned long ulComportInit=0;
	long lKey;
 
    if (p_stScriptAI!=NULL)
	{
	  /* so that init comport is initialized only once in model */
	  if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
	  {
        ulComportInit=M_GetScriptAINoComportInitDefault(p_stScriptAI);
 
		if (ulComportInit!=0)
		{
			lKey=ulComportInit;
            M_TestLinkTableValue(p_stMind,lKey,"Error in ComportInit In Model (.RUL or .RFX)");
			ulComportInit=(unsigned long) M_GetComportLinkValueWithKey(lKey);
		}
		else
			ulComportInit = (unsigned long)M_GetScriptAIComport(p_stScriptAI);
		M_GetScriptAINoComportInitDefault(p_stScriptAI)=ulComportInit;
	  }
	}
 
    /* init comport for perso*/
	ulComportInit=M_GetNoComportInit(p_stIntelligence);
	if (ulComportInit==0)
	{
       ulComportInit=M_GetScriptAINoComportInitDefault(p_stScriptAI);  
    }
	else
	{
 	  lKey=ulComportInit;
      M_TestLinkTableValue(p_stMind,lKey,"Error in ComportInit In Perso (.CAR)");
	  ulComportInit=(unsigned long) M_GetComportLinkValueWithKey(lKey);
	  if (ulComportInit==0)
		  ulComportInit=M_GetScriptAINoComportInitDefault(p_stScriptAI);  
	}
	M_GetNoComportInit(p_stIntelligence)=ulComportInit;
	fn_vReinitComport(p_stIntelligence);
  }
}
#endif /* AI_USE_SCRIPT */
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void fn_vSecondPassOfMindLoading(AI_tdxHandleToMind p_stMind,ACP_tdxBool _bPersoInFix, enum tdeObjectTreeInit_ _eObjectInit)
{
#if defined(AI_USE_SCRIPT)
   if (p_stMind!=NULL)
   {
	 tdstIntelligence *p_stReflexOrIntelligence;
 
#if defined(AI_LOGFILE) 
    fpAILogFile=NULL;
    fpAIUnusedComportLogFile=NULL;
    if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
	{
	  fpAILogFile=fopen(AI_ANIM_LOGFILE,"a");
	  fpAIUnusedComportLogFile=fopen(AI_UNUSEDCOMPORT_LOGFILE,"a");
	}
#endif
 
 
#if defined(ACTIVE_AIDEBUG)   /*** DR ***/
	fn_v_SetCurrentMind( p_stMind );
	AI_M_SetDoingIntel(p_stMind, 1);
#endif /*ACTIVE_AIDEBUG*/
 
	/* Second pass for array of references */
	if((p_stMind->p_stAIModel->CFast_dst_RefTreeArray) && (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind))))
	{
		struct tdstTreeInterpret_	stTree;
	    M_GetNodeInterpret(&stTree)=p_stMind->p_stAIModel->CFast_dst_RefTreeArray;
		M_SetNbNodeInterpret(&stTree,p_stMind->p_stAIModel->uwNbNode);
		fn_vSecondPassOfTree(p_stMind, &stTree);
	}
 
	 if ((p_stReflexOrIntelligence=AI_M_p_stGetIntelligence(p_stMind)) != NULL)
	 {
	   /* for nodes*/
	   /* so that init Script is initialized only once in model */
	   if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
	   {
	  	 #if defined(AI_LOGFILE) 
		 if (fpAILogFile)
		 {
			fprintf(fpAILogFile,"\n.RUL of %s :\n",AI_M_szGetPersoName(p_stMind));
		 }
		 #endif
	     fn_vSecondPassOfScriptAI(p_stMind,M_GetScriptAI(p_stReflexOrIntelligence));
	   }
	   /* for ComportInit*/
	   fn_vSecondPassOfComport(p_stMind,p_stReflexOrIntelligence);
 
	 }
	
#if defined(ACTIVE_AIDEBUG)   /*** DR ***/
	 AI_M_SetDoingIntel(p_stMind, 0);
#endif /*ACTIVE_AIDEBUG*/
	 if ((p_stReflexOrIntelligence=AI_M_p_stGetReflex(p_stMind)) != NULL)
	 {
	   /* for nodes*/
	   /* so that init Script is initialized only once in model */
	   if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
	   {
	  	 #if defined(AI_LOGFILE) 
		 if (fpAILogFile)
		 {
			fprintf(fpAILogFile,"\n.RFX of %s :\n",AI_M_szGetPersoName(p_stMind));
		 }
		 #endif
	     fn_vSecondPassOfScriptAI(p_stMind,M_GetScriptAI(p_stReflexOrIntelligence));
	   }
 
		/* for ComportInit*/
	    fn_vSecondPassOfComport(p_stMind,p_stReflexOrIntelligence);
	 }
    
	/* so that init Script is initialized only once in model */
	if (!AI_M_ucGetSecondPassDone(AI_M_p_stGetAIModel(p_stMind)) )
	{
		/* for references in macros*/
		fn_vSecondPassOfListMacro(p_stMind);
	}

	 /* for DsgVar type perso*/
	 fn_vSecondPassOfDsgMem(p_stMind,_bPersoInFix, _eObjectInit);
 
	 /* SAI*/
/*     fn_vInsertDsgVarInSAI(p_stMind);*/
 
	 /* hyper important : must be the last line of this function*/
	 AI_M_SetSecondPassDone(AI_M_p_stGetAIModel(p_stMind),1);
	 
#if defined(AI_LOGFILE) 
	if (fpAILogFile)
	{
		fclose(fpAILogFile);
		fpAILogFile=NULL;
	}
#endif
   }
   
#endif /* AI_USE_SCRIPT */
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
 
void fn_vReinitAIComport(AI_tdxHandleToMind p_stMind)
{
#if defined(ACTIVE_AIDEBUG)
		fn_v_SetCurrentMind(p_stMind);
#endif
 
  /* BEWARE : THIS IS THE ULTRA OPERATOR */
  fn_vSetUltraOperatorPerso(NULL,NULL);
  
  if (p_stMind!=NULL)
  {
     tdstIntelligence *p_stReflexOrIntelligence;
 
	  /* reinit comport intelligence*/
#if defined(ACTIVE_AIDEBUG)   /*** DR ***/
	 AI_M_SetDoingIntel(p_stMind, 1);
#endif /*ACTIVE_AIDEBUG*/
	 if ((p_stReflexOrIntelligence=AI_M_p_stGetIntelligence(p_stMind))!=NULL)
	 {
       	fn_vReinitComport(p_stReflexOrIntelligence);
	 }
 
	 /* reinit comport reflex*/
#if defined(ACTIVE_AIDEBUG)   /*** DR ***/
	 AI_M_SetDoingIntel(p_stMind, 0);
#endif /*ACTIVE_AIDEBUG	 */
	 if ((p_stReflexOrIntelligence=AI_M_p_stGetReflex(p_stMind))!=NULL) 
	 {
	   fn_vReinitComport(p_stReflexOrIntelligence);
	 }
//XB 05/08/99
#ifndef D_THROW_CFAST_AI
//End XB
	 p_stMind->CFast_lCmpMetaAction = 0; 
	 p_stMind->CFast_lRfxMetaAction = 0; 
	 p_stMind->CFast_lCmpMetaActionForMacro = 0; 
	 p_stMind->CFast_lRfxMetaActionForMacro = 0; 
//XB 05/08/99
#endif /* D_THROW_CFAST_AI */
//End XB
  }
}
 
void fn_vReinitAI(AI_tdxHandleToMind p_stMind)
{
  if (p_stMind!=NULL)
  {
    /* reinit AI comport*/
    fn_vReinitAIComport(p_stMind);
 
    /* reinit AI variable designer*/
    ReinitDesignerVariables(p_stMind);
  }
}
 
/* POTICHE*/
void fn_vFirstInitAI(AI_tdxHandleToMind p_stMind)
{
  if (p_stMind!=NULL)
  {
    /* reinit AI comport*/
    fn_vReinitAIComport(p_stMind);
 
    /* reinit AI variable designer*/
    FirstInitDesignerVariables(p_stMind);
  }
}
void fn_vReinitAIComportWithFlags(AI_tdxHandleToMind p_stMind,tdeObjectTreeInit eObjIniType)
{
  eObjIniType=eObjIniType;
  fn_vReinitAIComport(p_stMind);
}
 
/* for the moment */
void fn_vReinitAIWithFlags(AI_tdxHandleToMind p_stMind,tdeObjectTreeInit eObjIniType)
{
  if (p_stMind!=NULL)
  {
	/* reinit AI comport*/
    fn_vReinitAIComportWithFlags(p_stMind,eObjIniType);
 
	/* reinit AI variable designer*/
	fn_vReinitDesignerVariablesWithFlags(p_stMind,eObjIniType);
  }
}
 
 
/****************************************************************************************/
/* for always                                                                           */
/****************************************************************************************/
#include "specif/ActTable.h"
char *fn_p_cSimulateAllocDsgMemBuffer(char **p_ptr,unsigned long ulSize)
{
  char *p_cDsgMemBuffer=NULL;
  p_cDsgMemBuffer=(char*) (*p_ptr);
  (*p_ptr)+=ulSize*sizeof(char);
 
  memset(p_cDsgMemBuffer,0,ulSize);
  return(p_cDsgMemBuffer);
}
 
tdstDsgMem *fn_p_stSimulateAllocDsgMem(char **p_ptr,tdstDsgVar **p_p_stDsgVar,unsigned long ulSize)
{
  tdstDsgMem *p_stDsgMem=NULL;
  p_stDsgMem=(tdstDsgMem*) (*p_ptr);
  memset(*p_ptr,0,sizeof(tdstDsgMem));
  (*p_ptr)+=sizeof(tdstDsgMem);
 
  /* link DsgMem to its model : dont forget it*/
  p_stDsgMem->p_p_stDsgVar=p_p_stDsgVar;
  
  /* no specific values by default */
  p_stDsgMem->p_cDsgMemBufferInit=NULL; 
  
  /* zone which stores current DsgVarValues : Set during 2nd pass*/
  p_stDsgMem->p_cDsgMemBuffer=fn_p_cSimulateAllocDsgMemBuffer(p_ptr,ulSize);
  return(p_stDsgMem);
}
 
 
/* XB 20/05/1999 */
#ifndef D_THROW_COMPLEX_ACTION_TABLE
tdstActionTableEntry *fn_p_stSimulateAllocActionTableEntry(char **p_ptr,unsigned char ucActionTableNbEntry)
{
  tdstActionTableEntry *p_stActionTableEntry=NULL;
  p_stActionTableEntry=(tdstActionTableEntry*) (*p_ptr);
  memset(*p_ptr,0,ucActionTableNbEntry*sizeof(tdstActionTableEntry));
  (*p_ptr)+=(ucActionTableNbEntry*sizeof(tdstActionTableEntry));
  return(p_stActionTableEntry);
}
#endif /* D_THROW_COMPLEX_ACTION_TABLE */
/* End XB 20/05/1999 */
 
tdstActionTable *fn_p_stSimulateAllocActionTable(char **p_ptr,unsigned char ucActionTableNbEntry)
{
/* ANNECY MT - 18/09/98 { now, this function also initializes the ActionTable*/
  tdstActionTable *p_stActionTable=NULL;
  tdstActionTableEntry *p_stEntry=NULL;
/* XB 20/05/1999 */
#ifndef D_THROW_COMPLEX_ACTION_TABLE
  unsigned char ucNEntry;
#endif /* D_THROW_COMPLEX_ACTION_TABLE */
/* End XB 20/05/1999 */
 
/* XB 21/05/1999 */
	if(ucActionTableNbEntry!=0)
	{
  p_stActionTable=(tdstActionTable*) (*p_ptr);
  memset(*p_ptr,0,sizeof(tdstActionTable));
  (*p_ptr)+=sizeof(tdstActionTable);
	}
	else
	{
		return NULL;
	}
/* End XB 21/05/1999 */
 
/* XB 20/05/1999 */
#ifndef D_THROW_COMPLEX_ACTION_TABLE
  M_TableNbEntries(p_stActionTable)=ucActionTableNbEntry;
  M_TableEntry(p_stActionTable)=fn_p_stSimulateAllocActionTableEntry(p_ptr,ucActionTableNbEntry);
 
  p_stActionTable->ucNbEntriesUsed=0;
  p_stActionTable->ucCurrentEntry=0;
  /**/
  for (ucNEntry=0,p_stEntry=M_TableEntry(p_stActionTable);ucNEntry<ucActionTableNbEntry;ucNEntry++,p_stEntry++)
  {
	p_stEntry -> bUseDefaultActionReturn	= g_ucUseDefaultActionReturn;
	p_stEntry -> ucNewActionReturn			= g_ucNewActionReturn;
  }
#else /* D_THROW_COMPLEX_ACTION_TABLE */
	p_stEntry = &(p_stActionTable->stEntry);

	p_stEntry->bUseDefaultActionReturn=g_ucUseDefaultActionReturn;
	p_stEntry->ucNewActionReturn=g_ucNewActionReturn;

	memset(&(p_stEntry->stActionParam),0,sizeof(p_stEntry->stActionParam));
#endif /* D_THROW_COMPLEX_ACTION_TABLE */
/* End XB 20/05/1999 */

  return(p_stActionTable);
/* END ANNECY MT }*/
}
 
tdstIntelligence *fn_p_stSimulateAllocIntelligence(char **p_ptr,tdstScriptAI **p_p_stScriptAI,unsigned char ucActionTableNbEntry)
{
   tdstIntelligence *p_stIntelligence=NULL;
 
   if (M_GetScriptAINbComport(*p_p_stScriptAI)!=0)
   {
     p_stIntelligence=(tdstIntelligence *) (*p_ptr);
	 memset(*p_ptr,0,sizeof(tdstIntelligence));
	 (*p_ptr)+=sizeof(tdstIntelligence);
   
     /* link intelligence to its model*/
     p_stIntelligence->p_p_stScriptAI=p_p_stScriptAI; /* faire macro*/
 
	 /* initialise with default comport*/
     M_GetNoComportInit(p_stIntelligence)=M_GetScriptAINoComportInitDefault(*p_p_stScriptAI);
 
     M_ActionTable(p_stIntelligence)=fn_p_stSimulateAllocActionTable(p_ptr,ucActionTableNbEntry);
/* ANNECY MT - 18/09/98 { fn_p_stSimulateAllocActionTable() also initializes the ActionTable*/
     /*fn_vInitActionTable(p_stIntelligence);*/
/* END ANNECY MT }*/
   }
 
   return(p_stIntelligence);
}
 
void fn_vSimulateMindAllocationFromAnotherMind(AI_tdxHandleToMind p_stMindSrc,AI_tdxHandleToMind p_stMindDst)
{
	if ( (p_stMindSrc!=NULL) && (p_stMindDst!=NULL) )
	{
		AI_tdstAIModel *p_stLoadedAIModel;
		AI_tdstMind *p_stLoadedMind=p_stMindDst;
		tdstScriptAI **p_p_stScriptAI=NULL;
		tdstIntelligence *p_stIntelligenceOrReflex=NULL;
		
		char *ptr=(char*) (p_stMindDst+1);
		
		/* AIModel*/
		p_stLoadedAIModel=AI_M_p_stGetAIModel(p_stMindSrc);
		AI_M_SetAIModel(p_stLoadedMind,p_stLoadedAIModel);
		
#if defined(ACTIVE_EDITOR)
		AI_M_ucErrorFlag(p_stLoadedMind)=0;           
#endif
		
#if defined(ACTIVE_AIDEBUG)
		AIDebug_M_InitTrace( p_stLoadedMind );
		AIDebug_M_InitBuffer( p_stLoadedMind );
#endif /*ACTIVE_AIDEBUG*/
		
		/*    fn_vSecondPassOfMindLoading(p_stMindSrc);*/
		
		/* simul alloc intelligence and link it with its script*/
		p_p_stScriptAI=&AI_M_p_stGetIntelligenceScriptAIModel(p_stLoadedAIModel);
		if (*p_p_stScriptAI!=NULL)
		{
			AI_M_SetIntelligence(p_stLoadedMind,
				fn_p_stSimulateAllocIntelligence(&ptr,
				p_p_stScriptAI,
				M_GetScriptAIActionTableNbEntry(*p_p_stScriptAI)
				)
				);
			p_stIntelligenceOrReflex=AI_M_p_stGetIntelligence(p_stMindSrc);
			if (p_stIntelligenceOrReflex!=NULL)
			{
				M_GetNoComportInit(AI_M_p_stGetIntelligence(p_stLoadedMind))=M_GetNoComportInit(p_stIntelligenceOrReflex);
			}
		}
		else
		{
			AI_M_SetIntelligence(p_stLoadedMind,NULL);
		}
		
		p_stIntelligenceOrReflex=AI_M_p_stGetIntelligence(p_stMindSrc);
		if (p_stIntelligenceOrReflex!=NULL)
		{
			M_GetNoComportInit(AI_M_p_stGetIntelligence(p_stLoadedMind))=M_GetNoComportInit(p_stIntelligenceOrReflex);
		}
		
		/* simul reflex (same structure as intelligence and link it with its script)*/
		p_p_stScriptAI=&AI_M_p_stGetReflexScriptAIModel(p_stLoadedAIModel);
		if (*p_p_stScriptAI!=NULL)
		{
			AI_M_SetReflex(p_stLoadedMind,
				fn_p_stSimulateAllocIntelligence(&ptr,
				p_p_stScriptAI,
				M_GetScriptAIActionTableNbEntry(*p_p_stScriptAI)
				)
				);
			
			p_stIntelligenceOrReflex=AI_M_p_stGetReflex(p_stMindSrc);
			if (p_stIntelligenceOrReflex!=NULL)
			{
				M_GetNoComportInit(AI_M_p_stGetReflex(p_stLoadedMind))=M_GetNoComportInit(p_stIntelligenceOrReflex);
			}
		}  
		else
		{
			AI_M_SetReflex(p_stLoadedMind,NULL);
		}
		
		
		/* simul alloc dsgvar*/
		M_GetDsgMem(p_stLoadedMind)=NULL;
		if ( AI_M_p_stGetDsgVar(p_stLoadedMind)!=NULL)
		{
			if (M_GetDsgVarSize(p_stLoadedMind)!=0)
			{
				AI_M_p_stGetDsgMem(p_stLoadedMind)=fn_p_stSimulateAllocDsgMem(&ptr,&AI_M_p_stGetDsgVar(p_stLoadedMind),M_GetDsgVarSize(p_stLoadedMind) );
				M_GetDsgVar(p_stLoadedMind)=M_GetDsgVar(p_stMindSrc);
				
				/* dsgvar init*/
				if (M_GetDsgMemBufferInit(p_stMindSrc)!=NULL)
				{
					M_GetDsgMemBufferInit(p_stLoadedMind)=fn_p_cSimulateAllocDsgMemBuffer(&ptr,M_GetDsgVarSize(p_stLoadedMind));
					
					/* copy it from the model */
					memcpy(M_GetDsgMemBufferInit(p_stLoadedMind),M_GetDsgMemBufferInit(p_stMindSrc),M_GetDsgVarSize(p_stLoadedMind));
				}
				
			}
		}  
		
		/* reinit comport and dsgvar*/
/* ANNECY MT - 18/09/98 {*/
		/*fn_vReinitAI(p_stLoadedMind);*/
		/**/
		p_stIntelligenceOrReflex=AI_M_p_stGetIntelligence(p_stLoadedMind);
		if(p_stIntelligenceOrReflex)
		{
			M_GetCurrentComport(p_stIntelligenceOrReflex) = (tdstComport *)M_GetNoComportInit(p_stIntelligenceOrReflex);
			M_GetPrevComport(p_stIntelligenceOrReflex) = M_GetCurrentComport(p_stIntelligenceOrReflex);
		}
		/**/
		p_stIntelligenceOrReflex=AI_M_p_stGetReflex(p_stLoadedMind);
		if(p_stIntelligenceOrReflex)
		{
			M_GetCurrentComport(p_stIntelligenceOrReflex) = (tdstComport *)M_GetNoComportInit(p_stIntelligenceOrReflex);
			M_GetPrevComport(p_stIntelligenceOrReflex) = M_GetCurrentComport(p_stIntelligenceOrReflex);
		}
		/**/
		if (M_GetDsgMem(p_stLoadedMind)!=NULL)
		{
			/* copy current values*/
			if (M_GetDsgMemBufferInit(p_stLoadedMind)==NULL)
			{
				/* from init values in model */
				memcpy(M_GetDsgMemBuffer(p_stLoadedMind),M_GetDsgMemDefaultInit(p_stLoadedMind),M_GetDsgVarSize(p_stLoadedMind));
			}
			else
			{
				/* from init values in perso*/
				memcpy(M_GetDsgMemBuffer(p_stLoadedMind),M_GetDsgMemBufferInit(p_stLoadedMind),M_GetDsgVarSize(p_stLoadedMind));
			}
		}
//XB 05/08/99
#ifndef D_THROW_CFAST_AI
//End XB
	  p_stLoadedMind->CFast_lCmpMetaAction = 0; 
	  p_stLoadedMind->CFast_lRfxMetaAction = 0; 
	  p_stLoadedMind->CFast_lCmpMetaActionForMacro = 0; 
	  p_stLoadedMind->CFast_lRfxMetaActionForMacro = 0; 
//XB 05/08/99
#endif /* D_THROW_CFAST_AI */
//End XB
/* END ANNECY MT }*/
  }
}
 
unsigned long fn_ulGetSizeOfMindWithoutAIModel(AI_tdxHandleToMind p_stMind)
{
  unsigned long ulSize=0;
  
  if (p_stMind!=NULL)
  {
	 tdstIntelligence *p_stIntelligenceOrReflex;
 
     /* Mind structure*/
	 ulSize+=sizeof(AI_tdstMind);
 
	 /* Intelligence structure*/
	 p_stIntelligenceOrReflex=AI_M_p_stGetIntelligence(p_stMind);
	 if (p_stIntelligenceOrReflex!=NULL)
	 {
	   ulSize+=sizeof(tdstIntelligence);
	   ulSize+=sizeof(tdstActionTable);
	   ulSize+=sizeof(tdstActionTableEntry)*M_ActionTableNbEntries(p_stIntelligenceOrReflex);
	 }
 
     /* Reflex structure*/
	 p_stIntelligenceOrReflex=AI_M_p_stGetReflex(p_stMind);
	 if (p_stIntelligenceOrReflex!=NULL)
	 {
	   ulSize+=sizeof(tdstIntelligence);
	   ulSize+=sizeof(tdstActionTable);
	   ulSize+=sizeof(tdstActionTableEntry)*M_ActionTableNbEntries(p_stIntelligenceOrReflex);
	 }
 
     /* DsgMem*/
	 if ( AI_M_p_stGetDsgVar(p_stMind)!=NULL)
	 {
		if (M_GetDsgVarSize(p_stMind)!=0)
		{
			ulSize+=sizeof(tdstDsgMem);
			ulSize+=M_GetDsgVarSize(p_stMind);
			if (M_GetDsgMemBufferInit(p_stMind)!=NULL)
			{
              ulSize+=M_GetDsgVarSize(p_stMind);
			}
		}
	 }
  }
  return(ulSize);
}
 
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
unsigned long fn_ulGetSizeOfMindWithAIModel(AI_tdxHandleToMind p_stMind)
{
    unsigned long ulSize=0;
	
	if (p_stMind!=NULL)
	{
		AI_tdstAIModel *p_stModel=AI_M_p_stGetAIModel(p_stMind);
		if (p_stModel!=NULL)
		{
			tdstScriptAI *p_stIntelligenceOrReflexScriptAI;
			long n=2;
			
			/* Model*/
			ulSize+=sizeof(AI_tdstAIModel);
			
			/* Intelligence and reflex*/
			while (n)
			{
				if (n==2)
				{
					p_stIntelligenceOrReflexScriptAI=AI_M_p_stGetIntelligenceScriptAIModel(p_stModel);
				}
				else if (n==1)
				{
					p_stIntelligenceOrReflexScriptAI=AI_M_p_stGetReflexScriptAIModel(p_stModel);
				}
				else
				{
					p_stIntelligenceOrReflexScriptAI=NULL;
				}
				
				if (p_stIntelligenceOrReflexScriptAI!=NULL)
				{
					unsigned long i,j,k;
					ulSize+=sizeof(tdstScriptAI);
					
					for (i=0;i<M_GetScriptAINbComport(p_stIntelligenceOrReflexScriptAI);i++)
					{
						tdstComport *p_stComport=M_GetScriptAIComportN(p_stIntelligenceOrReflexScriptAI,i);
						if (p_stComport!=NULL)
						{
							ulSize+=sizeof(tdstComport);
							
							for (j=0;j<M_GetComportNbRules(p_stComport);j++)
							{
								tdstTreeInterpret *p_stRule=M_GetComportRuleN(p_stComport,j);
								if (p_stRule!=NULL)
								{
									ulSize+=sizeof(tdstTreeInterpret);
									
									for(k=0;k<M_GetNbNodeInterpret(p_stRule);k++)
									{
										tdstNodeInterpret *p_stNode=M_GetNodeInterpretN(p_stRule,k);
										if (p_stNode!=NULL)
										{ 
											ulSize+=sizeof(tdstNodeInterpret);
											
											if (M_GetTypeInterpret(p_stNode) == E_ti_String)
											{
												if (M_szStringInterpret(p_stNode) != NULL)
												{
													ulSize+=strlen(M_szStringInterpret(p_stNode))+1;
												}
											}
											else if (M_GetTypeInterpret(p_stNode) == E_ti_ConstantVector)
											{
												if (M_p_stVectorInterpret(p_stNode) != NULL)
												{
													ulSize+=sizeof(MTH3D_tdstVector);
												}
											}
										}
									}
								}
							}
						}
					}
					n--;
				}
 
				/* Dsgvar*/
                /* To finish*/
			}
		}
	}
	return(fn_ulGetSizeOfMindWithoutAIModel(p_stMind)+ulSize);
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
 
#if defined(AI_USE_SCRIPT)
void fn_vInitAIDebugWindow(void)
{
	SMALL_RECT stDebugWindowSize;
	COORD stDebugWindowSize1;
	ACP_tdxBool bError;
	
	AllocConsole();
	
	stDebugWindowSize.Top=0;
	stDebugWindowSize.Bottom=50;
	stDebugWindowSize.Left=0;
	stDebugWindowSize.Right=20;
	
	stDebugWindowSize1.X=20;
	stDebugWindowSize1.Y=50;
	
	bError=SetConsoleScreenBufferSize(
		GetStdHandle(STD_OUTPUT_HANDLE),	/* handle of console screen buffer */
		stDebugWindowSize1 	/* new size in character rows and cols.  */
		);
	
	bError=SetConsoleWindowInfo(
		GetStdHandle(STD_OUTPUT_HANDLE),	/* handle of console screen buffer */
		TRUE,	/* coordinate type flag */
		&stDebugWindowSize 	/* address of new window rectangle */
		);
	
	SetConsoleTitle("Debug Window");
}
 
void fn_vPrintAIDebug(char *text)
{
	short i;
	
	WriteConsole(
		GetStdHandle(STD_OUTPUT_HANDLE),	/* handle to a console screen buffer */
		text,	/* pointer to buffer to write from */
		strlen(text),	/* number of characters to write */
		(LPDWORD)&i,	/* pointer to number of characters written */
		NULL 	/* reserved */
		);
}
#endif /* AI_USE_SCRIPT */


/* ANNECY MT - 30/03/99 { PC Protection Code */
#ifndef U64	/* { */

/************************************************/
/* Fonctions pour l'utilisation des protections */
/************************************************/


/* ANNECY OA - 04/08/99 { */
/* Lettre du CDROM */
#if defined(__cplusplus)
extern "C"
{
#endif
extern char g_cCDROM;
#if defined(__cplusplus)
}
#endif



/* Initialise le handler des fonctions */
void fn_vInitLoaderHandler(tdstLoaderHandler *stLoader)
{
#if !defined(PRESS_DEMO)
#ifdef PTC_SYSTEM_ACTIVED
	#define M_GET_FUNC_ADDR(num) ((PTC_ga_stImportedFunctions[(num)].dwAddress ^ *((DWORD*)(PTC_ga_stImportedFunctions[(num)].szName))))
#else
	#define M_GET_FUNC_ADDR(num) (NULL)
#endif
	*((long *)&stLoader->SetErrorMode) = M_GET_FUNC_ADDR(PTC_C_SetErrorModeIndex);
	*((long *)&stLoader->CreateFile) = M_GET_FUNC_ADDR(PTC_C_CreateFileIndex);
	*((long *)&stLoader->GetFileInformationByHandle) = M_GET_FUNC_ADDR(PTC_C_GetFileInformationByHandleIndex);
	*((long *)&stLoader->CloseHandle) = M_GET_FUNC_ADDR(PTC_C_CloseHandleIndex);
	*((long *)&stLoader->GetDriveType) = M_GET_FUNC_ADDR(PTC_C_GetDriveTypeIndex);
	*((long *)&stLoader->GetVolumeInformation) = M_GET_FUNC_ADDR(PTC_C_GetVolumeInformationIndex);
	*((long *)&stLoader->GetDiskFreeSpace) = M_GET_FUNC_ADDR(PTC_C_GetDiskFreeSpaceIndex);
	*((long *)&stLoader->SetFileAttributes) = M_GET_FUNC_ADDR(PTC_C_SetFileAttributsIndex);
	*((long *)&stLoader->GetFileAttributes) = M_GET_FUNC_ADDR(PTC_C_GetFileAttributsIndex);
	*((long *)&stLoader->SetFileTime) = M_GET_FUNC_ADDR(PTC_C_SetFileTimeIndex);
	*((long *)&stLoader->GetFileTime) = M_GET_FUNC_ADDR(PTC_C_GetFileTimeIndex);
	*((long *)&stLoader->GetFileSize) = M_GET_FUNC_ADDR(PTC_C_GetFileSizeIndex);
#ifdef PTC_SYSTEM_ACTIVED
	*((long *)&stLoader->SearchExportedFunctionInEveryDLL) = (long)PTC_fn_dwSearchExportedFunctionInEveryDLL;
	*((long *)&stLoader->SearchFunctionInImportedTableOfExe) = (long)PTC_fn_dwSearchFunctionInImportedTableOfExe;
#else
	*((long *)&stLoader->SearchExportedFunctionInEveryDLL) = NULL;
	*((long *)&stLoader->SearchFunctionInImportedTableOfExe) = NULL;
#endif
#endif /* PRESS_DEMO */
}

/* Pointeur de fonctions pour les fonctions dans les donnees */
typedef long (*ptrFunction)(char *_szFileName, tdstLoaderHandler *stHandler);
/* END ANNECY OA } */


unsigned char fn_ucSetDsgVarArray(void *pMyVarAddr,unsigned char ucIndex,tdstGetSetParam *p_stGetSetParam);
unsigned char fn_ucSetDsgVarInteger(void *pMyVarAddr,unsigned char ucIndex,tdstGetSetParam *p_stGetSetParam);
unsigned char fn_ucGetDsgVarInteger(void *pMyVarAddr,unsigned char ucIndex,tdstGetSetParam *p_stGetSetParam);

/* -----------------19/05/99 16:24-------------------
 * for every model
 * --------------------------------------------------*/
#define AI_C_DsgMemNumberForType            0


/* -----------------19/05/99 16:24-------------------
 * for Protect Key model
 * --------------------------------------------------*/
#define AI_C_DsgMemNumberForInitKey         1
#define AI_C_DsgMemNumberOfKey              2
#define AI_C_DsgMemNumberForProtectKey      3

/* 
 * Copy protect keys in Model after binary loading 
 */

#if !defined(PRESS_DEMO)
void fn_vInitDesignerVariablesWithProtectKeyInModel(AI_tdxHandleToMind p_stMind)
{
    char *ptrNumberForType = NULL;

	if (p_stMind)
	{
		unsigned char ucElement;
		tdstGetSetParam stGSParam;

#ifdef _DEBUG
        assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForType);
        //assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForInitKey))==E_vt_Integer);
#endif /* _DEBUG */

        ptrNumberForType = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForType);
        if (fn_ucGetDsgVarInteger(ptrNumberForType,0,&stGSParam)==C_VALID_GET)
        {
            long lType = M_GetSetParam_lValue(&stGSParam);
            if (lType==0)
            {
                /* -----------------19/05/99 16:32-------------------
                 * protect key model
                 * --------------------------------------------------*/
                char *ptrInitKeyArray = NULL;
                char *ptrProtectKeyArray = NULL;
                char *ptrNumberOfKey = NULL;

#ifdef _DEBUG
                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberOfKey);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberOfKey))==E_vt_Integer);

                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForInitKey);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForInitKey))==E_vt_Array);

                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForProtectKey);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForProtectKey))==E_vt_Array);
#endif

                ptrInitKeyArray    = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForInitKey);
                ptrProtectKeyArray = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForProtectKey);

                for (ucElement = 0 ; ucElement < SNA_g_dwNumberOfRelocationTableLoaded ; ucElement++ )
                {
                    M_Full_GetSetParam_Integer(&stGSParam,SNA_g_a_dwInitKeyRelocationTableLoaded[ucElement]);
                    fn_ucSetDsgVarArray (ptrInitKeyArray , ucElement ,&stGSParam);

                    M_Full_GetSetParam_Integer(&stGSParam,SNA_g_a_dwProtectKeyRelocationTableLoaded[ucElement]);
                    fn_ucSetDsgVarArray (ptrProtectKeyArray , ucElement ,&stGSParam);
                }

                ptrNumberOfKey = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberOfKey);
                M_Full_GetSetParam_Integer(&stGSParam,SNA_g_dwNumberOfRelocationTableLoaded);
                fn_ucSetDsgVarInteger (ptrNumberOfKey , 0 , &stGSParam);
            }
        }
	}
}


/* ANNECY OA - 21/07/99 { */
/* -----------------19/05/99 16:24-------------------
 * for Computed Datas model
 * --------------------------------------------------*/
#define AI_C_DsgMemNumberForCode         1
#define AI_C_DsgMemNumberForConsigne     2
#define AI_C_DsgMemNumberForParameter    3
#define AI_C_DsgMemNumberForResult       4
#define AI_C_DsgMemNumberForCDROM		 5

/*
 * execute code in Designer variable after binary loading
 */
void fn_vInitDesignerVariablesWithComputedDatas(AI_tdxHandleToMind p_stMind)
{
	if (p_stMind)
	{
		tdstGetSetParam stGSParam;
		char *ptrNumberForType = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForType);
        
        if (fn_ucGetDsgVarInteger(ptrNumberForType, 0, &stGSParam) == C_VALID_GET)
        {
            long lType = M_GetSetParam_lValue(&stGSParam);

			/* Modele a executer ? */
            if (lType==2)
            {
				tdstLoaderHandler stLoader;
				char *pcComputeDataCode = (char *)((tdstArray *)(M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForCode)))->d_ArrayElement;
				char *pcParameter = (char *)((tdstArray *)(M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForParameter)))->d_ArrayElement;
				char *pcConsigne = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForConsigne);
				char *pcResult = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForResult);
				char *pcCDROM  = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForCDROM);
				long *plCryptage = (long *)pcComputeDataCode;
				long lResult;
				long lCryptKey;
				long lMask;
				
#ifdef _DEBUG
				assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForResult);
				assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForResult))==E_vt_Integer);
#endif /* _DEBUG */


#ifdef _DEBUG
				lMask = 0x81EC8B55;
#else
				lMask = 0x4401;
#endif


				/* Decryptage du code */
				plCryptage = (long *)pcComputeDataCode;
				lCryptKey = ~*plCryptage & lMask;
				/* Nouveau systeme de cryptage
				lCryptKey = *plCryptage;
				++plCryptage;
				*/
				while (plCryptage < (long *)pcConsigne)
				{
					long lNextCryptKey = *plCryptage;
					*plCryptage ^= lCryptKey;
					lCryptKey = lNextCryptKey;
					++plCryptage;
				}

				fn_vInitLoaderHandler(&stLoader);

				/* Decryptage du parametre */
				plCryptage = (long *)pcParameter;
				while (plCryptage < (long *)pcResult)
				{
					long lNextCryptKey = *plCryptage;
					*plCryptage ^= lCryptKey;
					lCryptKey = lNextCryptKey;
					++plCryptage;
				}

				/* lecteur du CDROM en parametre ? */
				fn_ucGetDsgVarInteger(pcCDROM,0,&stGSParam);
				if (M_GetSetParam_lValue(&stGSParam))
				{
					*pcParameter = g_cCDROM;
				}
				
				/* Execution de la fonction */
				lResult = ((ptrFunction)pcComputeDataCode)(pcParameter, &stLoader);				

				/* Cryptage du code */
				while (pcComputeDataCode < pcConsigne)
				{
					*pcComputeDataCode = PTC_fn_lGetRandom();;
					++pcComputeDataCode;
				}

				/* Preparation du resultat */
				M_Full_GetSetParam_Integer(&stGSParam, lResult);

				/* Cryptage du parametre */
				while (pcParameter < pcResult)
				{
					*pcParameter = PTC_fn_lGetRandom();
					++pcParameter;
				}

				/* Stockage du resultat */
				fn_ucSetDsgVarInteger (pcResult, 0, &stGSParam);
			}
		}
	}
}
#endif /* PRESS_DEMO */

/* END ANNECY OA } */

#ifndef RETAIL /* { */

#ifdef PTC_SYSTEM_ACTIVED	/* { */

/* ANNECY OA - 04/08/99 { */
/*************************************************************************/
/* Fonctions pour l'inclusion des protections pendant de la binarisation */
/*************************************************************************/
/* Ligne de commande pour passer par ici : -level:learn_30 -bin:2 -mem:2 -dsc:2  */


/* Taille max du code en long... */
#define M_MAX_CODE_SIZE	200

/* Taille max du parametre en long */
#define M_MAX_PARAMETER_SIZE	100

typedef struct tdstProtectionsInit_
{
	ptrFunction function;
	long		result;
	char		parameter[M_MAX_PARAMETER_SIZE];
	char		CDROM;
} tdstProtectionsInit;


#include "Protections.cxx"


long fn_lCodeSize(ptrFunction function)
{
	long lIndex = 0;

	while (lIndex < 50 && g_ListOfProtectionFunctions[lIndex] != function)		lIndex++;

	if (lIndex < 50)
	{
		return (long)g_ListOfProtectionFunctions[lIndex+1] - (long)g_ListOfProtectionFunctions[lIndex];
	}
	return -1;
}
/* END ANNECY OA } */


/* ANNECY OA - 23/07/99 { */
/*
 * Copy code in Designer variable during binarisation
 */
void fn_vInitDesignerVariablesWithCode(struct tdstEngineObject_ *p_stObject, AI_tdxHandleToMind p_stMind)
{
	MS_tdxHandleToStandardGame h_StdGame = p_stObject -> h_StandardGame;

	if (p_stMind)
	{
		tdstGetSetParam stGSParam;
	    char *pcNumberForType = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForType);
        
        if (fn_ucGetDsgVarInteger(pcNumberForType, 0, &stGSParam) == C_VALID_GET)
        {
            long lType = M_GetSetParam_lValue(&stGSParam);

			if (lType >= 100)
            {
				/* Recherche des variables utiles */
				char *pcComputeDataCode = (char *)((tdstArray *)(M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForCode)))->d_ArrayElement;
				char *pcParameter = (char *)((tdstArray *)(M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForParameter)))->d_ArrayElement;
				char *pcResult = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForResult);
				char *pcConsigne = M_GetDsgVarAddrInit(p_stMind, AI_C_DsgMemNumberForConsigne);
				long *plCryptage = (long *)pcComputeDataCode;
				//long lCodeSize = fn_lCodeSize(lType%100);
				long lCodeSize = fn_lCodeSize(g_ProtectionFunctions[lType%100].function);
				long lCryptKey;
				long lMask;


				/* Sous-couche du code :)) */
				plCryptage = (long *)pcComputeDataCode;
				while (plCryptage < (long *)pcConsigne)
				{
					*plCryptage = PTC_fn_lGetRandom();
					++plCryptage;
				}

				/* Sous-couche du parametre :)) */
				plCryptage = (long *)pcParameter;
				while (plCryptage < (long *)pcResult)
				{
					*plCryptage = PTC_fn_lGetRandom();
					++plCryptage;
				}


				/* Copie de code */
				assert((lCodeSize>>2) < M_MAX_CODE_SIZE);
				memcpy(pcComputeDataCode, g_ProtectionFunctions[lType%100].function, lCodeSize);

				/* Test le point communs entre tous les premmiers entier des fonctions, utile pour le cryptage
				{
					int cmp = *((int *)(g_ProtectionFunctions[0].function));
					int i;
					char buffer[200];
					for (i=1; i < 15; ++i)
					{
						cmp &= *((int *)(g_ProtectionFunctions[i].function));
					}
					sprintf(buffer, "cmp = %X", cmp);
					OutputDebugString(buffer);
					abort();
				}
				*/

				/* Copie du parametre */
				strcpy(pcParameter, g_ProtectionFunctions[lType%100].parameter);

				/* Test de la fonction de protection
				{
					tdstLoaderHandler stLoader;
					long lResult;
					*pcParameter = g_cCDROM;
					fn_vInitLoaderHandler(&stLoader);
					lResult = g_ProtectionFunctions[lType%100].function(pcParameter, &stLoader);
				}
				*/

				/* Copie de la consigne */
				M_Full_GetSetParam_Integer(&stGSParam, g_ProtectionFunctions[lType%100].result);
				fn_ucSetDsgVarInteger (pcConsigne, 0, &stGSParam);


				/* Nettoyage */
				if ((lType >= 100) && (lType <= 199))
				{
					/* Modele Actif, le type est mis a 2 */
					M_Full_GetSetParam_Integer(&stGSParam, 2);
					fn_ucSetDsgVarInteger (pcNumberForType, 0, &stGSParam);
				}
				else if ((lType >= 200) && (lType <= 299))
				{
					/* Modele Passif, le type est mis a 0 */
					M_Full_GetSetParam_Integer(&stGSParam, 0);
					fn_ucSetDsgVarInteger (pcNumberForType, 0, &stGSParam);

					/* et le bit de protection est desactive */
					h_StdGame->ulCustomBits &= ~GAM_C_CustBitProtection;
				}

#ifdef _DEBUG
				lMask = 0x81EC8B55;
#else
				lMask = 0x4401;
#endif


				/* Cryptage du code */
				plCryptage = (long *)pcComputeDataCode;
				lCryptKey = PTC_fn_lGetRandom() & lMask;
				/* Nouveau systeme de cryptage
				lCryptKey = *plCryptage;
				++plCryptage;
				*/
				while (plCryptage < (long *)pcConsigne)
				{
					*plCryptage ^= lCryptKey;
					lCryptKey = *plCryptage;
					++plCryptage;
				}

				/* Cryptage du parametre */
				plCryptage = (long *)pcParameter;
				while (plCryptage < (long *)pcResult)
				{
					*plCryptage ^= lCryptKey;
					lCryptKey = *plCryptage;
					++plCryptage;
				}
			}
		}
	}
}
/* END ANNECY OA } */


/* -----------------19/05/99 16:24-------------------
 * for CheckSum model
 * --------------------------------------------------*/
#define AI_C_DsgMemNumberForBeginAddress    2
#define AI_C_DsgMemNumberForSize            1
#define AI_C_DsgMemNumberForEndAddress      3
#define AI_C_DsgMemNumberForChecksum        4
void fn_vInitDesignerVariablesWithChecksumInModel(struct tdstEngineObject_ *p_stObject, AI_tdxHandleToMind p_stMind)
{
/* ANNECY OA - 04/08/99 { */
	MS_tdxHandleToStandardGame h_StdGame = p_stObject -> h_StandardGame;
/* END ANNECY OA } */
    char *ptrNumberForType = NULL;

	if (p_stMind)
	{
		unsigned char ucElement;
		tdstGetSetParam stGSParam;

#ifdef _DEBUG
        assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForType);
        //assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForInitKey))==E_vt_Integer);
#endif /* _DEBUG */

        ptrNumberForType = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForType);
        if (fn_ucGetDsgVarInteger(ptrNumberForType,0,&stGSParam)==C_VALID_GET)
        {
            long lType = M_GetSetParam_lValue(&stGSParam);
            if (lType==1)
            {
                /* -----------------19/05/99 16:32-------------------
                 * checksum model
                 * --------------------------------------------------*/
                char        *ptrBeginArray      = NULL;
                char        *ptrEndArray        = NULL;
                char        *ptrChecksum        = NULL;
                char        *ptrNumberForSize   = NULL;
                DWORD       *p_dwBeginAddress   = PTC_g_dwBeginLabelAddress;
                DWORD       *p_dwEndAddress     = PTC_g_dwEndLabelAddress;
                DWORD		*p_dwCheckSum		= PTC_g_dwChecksum;
				long		lChecksumBegin		= 0;
				long		lChecksumEnd		= 0;
				long		lChecksumChecksum	= 0;
#ifdef _DEBUG
                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForSize);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForSize))==E_vt_Integer);

                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForBeginAddress);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForBeginAddress))==E_vt_Array);

                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForEndAddress);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForEndAddress))==E_vt_Array);

                assert(M_GetNbDsgVar(p_stMind) > AI_C_DsgMemNumberForChecksum);
                assert(fn_GetDsgVarType(M_GetDsgVarType(p_stMind,AI_C_DsgMemNumberForChecksum))==E_vt_Array);
#endif /* _DEBUG */

                ptrBeginArray    = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForBeginAddress);
                ptrEndArray      = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForEndAddress);
                ptrChecksum      = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForChecksum);

                for (ucElement = 0 ; *p_dwBeginAddress && *p_dwEndAddress ; ucElement++,p_dwBeginAddress++,p_dwEndAddress++,p_dwCheckSum++)
                {
                    M_Full_GetSetParam_Integer(&stGSParam,*p_dwBeginAddress);
                    fn_ucSetDsgVarArray (ptrBeginArray , ucElement ,&stGSParam);

                    M_Full_GetSetParam_Integer(&stGSParam,*p_dwEndAddress);
                    fn_ucSetDsgVarArray (ptrEndArray , ucElement ,&stGSParam);

                    M_Full_GetSetParam_Integer(&stGSParam,*p_dwCheckSum);
                    fn_ucSetDsgVarArray (ptrChecksum , ucElement ,&stGSParam);

					lChecksumBegin		+= (*(long*)p_dwBeginAddress)	* (*(long*)p_dwBeginAddress);
					lChecksumEnd		+= (*(long*)p_dwEndAddress)		* (*(long*)p_dwEndAddress);
					lChecksumChecksum	+= (*(long*)p_dwCheckSum)		* (*(long*)p_dwCheckSum);
                }

				//
                M_Full_GetSetParam_Integer(&stGSParam,lChecksumBegin);
                fn_ucSetDsgVarArray (ptrBeginArray , ucElement ,&stGSParam);

                M_Full_GetSetParam_Integer(&stGSParam,lChecksumEnd);
                fn_ucSetDsgVarArray (ptrEndArray , ucElement ,&stGSParam);

                M_Full_GetSetParam_Integer(&stGSParam,lChecksumChecksum);
                fn_ucSetDsgVarArray (ptrChecksum , ucElement ,&stGSParam);
				//

				ucElement++;
                ptrNumberForSize = M_GetDsgVarAddrDefault(p_stMind,AI_C_DsgMemNumberForSize);
                M_Full_GetSetParam_Integer(&stGSParam,ucElement);
                fn_ucSetDsgVarInteger (ptrNumberForSize , 0 , &stGSParam);


/* ANNECY OA - 04/08/99 { */
				/* Nettoyage : le type est mis a 0 */
				M_Full_GetSetParam_Integer(&stGSParam, 0);
				fn_ucSetDsgVarInteger (ptrNumberForType, 0, &stGSParam);

				/* et le bit de protection est desactive */
				h_StdGame->ulCustomBits &= ~GAM_C_CustBitProtection;
/* END ANNECY OA } */
            }
        }
	}
}
#endif /* PTC_SYSTEM_ACTIVED } */

#endif /* RETAIL } */

#endif /* } U64 */
/* END ANNECY MT } */