1 files changed, 146 insertions, 145 deletions
diff --git a/src/CBot/CBot.h b/src/CBot/CBot.h
index c1a7de9..ae2284a 100644
--- a/src/CBot/CBot.h
+++ b/src/CBot/CBot.h
@@ -1,4 +1,4 @@
-ď»ż// * This file is part of the COLOBOT source code
+// * 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
@@ -12,31 +12,32 @@
 // * 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  http://www.gnu.org/licenses/.
+// * along with this program. If not, see  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////
+// interpréteur pour le language CBot du jeu COLOBOT
 
-// derniďż˝re rďż˝vision : 03/10/2002	DD
+// derničre révision : 03/10/2002	DD
 
 #define	EXTENDS	TRUE
 
 
 #include "resource.h"
-#include "CBotDll.h"				// dďż˝finitions publiques
+#include "CBotDll.h"				// définitions publiques
 #include "CBotToken.h"				// gestion des tokens
 
-#define	STACKRUN	TRUE			// reprise de l'exďż˝cution direct sur une routine suspendue
-#define	STACKMEM	TRUE			// prďż˝rďż˝serve la mďż˝moire pour la pile d'exďż˝cution
-#define	MAXSTACK	990				// taille du stack rďż˝servďż˝
+#define	STACKRUN	TRUE			// reprise de l'exécution direct sur une routine suspendue
+#define	STACKMEM	TRUE			// préréserve la mémoire pour la pile d'exécution
+#define	MAXSTACK	990				// taille du stack réservé
 
-#define	EOX			(CBotStack*)-1	// marqueur condition spďż˝ciale
+#define	EOX			(CBotStack*)-1	// marqueur condition spéciale
 
 /////////////////////////////////////////////////////////////////////
-// rďż˝sumďż˝ des classes utilisďż˝es, dďż˝finies ci-aprďż˝s
+// résumé des classes utilisées, définies ci-aprčs
 
 class CBotCompExpr;	// une expression telle que
 					// () <= ()
 class CBotAddExpr;	// une expression telle que 
 					// () + ()
-class CBotParExpr;	// un ďż˝lďż˝ment de base ou entre parenthďż˝se
+class CBotParExpr;	// un élément de base ou entre parenthčse
 					// Toto.truc
 					// 12.5
 					// "chaine"
@@ -46,17 +47,17 @@ class CBotExprVar;	// un nom de variable tel que
 					// chose.truc.machin
 class CBotWhile;	// while (...) {...};
 class CBotIf;		// if (...) {...} else {...}
-class CBotDefParam;	// liste de paramďż˝tres d'une fonction
+class CBotDefParam;	// liste de paramčtres d'une fonction
 class CBotRepeat;	// repeat (nb) {...}
 
 
 
 ////////////////////////////////////////////////////////////////////////
-// Gestion de la pile d'exďż˝cution
+// Gestion de la pile d'exécution
 ////////////////////////////////////////////////////////////////////////
 
 // en fait, en externe, la seule chose qu'il est possible de faire
-// c'est de crďż˝er une instance d'une pile 
+// c'est de créer une instance d'une pile 
 // pour l'utiliser pour la routine CBotProgram::Execute(CBotStack)
 
 class CBotStack
@@ -76,15 +77,15 @@ private:
 	static int		m_start;
 	static int		m_end;
 	static
-	CBotVar*		m_retvar;					// rďż˝sultat d'un return
+	CBotVar*		m_retvar;					// résultat d'un return
 
-	CBotVar*		m_var;						// rďż˝sultat des opďż˝rations
-	CBotVar*		m_listVar;					// les variables dďż˝clarďż˝es ďż˝ ce niveau
+	CBotVar*		m_var;						// résultat des opérations
+	CBotVar*		m_listVar;					// les variables déclarées ŕ ce niveau
 
-	BOOL			m_bBlock;					// fait partie d'un bloc (variables sont locales ďż˝ ce bloc)
+	BOOL			m_bBlock;					// fait partie d'un bloc (variables sont locales ŕ ce bloc)
 	BOOL			m_bOver;					// limites de la pile ?
-//	BOOL			m_bDontDelete;				// spďż˝cial, ne pas dďż˝truire les variables au delete
-	CBotProgram*	m_prog;						// les fonctions dďż˝finies par user
+//	BOOL			m_bDontDelete;				// spécial, ne pas détruire les variables au delete
+	CBotProgram*	m_prog;						// les fonctions définies par user
 
 	static
 	int				m_initimer;
