1 files changed, 87 insertions, 75 deletions
diff --git a/src/CBot/CBotVar.cpp b/src/CBot/CBotVar.cpp
index bd5e889..bd6fe31 100644
--- a/src/CBot/CBotVar.cpp
+++ b/src/CBot/CBotVar.cpp
@@ -1,8 +1,20 @@
-////////////////////////////////////////////////////////////////////
-// Définition pour la classe CBotVar
-// gestion des variables du langage CBot
-
-// on ne crée jamais d'instance de la class mčre CBotVar
+ď»ż// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// *
+// * This program is free software: you can redistribute it and/or modify
+// * it under the terms of the GNU General Public License as published by
+// * the Free Software Foundation, either version 3 of the License, or
+// * (at your option) any later version.
+// *
+// * This program is distributed in the hope that it will be useful,
+// * but WITHOUT ANY WARRANTY; without even the implied warranty of
+// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// * GNU General Public License for more details.
+// *
+// * You should have received a copy of the GNU General Public License
+// * along with this program. If not, see .
+
+// on ne crďż˝e jamais d'instance de la class mďż˝re CBotVar
 
 
 #include "CBot.h"
@@ -106,7 +118,7 @@ CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int
 void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )
 {*/
 	if ( !type.Eq(CBotTypClass)        &&
-		 !type.Eq(CBotTypIntrinsic)    &&				// par comodité accepte ces types
+		 !type.Eq(CBotTypIntrinsic)    &&				// par comoditďż˝ accepte ces types
 		 !type.Eq(CBotTypPointer)      &&
 		 !type.Eq(CBotTypArrayPointer) &&
 		 !type.Eq(CBotTypArrayBody)) __asm int 3;
@@ -142,7 +154,7 @@ void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type
 	CBotClass* pClass2 = pClass->GivParent();
 	if ( pClass2 != NULL )
 	{
-		// crée également une instance dans la classe pčre
+		// crďż˝e ďż˝galement une instance dans la classe pďż˝re
 		m_pParent = new CBotVarClass(name, CBotTypResult(type.GivType(),pClass2) ); //, nIdent);
 	}
 
@@ -158,7 +170,7 @@ CBotVarClass::~CBotVarClass( )
 	if ( m_pParent ) delete m_pParent;
 	m_pParent = NULL;
 
-	// libčre l'objet indirect s'il y a lieu
+	// libďż˝re l'objet indirect s'il y a lieu
 //	if ( m_Indirect != NULL )
 //		m_Indirect->DecrementUse();
 
@@ -248,7 +260,7 @@ void* CBotVar::GivUserPtr()
 
 BOOL CBotVar::Save1State(FILE* pf)
 {
-	// cette routine "virtual" ne doit jamais ętre appellée,
+	// cette routine "virtual" ne doit jamais ďż˝tre appellďż˝e,
 	// il doit y avoir une routine pour chaque classe fille (CBotVarInt, CBotVarFloat, etc)
 	// ( voir le type dans m_type )
 	__asm int 3;
@@ -262,7 +274,7 @@ void CBotVar::Maj(void* pUser, BOOL bContinu)
 }
 
 
-// crée une variable selon son type
+// crďż˝e une variable selon son type
 
 CBotVar* CBotVar::Create(const CBotToken* name, int type )
 {
@@ -290,7 +302,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type)
 		return new CBotVarClass(name, type);
 
 	case CBotTypClass:
-		// crée une nouvelle instance d'une classe
+		// crďż˝e une nouvelle instance d'une classe
 		// et retourne le POINTER sur cette instance
 		{
 			CBotVarClass* instance = new CBotVarClass(name, type);
@@ -312,7 +324,7 @@ CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type)
 			while (type.Eq(CBotTypArrayBody))
 			{
 				type = type.GivTypElem();
-				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crée au moins l'élément [0]
+				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crďż˝e au moins l'ďż˝lďż˝ment [0]
 			}
 
 			return array;
@@ -360,7 +372,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type)
 		}
 
 	case CBotTypClass:
-		// crée une nouvelle instance d'une classe
+		// crďż˝e une nouvelle instance d'une classe
 		// et retourne le POINTER sur cette instance
 		{
 			CBotVarClass* instance = new CBotVarClass(&name, type);
@@ -383,7 +395,7 @@ CBotVar* CBotVar::Create( const char* n, CBotTypResult type)
 			while (type.Eq(CBotTypArrayBody))
 			{
 				type = type.GivTypElem();
-				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crée au moins l'élément [0]
+				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crďż˝e au moins l'ďż˝lďż˝ment [0]
 			}
 
 			return array;
@@ -452,7 +464,7 @@ void CBotVar::SetType(CBotTypResult& type)
 
 int CBotVar::GivInit()
 {
-	if (  m_type.Eq(CBotTypClass) ) return IS_DEF;		// toujours défini !
+	if (  m_type.Eq(CBotTypClass) ) return IS_DEF;		// toujours dďż˝fini !
 
 	return	m_binit;
 }
@@ -460,7 +472,7 @@ int CBotVar::GivInit()
 void CBotVar::SetInit(BOOL bInit)
 {
 	m_binit = bInit;
-	if ( bInit == 2 ) m_binit = IS_DEF;					// cas spécial
+	if ( bInit == 2 ) m_binit = IS_DEF;					// cas spďż˝cial
 
 	if ( m_type.Eq(CBotTypPointer) && bInit == 2 )
 	{
@@ -525,7 +537,7 @@ CBotVar* CBotVar::GivItem(int row, BOOL bGrow)
 	return NULL;
 }
 
-// dit si une variable appartient ŕ une classe donnée
+// dit si une variable appartient ďż˝ une classe donnďż˝e
 BOOL CBotVar::IsElemOfClass(const char* name)
 {
 	CBotClass*	pc = NULL;
@@ -551,7 +563,7 @@ BOOL CBotVar::IsElemOfClass(const char* name)
 
 CBotVar* CBotVar::GivStaticVar()
 {
-	// rend le pointeur ŕ la variable si elle est statique
+	// rend le pointeur ďż˝ la variable si elle est statique
 	if ( m_bStatic == 0 || m_pMyThis == NULL ) return this;
 
 	CBotClass*	pClass = m_pMyThis->GivClass();
@@ -604,7 +616,7 @@ void CBotVar::SetVal(CBotVar* var)
 		__asm int 3;
 	}
 
-	m_binit = var->m_binit;		// copie l'état nan s'il y a 
+	m_binit = var->m_binit;		// copie l'ďż˝tat nan s'il y a 
 }
 
 void CBotVar::SetStatic(BOOL bStatic)
@@ -644,8 +656,8 @@ CBotVarClass* CBotVar::GivPointer()
 	return NULL;
 }
 
-// toutes ces fonctions doivent ętre définies dans les classes filles 
-// dérivées de la classe CBotVar
+// toutes ces fonctions doivent ďż˝tre dďż˝finies dans les classes filles 
+// dďż˝rivďż˝es de la classe CBotVar
 
 int CBotVar::GivValInt()
 {
@@ -834,7 +846,7 @@ void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName)
 	m_pMyThis	= NULL;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 
 	m_defnum	= p->m_defnum;
@@ -1047,7 +1059,7 @@ void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName)
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 }
 
@@ -1208,7 +1220,7 @@ void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName)
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 }
 
@@ -1306,7 +1318,7 @@ void CBotVarString::Copy(CBotVar* pSrc, BOOL bName)
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 }
 
@@ -1379,7 +1391,7 @@ BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right)
 // copie une variable dans une autre
 void CBotVarClass::Copy(CBotVar* pSrc, BOOL bName)
 {
-	pSrc = pSrc->GivPointer();					// si source donné par un pointeur
+	pSrc = pSrc->GivPointer();					// si source donnďż˝ par un pointeur
 
 	if ( pSrc->GivType() != CBotTypClass )
 		__asm int 3;
@@ -1402,7 +1414,7 @@ __asm int 3;	"que faire du pParent";
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_ItemIdent = p->m_ItemIdent;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 
 	delete		m_pVar;
@@ -1439,7 +1451,7 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent)
 
 	m_pClass = pClass;
 