@@ -96,7 +97,7 @@ private:
 	void*			m_pUser;
 
 	CBotInstr*		m_instr;					// l'instruction correspondante
-	BOOL			m_bFunc;					// une entrďż˝e d'une fonction ?
+	BOOL			m_bFunc;					// une entrée d'une fonction ?
 	CBotCall*		m_call;						// point de reprise dans un call extern
 	friend class	CBotTry;
 
@@ -111,10 +112,10 @@ public:
 	BOOL			StackOver();
 
 	int				GivError(int& start, int& end);
-	int				GivError();						// rend le numďż˝ro d'erreur retournďż˝
+	int				GivError();						// rend le numéro d'erreur retourné
 
-	void			Reset(void* pUser);				// plus d'erreur, timer au dďż˝but
-	void			SetType(CBotTypResult& type);	// dďż˝termine le type
+	void			Reset(void* pUser);				// plus d'erreur, timer au début
+	void			SetType(CBotTypResult& type);	// détermine le type
 	int				GivType(int mode = 0);			// donne le type de valeur sur le stack
 	CBotTypResult	GivTypResult(int mode = 0);		// donne le type complet de valeur sur le stack
 
@@ -133,25 +134,25 @@ public:
 	CBotVar*		CopyVar(CBotToken& Token, BOOL bUpdate = FALSE);	// trouve et rend une copie
 
 
-	CBotStack*		AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE);	// ďż˝tend le stack
-	CBotStack*		AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE);	// ďż˝tend le stack
+	CBotStack*		AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE);	// étend le stack
+	CBotStack*		AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE);	// étend le stack
 	CBotStack*		RestoreStack(CBotInstr* instr = NULL);
 	CBotStack*		RestoreStackEOX(CBotCall* instr = NULL);
 
-	CBotStack*		AddStack2(BOOL bBlock = FALSE);						// ďż˝tend le stack
-	BOOL			Return(CBotStack* pFils);							// transmet le rďż˝sultat au dessus
-	BOOL			ReturnKeep(CBotStack* pFils);						// transmet le rďż˝sultat sans rďż˝duire la pile
+	CBotStack*		AddStack2(BOOL bBlock = FALSE);						// étend le stack
+	BOOL			Return(CBotStack* pFils);							// transmet le résultat au dessus
+	BOOL			ReturnKeep(CBotStack* pFils);						// transmet le résultat sans réduire la pile
 	BOOL			BreakReturn(CBotStack* pfils, const char* name = NULL);
-																		// en cas de break ďż˝ventuel
+																		// en cas de break éventuel
 	BOOL			IfContinue(int state, const char* name);
 																		// ou de "continue"
 	
 	BOOL			IsOk();
 
-	BOOL			SetState(int n, int lim = -10);						// sďż˝lectionne un ďż˝tat
-	int				GivState();											// dans quel ďż˝tat j'ďż˝re ?
-	BOOL			IncState(int lim = -10);							// passe ďż˝ l'ďż˝tat suivant
-	BOOL			IfStep();											// faire du pas ďż˝ pas ?
+	BOOL			SetState(int n, int lim = -10);						// sélectionne un état
+	int				GivState();											// dans quel état j'čre ?
+	BOOL			IncState(int lim = -10);							// passe ŕ l'état suivant
+	BOOL			IfStep();											// faire du pas ŕ pas ?
 	BOOL			Execute(); 
 
 	void			SetVar( CBotVar* var );
@@ -190,7 +191,7 @@ public:
 	int				m_temp;
 };
 
-// les routines inline doivent ďż˝tre dďż˝clarďż˝es dans le fichier .h
+// les routines inline doivent ętre déclarées dans le fichier .h
 
 inline BOOL CBotStack::IsOk()
 {
@@ -224,13 +225,13 @@ private:
 	int				m_end;
 	int				m_start;
 
-	CBotVar*		m_var;						// rďż˝sultat des opďż˝rations
+	CBotVar*		m_var;						// résultat des opérations
 
-	BOOL			m_bBlock;					// fait partie d'un bloc (variables sont locales ďż˝ ce bloc)
+	BOOL			m_bBlock;					// fait partie d'un bloc (variables sont locales ŕ ce bloc)
 	CBotVar*		m_listVar;
 
 	static
-	CBotProgram*	m_prog;						// liste des fonctions compilďż˝es
+	CBotProgram*	m_prog;						// liste des fonctions compilées
 	static
 	CBotTypResult	m_retTyp;
 //	static
@@ -243,9 +244,9 @@ public:
 	BOOL			IsOk();
 	int				GivError();
 	int				GivError(int& start, int& end);
-												// rend le numďż˝ro d'erreur retournďż˝
+												// rend le numéro d'erreur retourné
 
-	void			SetType(CBotTypResult& type);// dďż˝termine le type
+	void			SetType(CBotTypResult& type);// détermine le type
 	CBotTypResult	GivTypResult(int mode = 0);	// donne le type de valeur sur le stack
 	int				GivType(int mode = 0);		// donne le type de valeur sur le stack
 	CBotClass*		GivClass();					// donne la classe de la valeur sur le stack
@@ -257,8 +258,8 @@ public:
 	CBotVar*		CopyVar(CBotToken& Token);	// trouve et rend une copie
 
 	CBotCStack*		TokenStack(CBotToken* pToken = NULL, BOOL bBlock = FALSE);
-	CBotInstr*		Return(CBotInstr* p, CBotCStack* pParent);	// transmet le rďż˝sultat au dessus
-	CBotFunction*	ReturnFunc(CBotFunction* p, CBotCStack* pParent);	// transmet le rďż˝sultat au dessus
+	CBotInstr*		Return(CBotInstr* p, CBotCStack* pParent);	// transmet le résultat au dessus
+	CBotFunction*	ReturnFunc(CBotFunction* p, CBotCStack* pParent);	// transmet le résultat au dessus
 	
 	void			SetVar( CBotVar* var );
 	void			SetCopyVar( CBotVar* var );
@@ -286,7 +287,7 @@ extern BOOL SaveVar(FILE* pf, CBotVar* pVar);
 
 
 /////////////////////////////////////////////////////////////////////
-// classes dďż˝finissant une instruction
+// classes définissant une instruction
 class CBotInstr
 {
 private:
@@ -296,15 +297,15 @@ private:
 protected:
 	CBotToken	m_token;				// conserve le token
 	CBotString	name;					// debug
-	CBotInstr*	m_next;					// instructions chaďż˝nďż˝es
-	CBotInstr*	m_next2b;				// seconde liste pour dďż˝finition en chaďż˝ne
-	CBotInstr*	m_next3;				// troisiďż˝me liste pour les indices et champs
-	CBotInstr*	m_next3b;				// nďż˝cessaire pour la dďż˝claration des tableaux
+	CBotInstr*	m_next;					// instructions chaînées
+	CBotInstr*	m_next2b;				// seconde liste pour définition en chaîne
+	CBotInstr*	m_next3;				// troisičme liste pour les indices et champs
+	CBotInstr*	m_next3b;				// nécessaire pour la déclaration des tableaux
 /*
 	par exemple, le programme suivant
 	int		x[]; x[1] = 4;
 	int		y[x[1]][10], z;
-    va gďż˝nďż˝rďż˝
+    va généré
 	CBotInstrArray
 	m_next3b-> CBotEmpty
 	m_next->
@@ -381,7 +382,7 @@ class CBotWhile : public CBotInstr
 private:
 	CBotInstr*	m_Condition;		// la condition
 	CBotInstr*	m_Block;			// les instructions
-	CBotString	m_label;			// une ďż˝tiquette s'il y a
+	CBotString	m_label;			// une étiquette s'il y a
 
 public:
 				CBotWhile();
@@ -395,9 +396,9 @@ public:
 class CBotRepeat : public CBotInstr
 {
 private:
-	CBotInstr*	m_NbIter;			// le nombre d'itďż˝ration
+	CBotInstr*	m_NbIter;			// le nombre d'itération
 	CBotInstr*	m_Block;			// les instructions
-	CBotString	m_label;			// une ďż˝tiquette s'il y a
+	CBotString	m_label;			// une étiquette s'il y a
 
 public:
 				CBotRepeat();
@@ -413,7 +414,7 @@ class CBotDo : public CBotInstr
 private:
 	CBotInstr*	m_Block;			// les instructions
 	CBotInstr*	m_Condition;		// la condition
-	CBotString	m_label;			// une ďż˝tiquette s'il y a
+	CBotString	m_label;			// une étiquette s'il y a
 
 public:
 				CBotDo();
@@ -429,9 +430,9 @@ class CBotFor : public CBotInstr
 private:
 	CBotInstr*	m_Init;				// intruction initiale
 	CBotInstr*	m_Test;				// la condition de test
-	CBotInstr*	m_Incr;				// instruction pour l'incrďż˝ment
+	CBotInstr*	m_Incr;				// instruction pour l'incrément
 	CBotInstr*	m_Block;			// les instructions
-	CBotString	m_label;			// une ďż˝tiquette s'il y a
+	CBotString	m_label;			// une étiquette s'il y a
 
 public:
 				CBotFor();
@@ -445,7 +446,7 @@ public:
 class CBotBreak : public CBotInstr
 {
 private:
-	CBotString	m_label;			// une ďż˝tiquette s'il y a
+	CBotString	m_label;			// une étiquette s'il y a
 
 public:
 				CBotBreak();
@@ -459,7 +460,7 @@ public:
 class CBotReturn : public CBotInstr
 {
 private:
-	CBotInstr*	m_Instr;			// le paramďż˝tre ďż˝ retourner
+	CBotInstr*	m_Instr;			// le paramčtre ŕ retourner
 
 public:
 				CBotReturn();
@@ -474,7 +475,7 @@ public:
 class CBotSwitch : public CBotInstr
 {
 private:
-	CBotInstr*	m_Value;			// value ďż˝ chercher
+	CBotInstr*	m_Value;			// value ŕ chercher
 	CBotInstr*	m_Block;			// les instructions
 
 public:
@@ -490,7 +491,7 @@ public:
 class CBotCase : public CBotInstr
 {
 private:
-	CBotInstr*	m_Value;			// valeur ďż˝ comparer
+	CBotInstr*	m_Value;			// valeur ŕ comparer
 
 public:
 				CBotCase();
@@ -540,7 +541,7 @@ public:
 class CBotThrow : public CBotInstr
 {
 private:
-	CBotInstr*	m_Value;			// la valeur ďż˝ envoyer
+	CBotInstr*	m_Value;			// la valeur ŕ envoyer
 
 public:
 				CBotThrow();
@@ -582,14 +583,14 @@ public:
 };
 
 
-// dďż˝finition d'un nombre entier
+// définition d'un nombre entier
 
 class CBotInt : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
-	CBotInstr*	m_expr;				// la valeur ďż˝ mettre, s'il y a
-///	CBotInstr*	m_next;				// plusieurs dďż˝finitions enchaďż˝nďż˝es
+	CBotInstr*	m_var;				// la variable ŕ initialiser
+	CBotInstr*	m_expr;				// la valeur ŕ mettre, s'il y a
+///	CBotInstr*	m_next;				// plusieurs définitions enchaînées
 
 public:
 				CBotInt();
@@ -600,15 +601,15 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// dďż˝finition d'un tableau
+// définition d'un tableau
 
 class CBotInstArray : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
+	CBotInstr*	m_var;				// la variable ŕ initialiser
 	CBotInstr*	m_listass;			// liste d'assignations pour le tableau
 	CBotTypResult
-				m_typevar;			// type d'ďż˝lďż˝ments
+				m_typevar;			// type d'éléments
 //	CBotString	m_ClassName;
 
 public:
@@ -621,14 +622,14 @@ public:
 };
 
 
-// dďż˝finition d'une liste d'assignation pour un tableau
+// définition d'une liste d'assignation pour un tableau
 // int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
 
 class CBotListArray : public CBotInstr
 {
 private:
-	CBotInstr*	m_expr;				// expression pour un ďż˝lďż˝ment
-									// les autres sont chaďż˝nďż˝s avec CBotInstr::m_next3;
+	CBotInstr*	m_expr;				// expression pour un élément
+									// les autres sont chaînés avec CBotInstr::m_next3;
 public:
 				CBotListArray();
 				~CBotListArray();
@@ -645,13 +646,13 @@ class CBotEmpty : public CBotInstr
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// dďż˝finition d'un boolďż˝en
+// définition d'un booléen
 
 class CBotBoolean : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
-	CBotInstr*	m_expr;				// la valeur ďż˝ mettre, s'il y a
+	CBotInstr*	m_var;				// la variable ŕ initialiser
+	CBotInstr*	m_expr;				// la valeur ŕ mettre, s'il y a
 
 public:
 				CBotBoolean();
@@ -663,13 +664,13 @@ public:
 };
 
 
-// dďż˝finition d'un nombre rďż˝el
+// définition d'un nombre réel
 
 class CBotFloat : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
-	CBotInstr*	m_expr;				// la valeur ďż˝ mettre, s'il y a
+	CBotInstr*	m_var;				// la variable ŕ initialiser
+	CBotInstr*	m_expr;				// la valeur ŕ mettre, s'il y a
 
 public:
 				CBotFloat();
@@ -680,13 +681,13 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// dďż˝finition d'un elďż˝ment string
+// définition d'un elément string
 
 class CBotIString : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
-	CBotInstr*	m_expr;				// la valeur ďż˝ mettre, s'il y a
+	CBotInstr*	m_var;				// la variable ŕ initialiser
+	CBotInstr*	m_expr;				// la valeur ŕ mettre, s'il y a
 
 public:
 				CBotIString();
@@ -697,16 +698,16 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// dďż˝finition d'un elďż˝ment dans une classe quelconque
+// définition d'un elément dans une classe quelconque
 
 class CBotClassInst : public CBotInstr
 {
 private:
-	CBotInstr*	m_var;				// la variable ďż˝ initialiser
-	CBotClass*	m_pClass;			// rďż˝fďż˝rence ďż˝ la classe
-	CBotInstr*	m_Parameters;		// les paramďż˝tres ďż˝ ďż˝valuer pour le constructeur
-	CBotInstr*	m_expr;				// la valeur ďż˝ mettre, s'il y a
-	BOOL		m_hasParams;		// il y a des paramďż˝tres ?
+	CBotInstr*	m_var;				// la variable ŕ initialiser
+	CBotClass*	m_pClass;			// référence ŕ la classe
+	CBotInstr*	m_Parameters;		// les paramčtres ŕ évaluer pour le constructeur
+	CBotInstr*	m_expr;				// la valeur ŕ mettre, s'il y a
+	BOOL		m_hasParams;		// il y a des paramčtres ?
 	long		m_nMethodeIdent;
 
 public:
@@ -729,8 +730,8 @@ public:
 };
 
 
-// left opďż˝rande
-// n'accepte que les expressions pouvant ďż˝tre ďż˝ gauche d'une assignation
+// left opérande
+// n'accepte que les expressions pouvant ętre ŕ gauche d'une assignation
 
 class CBotLeftExpr : public CBotInstr
 {
@@ -795,8 +796,8 @@ public:
 class CBotExpression : public CBotInstr
 {
 private:
-	CBotLeftExpr*	m_leftop;			// ďż˝lďż˝ment de gauche
-	CBotInstr*		m_rightop;			// ďż˝lďż˝ment de droite
+	CBotLeftExpr*	m_leftop;			// élément de gauche
+	CBotInstr*		m_rightop;			// élément de droite
 
 public:
 				CBotExpression();
@@ -810,7 +811,7 @@ public:
 class CBotListExpression : public CBotInstr
 {
 private:
-	CBotInstr*	m_Expr;				// la 1ďż˝re expression ďż˝ ďż˝valuer
+	CBotInstr*	m_Expr;				// la 1čre expression ŕ évaluer
 
 public:
 				CBotListExpression();
@@ -824,9 +825,9 @@ public:
 class CBotLogicExpr : public CBotInstr
 {
 private:
-	CBotInstr*	m_condition;		// test ďż˝ ďż˝valuer
-	CBotInstr*	m_op1;				// ďż˝lďż˝ment de gauche
-	CBotInstr*	m_op2;				// ďż˝lďż˝ment de droite
+	CBotInstr*	m_condition;		// test ŕ évaluer
+	CBotInstr*	m_op1;				// élément de gauche
+	CBotInstr*	m_op2;				// élément de droite
 	friend class CBotTwoOpExpr;
 
 public:
@@ -851,9 +852,9 @@ public:
 
 
 
-// une expression ďż˝ventuellement entre parenthďż˝ses ( ... )
+// une expression éventuellement entre parenthčses ( ... )
 // il n'y a jamais d'instance de cette classe
-// l'objet retournďż˝ ďż˝tant le contenu de la parenthďż˝se
+// l'objet retourné étant le contenu de la parenthése
 class CBotParExpr : public CBotInstr
 {
 private:
@@ -867,7 +868,7 @@ public:
 class CBotExprUnaire : public CBotInstr
 {
 private:
-	CBotInstr*	m_Expr;				// l'expression ďż˝ ďż˝valuer
+	CBotInstr*	m_Expr;				// l'expression ŕ évaluer
 public:
 				CBotExprUnaire();
 				~CBotExprUnaire();
@@ -877,13 +878,13 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// toutes les opďż˝rations ďż˝ 2 opďż˝randes
+// toutes les opérations ŕ 2 opérandes
 
 class CBotTwoOpExpr : public CBotInstr
 {
 private:
-	CBotInstr*	m_leftop;			// ďż˝lďż˝ment de gauche
-	CBotInstr*	m_rightop;			// ďż˝lďż˝ment de droite
+	CBotInstr*	m_leftop;			// élément de gauche
+	CBotInstr*	m_rightop;			// élément de droite
 public:
 				CBotTwoOpExpr();
 				~CBotTwoOpExpr();
@@ -913,7 +914,7 @@ public:
 class CBotListInstr : public CBotInstr
 {
 private:
-	CBotInstr*	m_Instr;			// les instructions ďż˝ faire
+	CBotInstr*	m_Instr;			// les instructions ŕ faire
 
 public:
 				CBotListInstr();
@@ -928,11 +929,11 @@ public:
 class CBotInstrCall : public CBotInstr
 {
 private:
-	CBotInstr*	m_Parameters;		// les paramďż˝tres ďż˝ ďż˝valuer
-//	int			m_typeRes;			// type du rďż˝sultat
-//	CBotString	m_RetClassName;		// class du rďż˝sultat
+	CBotInstr*	m_Parameters;		// les paramčtres ŕ évaluer
+//	int			m_typeRes;			// type du résultat
+//	CBotString	m_RetClassName;		// class du résultat
 	CBotTypResult
-				m_typRes;			// type complet du rďż˝sultat
+				m_typRes;			// type complet du résultat
 	long		m_nFuncIdent;		// id de la fonction
 
 public:
@@ -944,19 +945,19 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// un appel d'une mďż˝thode
+// un appel d'une méthode
 
 class CBotInstrMethode : public CBotInstr
 {
 private:
-	CBotInstr*	m_Parameters;		// les paramďż˝tres ďż˝ ďż˝valuer
-//	int			m_typeRes;			// type du rďż˝sultat
-//	CBotString	m_RetClassName;		// class du rďż˝sultat
+	CBotInstr*	m_Parameters;		// les paramčtres ŕ évaluer
+//	int			m_typeRes;			// type du résultat
+//	CBotString	m_RetClassName;		// class du résultat
 	CBotTypResult
-				m_typRes;			// type complet du rďż˝sultat
+				m_typRes;			// type complet du résultat
 
-	CBotString	m_NomMethod;		// nom de la mďż˝thode
-	long		m_MethodeIdent;		// identificateur de la mďż˝thode
+	CBotString	m_NomMethod;		// nom de la méthode
+	long		m_MethodeIdent;		// identificateur de la méthode
 //	long		m_nThisIdent;		// identificateur pour "this"
 	CBotString	m_ClassName;		// nom de la classe
 
@@ -1030,7 +1031,7 @@ class CBotLeftExprVar : public CBotInstr
 private:
 public:
 	CBotTypResult
-				m_typevar;			// type de variable dďż˝clarďż˝e
+				m_typevar;			// type de variable déclarée
 	long		m_nIdent;			// identificateur unique pour cette variable
 
 public:
@@ -1085,7 +1086,7 @@ public:
 class CBotNew : public CBotInstr
 {
 private:
-	CBotInstr*	m_Parameters;		// les paramďż˝tres ďż˝ ďż˝valuer
+	CBotInstr*	m_Parameters;		// les paramčtres ŕ évaluer
 	long		m_nMethodeIdent;
 //	long		m_nThisIdent;
 	CBotToken	m_vartoken;
@@ -1100,7 +1101,7 @@ public:
 	void		RestoreState(CBotStack* &pj, BOOL bMain);
 };
 
-// expression reprďż˝sentant un nombre
+// expression représentant un nombre
 
 class CBotExprNum : public CBotInstr
 {
@@ -1120,7 +1121,7 @@ public:
 
 
 
-// expression reprďż˝sentant une chaine de caractďż˝res
+// expression représentant une chaine de caractčres
 
 class CBotExprAlpha : public CBotInstr
 {
@@ -1144,7 +1145,7 @@ class CBotVarInt : public CBotVar
 {
 private:
 	int			m_val;			// la valeur
-	CBotString	m_defnum;		// le nom si donnďż˝ par DefineNum
+	CBotString	m_defnum;		// le nom si donné par DefineNum
 	friend class CBotVar;
 
 public:
@@ -1192,7 +1193,7 @@ public:
 
 };
 
-// classe pour la gestion des nombres rďż˝els (float)
+// classe pour la gestion des nombres réels (float)
 class CBotVarFloat : CBotVar
 {
 private:
@@ -1233,7 +1234,7 @@ public:
 };
 
 
-// classe pour la gestion des chaďż˝nes (String)
+// classe pour la gestion des chaînes (String)
 class CBotVarString : CBotVar
 {
 private:
@@ -1294,19 +1295,19 @@ class CBotVarClass : public CBotVar
 {
 private:
 	static
-	CBotVarClass*	m_ExClass;		// liste des instances existantes ďż˝ un moment donnďż˝
-	CBotVarClass*	m_ExNext;		// pour cette liste gďż˝nďż˝rale
-	CBotVarClass*	m_ExPrev;		// pour cette liste gďż˝nďż˝rale
+	CBotVarClass*	m_ExClass;		// liste des instances existantes ŕ un moment donné
+	CBotVarClass*	m_ExNext;		// pour cette liste générale
+	CBotVarClass*	m_ExPrev;		// pour cette liste générale
 
 private:
-	CBotClass*		m_pClass;		// la dďż˝finition de la classe
+	CBotClass*		m_pClass;		// la définition de la classe
 	CBotVarClass*	m_pParent;		// l'instance dans la classe parent
 	CBotVar*		m_pVar;			// contenu
 	friend class	CBotVar;		// mon papa est un copain
 	friend class	CBotVarPointer;	// et le pointeur aussi
 	int				m_CptUse;		// compteur d'utilisation
 	long			m_ItemIdent;	// identificateur (unique) de l'instance
-	BOOL			m_bConstructor;	// set si un constructeur a ďż˝tďż˝ appelďż˝
+	BOOL			m_bConstructor;	// set si un constructeur a été appelé
 
 public:
 				CBotVarClass( const CBotToken* name, CBotTypResult& type );
@@ -1317,7 +1318,7 @@ public:
 	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);
 	void		SetClass(CBotClass* pClass); //, int &nIdent);
 	CBotClass*	GivClass();
-	CBotVar*	GivItem(const char* name);	// rend un ďż˝lďż˝ment d'une classe selon son nom (*)
+	CBotVar*	GivItem(const char* name);	// rend un élément d'une classe selon son nom (*)
 	CBotVar*	GivItemRef(int nIdent);
 
 	CBotVar*	GivItem(int n, BOOL bExtend);
@@ -1328,8 +1329,8 @@ public:
 	BOOL		Save1State(FILE* pf);
 	void		Maj(void* pUser, BOOL bContinue);
 
-	void		IncrementUse();				// une rďż˝fďż˝rence en plus
-	void		DecrementUse();				// une rďż˝fďż˝rence en moins
+	void		IncrementUse();				// une référence en plus
+	void		DecrementUse();				// une référence en moins
 
 	CBotVarClass* 
 				GivPointer();
@@ -1351,13 +1352,13 @@ public:
 };
 
 
-// classe pour la gestion des pointeurs ďż˝ une instances de classe
+// classe pour la gestion des pointeurs ŕ une instances de classe
 class CBotVarPointer : public CBotVar
 {
 private:
 	CBotVarClass*
 				m_pVarClass;		// contenu
-	CBotClass*	m_pClass;			// la classe prďż˝vue pour ce pointeur
+	CBotClass*	m_pClass;			// la classe prévue pour ce pointeur
 	friend class CBotVar;			// mon papa est un copain
 
 public:
@@ -1367,7 +1368,7 @@ public:
 	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);
 	void		SetClass(CBotClass* pClass);
 	CBotClass*	GivClass();
-	CBotVar*	GivItem(const char* name);	// rend un ďż˝lďż˝ment d'une classe selon son nom (*)
+	CBotVar*	GivItem(const char* name);	// rend un élément d'une classe selon son nom (*)
 	CBotVar*	GivItemRef(int nIdent);
 	CBotVar*	GivItemList();
 
@@ -1376,8 +1377,8 @@ public:
 	CBotVarClass*
 				GivPointer();
 
-	void		SetIdent(long n);			// associe un numďż˝ro d'identification (unique)
-	long		GivIdent();					// donne le numďż˝ro d'identification associďż˝
+	void		SetIdent(long n);			// associe un numéro d'identification (unique)
+	long		GivIdent();					// donne le numéro d'identification associé
 	void		ConstructorSet();
 
 	BOOL		Save1State(FILE* pf);
@@ -1396,7 +1397,7 @@ class CBotVarArray : public CBotVar
 {
 private:
 	CBotVarClass*
-				m_pInstance;				// instance gďż˝rant le tableau
+				m_pInstance;				// instance gérant le tableau
 
 	friend class CBotVar;					// papa est un copain
 
@@ -1409,12 +1410,12 @@ public:
 				GivPointer();
 	
 	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);
-	CBotVar*	GivItem(int n, BOOL bGrow=FALSE);	// rend un ďż˝lďż˝ment selon son index numďż˝rique
-												// agrandi le tableau si nďż˝cessaire si bExtend
-//	CBotVar*	GivItem(const char* name);		// rend un ďż˝lďż˝ment selon son index litďż˝ral
-	CBotVar*	GivItemList();					// donne le premier ďż˝lďż˝ment de la liste
+	CBotVar*	GivItem(int n, BOOL bGrow=FALSE);	// rend un élément selon son index numérique
+												// agrandi le tableau si nécessaire si bExtend
+//	CBotVar*	GivItem(const char* name);		// rend un élément selon son index litéral
+	CBotVar*	GivItemList();					// donne le premier élément de la liste
 
-	CBotString	GivValString();					// donne le contenu du tableau dans une chaďż˝ne
+	CBotString	GivValString();					// donne le contenu du tableau dans une chaîne
 
 	BOOL		Save1State(FILE* pf);
 };
@@ -1495,7 +1496,7 @@ public:
 	static void	Free();
 };
 
-// classe gďż˝rant les mďż˝thodes dďż˝clarďż˝es par AddFunction sur une classe
+// classe gérant les méthodes déclarées par AddFunction sur une classe
 
 class CBotCallMethode
 {
@@ -1527,15 +1528,15 @@ public:
 	
 };
 
-// une liste de paramďż˝tres
+// une liste de paramčtres
 
 class CBotDefParam
 {
 private:
-	CBotToken		m_token;		// nom du paramďż˝tre
+	CBotToken		m_token;		// nom du paramčtre
 	CBotString		m_typename;		// nom du type
-	CBotTypResult	m_type;			// type de paramďż˝tre
-	CBotDefParam*	m_next;			// paramďż˝tre suivant
+	CBotTypResult	m_type;			// type de paramčtre
+	CBotDefParam*	m_next;			// paramčtre suivant
 	long			m_nIdent;
 
 public:
@@ -1555,7 +1556,7 @@ public:
 };
 
 
-// une dďż˝claration de fonction
+// une déclaration de fonction
 
 class CBotFunction : CBotInstr
 {
@@ -1568,18 +1569,18 @@ private:
 	friend class	CBotCStack;
 //	long			m_nThisIdent;
 	long			m_nFuncIdent;
-	BOOL			m_bSynchro;		// mďż˝thode synchronisďż˝e ?
+	BOOL			m_bSynchro;		// méthode synchronisée ?
 
 private:
-	CBotDefParam*	m_Param;		// liste des paramďż˝tres
+	CBotDefParam*	m_Param;		// liste des paramčtres
 	CBotInstr*		m_Block;		// le bloc d'instructions
 	CBotFunction*	m_next;
 	CBotToken		m_retToken;		// si retourne un CBotTypClass
-	CBotTypResult	m_retTyp;		// type complet du rďż˝sultat
+	CBotTypResult	m_retTyp;		// type complet du résultat
 
 	BOOL			m_bPublic;		// fonction publique
 	BOOL			m_bExtern;		// fonction extern
-	CBotString		m_MasterClass;	// nom de la classe qu'on dďż˝rive
+	CBotString		m_MasterClass;	// nom de la classe qu'on dérive
 	CBotProgram*	m_pProg;
 	friend class CBotProgram;
 	friend class CBotClass;