-	// initialise les variables associées ŕ cette classe
+	// initialise les variables associďż˝es ďż˝ cette classe
 	delete m_pVar;
 	m_pVar = NULL;
 
@@ -1449,24 +1461,24 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent)
 	while ( pv != NULL )
 	{
 		// cherche les dimensions max du tableau
-		CBotInstr*	p  = pv->m_LimExpr;							// les différentes formules
+		CBotInstr*	p  = pv->m_LimExpr;							// les diffďż˝rentes formules
 		if ( p != NULL )
 		{
-			CBotStack* pile = CBotStack::FirstStack();	// une pile indépendante
+			CBotStack* pile = CBotStack::FirstStack();	// une pile indďż˝pendante
 			int	 n = 0;
 			int	 max[100];
 
 			while (p != NULL)
 			{
 				while( pile->IsOk() && !p->Execute(pile) ) ;		// calcul de la taille sans interruptions
-				CBotVar*	v = pile->GivVar();						// résultat
+				CBotVar*	v = pile->GivVar();						// rďż˝sultat
 				max[n] = v->GivValInt();							// valeur
 				n++;
 				p = p->GivNext3();
 			}
 			while (n<100) max[n++] = 0;
 
-			pv->m_type.SetArray( max );					// mémorise les limitations
+			pv->m_type.SetArray( max );					// mďż˝morise les limitations
 			pile->Delete();
 		}
 
@@ -1477,20 +1489,20 @@ void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent)
 		if ( pv->m_InitExpr != NULL )				// expression pour l'initialisation ?
 		{
 #if	STACKMEM
-			CBotStack* pile = CBotStack::FirstStack();	// une pile indépendante
+			CBotStack* pile = CBotStack::FirstStack();	// une pile indďż˝pendante
 
-			while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn));	// évalue l'expression sans timer
+			while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn));	// ďż˝value l'expression sans timer
 
 			pile->Delete();
 #else
-			CBotStack* pile = new CBotStack(NULL);	// une pile indépendante
-			while(!pv->m_InitExpr->Execute(pile));	// évalue l'expression sans timer
+			CBotStack* pile = new CBotStack(NULL);	// une pile indďż˝pendante
+			while(!pv->m_InitExpr->Execute(pile));	// ďż˝value l'expression sans timer
 			pn->SetVal( pile->GivVar() ) ;
 			delete pile;
 #endif
 		}
 
-//		pn->SetUniqNum(CBotVar::NextUniqNum());		// numérote les éléments
+//		pn->SetUniqNum(CBotVar::NextUniqNum());		// numďż˝rote les ďż˝lďż˝ments
 		pn->SetUniqNum(pv->GivUniqNum());	//++nIdent
 		pn->m_pMyThis = this;
 
@@ -1511,12 +1523,12 @@ void CBotVarClass::Maj(void* pUser, BOOL bContinu)
 /*	if (!bContinu && m_pMyThis != NULL) 
 		m_pMyThis->Maj(pUser, TRUE);*/
 
-	// une routine de mise ŕ jour existe-elle ?
+	// une routine de mise ďż˝ jour existe-elle ?
 
 	if ( m_pClass->m_rMaj == NULL ) return;
 
-	// récupčre le pointeur user selon la classe
-	// ou selon le paramčtre passé au CBotProgram::Run()
+	// rďż˝cupďż˝re le pointeur user selon la classe
+	// ou selon le paramďż˝tre passďż˝ au CBotProgram::Run()
 
 	if ( m_pUserPtr != NULL) pUser = m_pUserPtr;
 	if ( pUser == OBJECTDELETED ||
@@ -1553,7 +1565,7 @@ CBotVar* CBotVarClass::GivItemRef(int nIdent)
 }
 
 // pour la gestion d'un tableau
-// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray()
+// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixďż˝e par SetArray()
 
 CBotVar* CBotVarClass::GivItem(int n, BOOL bExtend)
 {
@@ -1597,7 +1609,7 @@ CBotString CBotVarClass::GivValString()
 
 	CBotString	res;
 
-	if ( m_pClass != NULL )						// pas utilisé pour un array
+	if ( m_pClass != NULL )						// pas utilisďż˝ pour un array
 	{
 		res = m_pClass->GivName() + "( ";
 
@@ -1658,7 +1670,7 @@ void CBotVarClass::DecrementUse()
 	if ( m_CptUse == 0 ) 
 	{
 		// s'il y en a un, appel le destructeur
-		// mais seulement si un constructeur avait été appelé.
+		// mais seulement si un constructeur avait ďż˝tďż˝ appelďż˝.
 		if ( m_bConstructor )
 		{
 			m_CptUse++;	// ne revient pas dans le destructeur
@@ -1667,7 +1679,7 @@ void CBotVarClass::DecrementUse()
 			// sauve la valeur pour la remettre ensuite
 			int	err, start, end;
 			CBotStack*	pile = NULL;
-			err = pile->GivError(start,end);	// pile == NULL ça ne derange pas !!
+			err = pile->GivError(start,end);	// pile == NULL ďż˝a ne derange pas !!
 
 			pile = CBotStack::FirstStack();		// efface l'erreur
 			CBotVar*	ppVars[1];
@@ -1689,7 +1701,7 @@ void CBotVarClass::DecrementUse()
 			m_CptUse--;
 		}
 
-		delete this; // s'auto-détruit !!
+		delete this; // s'auto-dďż˝truit !!
 	}
 }
 
@@ -1699,7 +1711,7 @@ CBotVarClass* CBotVarClass::GivPointer()
 }
 
 
-// trouve une instance selon son numéro unique
+// trouve une instance selon son numďż˝ro unique
 
 CBotVarClass* CBotVarClass::Find(long id)
 {
@@ -1726,7 +1738,7 @@ BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right)
 		r = r->GivNext();
 	}
 
-	// devrait toujours arrivé simultanément au bout (męmes classes)
+	// devrait toujours arrivďż˝ simultanďż˝ment au bout (mďż˝mes classes)
 	return l == r;
 }
 
@@ -1742,7 +1754,7 @@ BOOL CBotVarClass::Ne(CBotVar* left, CBotVar* right)
 		r = r->GivNext();
 	}
 
-	// devrait toujours arrivé simultanément au bout (męmes classes)
+	// devrait toujours arrivďż˝ simultanďż˝ment au bout (mďż˝mes classes)
 	return l != r;
 }
 
@@ -1763,12 +1775,12 @@ CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type )
 	m_type.SetType(CBotTypArrayPointer);
 	m_binit		= FALSE;
 
-	m_pInstance	= NULL;						// la liste des éléments du tableau
+	m_pInstance	= NULL;						// la liste des ďż˝lďż˝ments du tableau
 }
 
 CBotVarArray::~CBotVarArray()
 {
-	if ( m_pInstance != NULL ) m_pInstance->DecrementUse();	// une référence en moins
+	if ( m_pInstance != NULL ) m_pInstance->DecrementUse();	// une rďż˝fďż˝rence en moins
 }
 
 // copie une variable dans une autre
@@ -1784,34 +1796,34 @@ void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName)
 	m_pInstance = p->GivPointer();
 
 	if ( m_pInstance != NULL )
-		 m_pInstance->IncrementUse();			// une référence en plus
+		 m_pInstance->IncrementUse();			// une rďż˝fďż˝rence en plus
 
 	m_binit		= p->m_binit;
 //-	m_bStatic	= p->m_bStatic;
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 }
 
 void CBotVarArray::SetPointer(CBotVar* pVarClass)
 {
-	m_binit = TRUE;							// init, męme sur un pointeur null
+	m_binit = TRUE;							// init, mďż˝me sur un pointeur null
 
-	if ( m_pInstance == pVarClass) return;	// spécial, ne pas décrémenter et réincrémenter
-											// car le décrément peut détruire l'object
+	if ( m_pInstance == pVarClass) return;	// spďż˝cial, ne pas dďż˝crďż˝menter et rďż˝incrďż˝menter
+											// car le dďż˝crďż˝ment peut dďż˝truire l'object
 
 	if ( pVarClass != NULL )
 	{
 		if ( pVarClass->GivType() == CBotTypArrayPointer )
-			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur ŕ l'objet
+			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur ďż˝ l'objet
 
 		if ( !pVarClass->m_type.Eq(CBotTypClass) &&
 			 !pVarClass->m_type.Eq(CBotTypArrayBody))
 			__asm int 3;
 
-		((CBotVarClass*)pVarClass)->IncrementUse();			// une référence en plus
+		((CBotVarClass*)pVarClass)->IncrementUse();			// une rďż˝fďż˝rence en plus
 	}
 
 	if ( m_pInstance != NULL ) m_pInstance->DecrementUse();
@@ -1830,7 +1842,7 @@ CBotVar* CBotVarArray::GivItem(int n, BOOL bExtend)
 	if ( m_pInstance == NULL )
 	{
 		if ( !bExtend ) return NULL;
-		// crée une instance pour le tableau
+		// crďż˝e une instance pour le tableau
 
 		CBotVarClass* instance = new CBotVarClass(NULL, m_type);
 		SetPointer( instance );
@@ -1853,18 +1865,18 @@ CBotString CBotVarArray::GivValString()
 BOOL CBotVarArray::Save1State(FILE* pf)
 {
 	if ( !WriteType(pf, m_type) ) return FALSE;
-	return SaveVar(pf, m_pInstance);						// sauve l'instance qui gčre le tableau
+	return SaveVar(pf, m_pInstance);						// sauve l'instance qui gďż˝re le tableau
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
-// gestion des pointeurs ŕ une instance donnée
+// gestion des pointeurs ďż˝ une instance donnďż˝e
 
 CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
 {
 	if ( !type.Eq(CBotTypPointer) &&
 		 !type.Eq(CBotTypNullPointer) &&
-		 !type.Eq(CBotTypClass)   &&					// par commodité accepte Class et Intrinsic
+		 !type.Eq(CBotTypClass)   &&					// par commoditďż˝ accepte Class et Intrinsic
 		 !type.Eq(CBotTypIntrinsic) ) __asm int 3;
 
 	m_token		= new CBotToken(name);
@@ -1877,14 +1889,14 @@ CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
 		m_type.SetType(CBotTypPointer);					// quoi qu'il en soit, c'est un pointeur
 	m_binit		= FALSE;
 	m_pClass	= NULL;
-	m_pVarClass = NULL;									// sera défini par un SetPointer()
+	m_pVarClass = NULL;									// sera dďż˝fini par un SetPointer()
 
 	SetClass(type.GivClass() );
 }
 
 CBotVarPointer::~CBotVarPointer()
 {
-	if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();	// une référence en moins
+	if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();	// une rďż˝fďż˝rence en moins
 }
 
 
@@ -1899,7 +1911,7 @@ void CBotVarPointer::Maj(void* pUser, BOOL bContinu)
 CBotVar* CBotVarPointer::GivItem(const char* name)
 {
 	if ( m_pVarClass == NULL)				// pas d'instance existant ?
-		return m_pClass->GivItem(name);		// rend le pointeur dans la classe elle-męme
+		return m_pClass->GivItem(name);		// rend le pointeur dans la classe elle-mďż˝me
 
 	return m_pVarClass->GivItem(name);
 }
@@ -1907,7 +1919,7 @@ CBotVar* CBotVarPointer::GivItem(const char* name)
 CBotVar* CBotVarPointer::GivItemRef(int nIdent)
 {
 	if ( m_pVarClass == NULL)				// pas d'instance existant ?
-		return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-męme
+		return m_pClass->GivItemRef(nIdent);// rend le pointeur dans la classe elle-mďż˝me
 
 	return m_pVarClass->GivItemRef(nIdent);
 }
@@ -1936,21 +1948,21 @@ void CBotVarPointer::ConstructorSet()
 
 void CBotVarPointer::SetPointer(CBotVar* pVarClass)
 {
-	m_binit = TRUE;							// init, męme sur un pointeur null
+	m_binit = TRUE;							// init, mďż˝me sur un pointeur null
 
-	if ( m_pVarClass == pVarClass) return;	// spécial, ne pas décrémenter et réincrémenter
-											// car le décrément peut détruire l'object
+	if ( m_pVarClass == pVarClass) return;	// spďż˝cial, ne pas dďż˝crďż˝menter et rďż˝incrďż˝menter
+											// car le dďż˝crďż˝ment peut dďż˝truire l'object
 
 	if ( pVarClass != NULL )
 	{
 		if ( pVarClass->GivType() == CBotTypPointer )
-			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur ŕ l'objet
+			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur ďż˝ l'objet
 
 //		if ( pVarClass->GivType() != CBotTypClass )
 		if ( !pVarClass->m_type.Eq(CBotTypClass) )
 			__asm int 3;
 
-		((CBotVarClass*)pVarClass)->IncrementUse();			// une référence en plus
+		((CBotVarClass*)pVarClass)->IncrementUse();			// une rďż˝fďż˝rence en plus
 		m_pClass = ((CBotVarClass*)pVarClass)->m_pClass;
 		m_pUserPtr = pVarClass->m_pUserPtr;					// pas vraiment indispensable
 		m_type = CBotTypResult(CBotTypPointer, m_pClass);	// un pointeur de quel genre
@@ -2006,7 +2018,7 @@ BOOL CBotVarPointer::Save1State(FILE* pf)
 		if (!WriteString(pf, "")) return FALSE;
 	}
 
-	if (!WriteLong(pf, GivIdent())) return FALSE;		// la référence unique
+	if (!WriteLong(pf, GivIdent())) return FALSE;		// la rďż˝fďż˝rence unique
 
 	// sauve aussi une copie de l'instance
 	return SaveVar(pf, GivPointer());
@@ -2027,7 +2039,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName)
 	m_pVarClass = p->GivPointer();
 
 	if ( m_pVarClass != NULL )
-		 m_pVarClass->IncrementUse();			// une référence en plus
+		 m_pVarClass->IncrementUse();			// une rďż˝fďż˝rence en plus
 
 	m_pClass	= p->m_pClass;
 	m_binit		= p->m_binit;
@@ -2036,7 +2048,7 @@ void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName)
 	m_pMyThis	= NULL;//p->m_pMyThis;
 	m_pUserPtr	= p->m_pUserPtr;
 
-	// garde le męme idendificateur (par défaut)
+	// garde le mďż˝me idendificateur (par dďż˝faut)
 	if (m_ident == 0 ) m_ident     = p->m_ident;
 }
 
@@ -2065,7 +2077,7 @@ BOOL CBotVarPointer::Ne(CBotVar* left, CBotVar* right)
 
 
 ///////////////////////////////////////////////////////
-// gestion des types de résultats
+// gestion des types de rďż˝sultats
 
 
 CBotTypResult::CBotTypResult(int type)
@@ -2185,7 +2197,7 @@ void CBotTypResult::SetArray( int* max )
 	m_limite = *max;
 	if (m_limite < 1) m_limite = -1;
 
-	if ( m_pNext != NULL )					// derničre dimension ?
+	if ( m_pNext != NULL )					// derniďż˝re dimension ?
 	{
 		m_pNext->SetArray( max+1 );
 	}