Merge branch 'dev' of https://github.com/adiblol/colobot into dev

Conflicts:
	src/sound/sound.h

236 files changed, 32370 insertions, 23184 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2d24e0a..98e9732 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,16 +5,29 @@ cmake_minimum_required(VERSION 2.8)
 project(colobot C CXX)
 
 # Required packages
-find_package(OpenGL REQUIRED)
-find_package(SDL REQUIRED)
-find_package(SDL_image REQUIRED)
+find_package(OpenGL 1.4 REQUIRED)
+find_package(SDL 1.2.10 REQUIRED)
+find_package(SDL_image 1.2 REQUIRED)
+find_package(PNG 1.2 REQUIRED)
+
+# GLEW requirement depends on platform
+# By default it is auto detected
+# This setting may be used to override
+# Possible values:
+# - auto -> determine automatically
+# - 1 -> always enable
+# - 0 -> always disable
+set(USE_GLEW auto)
 
 # Build with debugging symbols
 set(CMAKE_BUILD_TYPE debug)
 
 # Global compile flags
-set(CMAKE_CXX_FLAGS_RELEASE "-O2")
-set(CMAKE_CXX_FLAGS_DEBUG "-w -g -O0")
+set(CMAKE_CXX_FLAGS_RELEASE "-O2 -Wall -Wold-style-cast -std=gnu++0x")
+set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -Wall -Wold-style-cast -std=gnu++0x")
+
+# Include cmake directory
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${colobot_SOURCE_DIR}/cmake")
 
 # Subdirectory with sources
 add_subdirectory(src bin)
diff --git a/Doxyfile b/Doxyfile
index e57ead3..9e4fe82 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -690,8 +690,7 @@ INPUT_ENCODING         = UTF-8
 # *.f90 *.f *.for *.vhd *.vhdl
 
 FILE_PATTERNS          = *.h \
-                         *.cpp \
-                         *.doc.txt
+                         *.cpp
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
diff --git a/HOWTO.txt b/HOWTO.txt
index 9a4b7bc..4c17234 100644
--- a/HOWTO.txt
+++ b/HOWTO.txt
@@ -1,77 +1,104 @@
+EN
+
 How to...
 
-1. Compile the game with MinGW.
+1. Compile the game.
+
+ 1.1 Windows:
 
-  1. Download and install DirectX 8.1 SDK. It can be difficult to find it now as it is old SDK, but here is a working dowload link:
-     http://dl.dropbox.com/u/32866936/dx81sdk_full.exe
-  2. Download and install MinGW and MSYS:
+  1. Download and install MinGW and MSYS:
       http://sourceforge.net/projects/mingw/files/Installer/mingw-get-inst/mingw-get-inst-20111118/
      When installing, select all available components.
-  3. Download and install CMake:
+  2. Download and install CMake:
       http://www.cmake.org/cmake/resources/software.html (the Windows zip file)
      Unpack the contents of the archive to where MinGW is installed (files from bin/ should go into bin/, etc.)
-  4. In the file src/CMakeLists.txt, change "set(DXSDK_DIR "c:/dxsdk") to the directory, where you have DirectX SDK
-     (the slashes must be in this form: /, not \).
-  5. Run MinGW console from the shortcut in menu start.
-  6. Change to the directory where you have the Colobot sources by typing "cd /c/where/the/sources/are"
-  7. Type "cmake -G 'MSYS Makefiles' ."
-  8. Type "make"
-  9. Everything should compile without errors.
+  3. Download the following libraries, installing them in your MinGW directory like with CMake:
+     SDL >=1.2.10, SDL_imgage >= 1.2, SDL_ttf >= 2.0, libpng >= 1.2, GLEW >= 1.8.0
+     Note #1: For most libraries, you can download binary packages with compiled files.
+              However, you must ensure that they work with MinGW as some are built with MSVC
+              and may be incompatible. If that is the case, you should compile the libraries from sources
+              using MinGW.
+     Note #2: For GLEW, you need to compile from source under MinGW. Since there is no automated
+              make script for that, follow the instructions here: http://stackoverflow.com/questions/6005076/
+  4. Run MinGW console from the shortcut in menu start.
+  5. Change to the directory where you have the Colobot sources by typing "cd /c/where/the/sources/are"
+  6. Type "cmake -G 'MSYS Makefiles' ."
+  7. Type "make"
+  8. Everything should compile without errors.
 
-2. Run the compiled game.
+ 1.2 Linux:
+
+  Since you're running Linux, you probably know how to do this anyway ;)
+  But just in case, here's what you need:
+    gcc compiler (with gcc-g++), cmake, libraries with header files: SDL, SDL_image, SDL_ttf, libpng
+  Instructions are the same:
+    $ cmake .
+    $ make
 
-  1. Download and unpack the package with the game data files.
-  2. Copy the compiled files from bin/colobot.exe, bin/CBot/libCBot.dll
-     and from the directory, where MinGW is installed bin/libgcc_s_dw2-1.dll and bin/libstdc++-6.dll
-     to the directory with game data (there should be several files named colobot*.dat).
-  3. Create a shortcut to the colobot.exe executable and add to the executed command " -nocd" option.
-  4. Run the shortcut and enjoy the game.
+  Note: If you experience problems with OpenGL's extensions, install GLEW library and enable
+        it in compilation by setting USE_GLEW to 1 in CMakeLists.txt
 
-3. But it's in French! How to change the language?
+ 1.3 Other platforms, compilers, etc.
+
+   We haven't checked other platforms yet but the code isn't particularly tied to any compiler or platform, so in theory it should work.
+   If you can, please try to compile the code on your platform and let us know how it goes.
+
+2. Run the compiled game.
 
-  1. In the source code, find language.h file and change the line #define FRENCH TRUE to #define FRENCH FALSE and do the reverse
-     on on the language of your choice (English, German or Polish).
-  2. Recompile the game and copy bin/colobot.exe.
-  3. In the directory with game data switch the directories scene, script and help with those from the directory of given language
-    (e.g. english/).
-  4. Run the game.
+  1. Download development data package - make sure you get the latest version as the files will be changed/moved around.
+     Currently the files are hosted at: http://colobot.info/files  (packages are named colobot-data-YYYY-MM-DD.zip)
+  2. Unpack the data package to any place you want.
+  3. Run the game with commandline option "-datadir where_you_put_the_data_dir" and enjoy the game.
 
 
 PL
 
 Jak...
 
-1. Skompilować projekt pod MinGW.
+1. Skompilować grę.
 
-  1. Ściągamy i instalujemy DirectX SDK w wersji 8.1. Może być problem ze znalezieniem linka bo to już stary SDK, ale można ściągnąć stąd:
-     http://dl.dropbox.com/u/32866936/dx81sdk_full.exe
-  2. ÅšciÄ…gamy i instalujemy MinGW i MSYS:
+ 1.1 Windows:
+
+  1. ÅšciÄ…gamy i instalujemy MinGW i MSYS:
      http://sourceforge.net/projects/mingw/files/Installer/mingw-get-inst/mingw-get-inst-20111118/
      Przy instalacji zaznaczamy wszystkie komponenty do instalacji.
-  3. ÅšciÄ…gamy i instalujemy CMake:
+  2. ÅšciÄ…gamy i instalujemy CMake:
      http://www.cmake.org/cmake/resources/software.html (plik zip dla Windowsa)
      Zip rozpakowujemy do katalogu, gdzie zainstalowany jest MinGW (pliki z bin/ mają trafić do bin/ itd.).
-  4. W pliku src/CMakeLists.txt zmieniamy set(DXSDK_DIR "c:/dxsdk") na katalog, gdzie jest zainstalowany DirectX SDK (w wersji 8.1)
-     (slashe mają być właśnie w takiej postaci: / a nie \).
-  5. Uruchamiamy MinGW console ze skrótu w menu start.
-  6. Przechodzimy do katalogu, gdzie są źródła wpisując "cd /c/tam/gdzie/sa/zrodla"
-  7. Wpisujemy "cmake -G 'MSYS Makefiles' ."
-  8. Wpisujemy "make"
-  9. Wszystko powinno się skomplikować bez błędów.
+  3. Ścągamy następujące biblioteki i instalujemy je tam, gdzie MinGW, podobnie jak z CMake:
+     SDL >= 1.2.10, SDL_image >= 1.2, SDL_ttf >= 2.0, libpng >= 1.2
+     Uwaga #1: W większości wymienionych bibliotek można ściągnąć paczki binarne ze skompilowanymi plikami.
+               Jednak musisz się upewnić, że pliki te będą współpracowały z MinGW, bo część z nich
+               jest kompilowana MSVC i może być niezgodna. W takim wypadku, musisz skompilować bibliotekę
+               ze źródeł pod MinGW.
 
-2. Uruchomić skompilowaną grę.
+     Uwaga #2: W przypadku GLEW, musisz skompilować bibiotekę ze źródeł pod MinGW. Ponieważ nie ma skryptu
+               make do tego, użyj poleceń opisanych tutaj: http://stackoverflow.com/questions/6005076/
+  4. Uruchamiamy MinGW console ze skrótu w menu start.
+  5. Przechodzimy do katalogu, gdzie są źródła wpisując "cd /c/tam/gdzie/sa/zrodla"
+  6. Wpisujemy "cmake -G 'MSYS Makefiles' ."
+  7. Wpisujemy "make"
+  8. Wszystko powinno się skomplikować bez błędów.
+
+ 1.2 Linux:
+
+  Skoro już masz Linuksa, to prawdpobodobnie wiesz co robić ;)
+  Ale na wszelki wypadek, potrzebujesz tego:
+    kompilator gcc (razem z gcc-g++), cmake, biblioteki wraz z nagłówkami: SDL, SDL_image, SDL_ttf, libpng
+  Polecenia sÄ… takie same:
+    $ cmake .
+    $ make
 
-  1. ÅšciÄ…gamy paczkÄ™ z plikami danych gry.
-  2. Kopiujemy skompilowane pliki bin/colobot.exe, bin/CBot/libCBot.dll
-     i z katalogu, gdzie jest zainstalowany MinGW bin/libgcc_s_dw2-1.dll i bin/libstdc++-6.dll
-     do katalogu z plikami danych (powinno być tam kilka plików colobot*.dat).
-  3. Tworzymy skrót do colobot.exe, przy czym w wywoływanej komendzie dopisujemy na końcu opcję " -nocd".
-  4. Odpalamy skrót i cieszymy się grą.
+  Uwaga: Jeśli natrafisz na problemy z rozszerzeniami OpenGL, zainstaluj bibliotekę GLEW i włącz ją
+         przy kompilacji, ustawiajÄ…c USE_GLEW na 1 w CMakeLists.txt
 
-3. Ale gra jest po francusku! Jak zmienić język?
+ 1.3 Inne platformy, kompilatory, etc.
+
+   Nie sprawdzaliśmy jeszcze innych platform, ale kod nie jest jakoś specjalnie związany z danym kompilatorem czy platformą, więc w teorii powinien zadziałać.
+   Jeśli możesz, spróbuj skompilować kod na twojej platformie i daj nam znać jak poszło.
+
+2. Uruchomić skompilowaną grę.
 
-  1. W kodzie źródłowym znajdujemy plik language.h i zmieniamy  #define FRENCH TRUE na #define FRENCH FALSE i robimy odwrotnie
-     dla wybranego języka (angielski, niemiecki lub polski).
-  2. Kompilujemy od nowa grÄ™ i kopiujemy bin/colobot.exe.
-  3. W katalogu z plikami danych podmieniamy katalogi scene, script i help z tymi z katalogu danego języka (np. english/).
-  4. Odpalamy grÄ™.
+  1. Ściągamy paczkę developerską z plikami danych gry - upewnij się, że jest to najnowsza wersja, bo pliki będą zmieniane/przenoszone.
+  2. Wypakowujemy pliki gdziekolwiek.
+  3. Uruchamiamy grę wraz z opcją "-datadir tam_gdzie_rozpakowałeś_paczkę" i cieszymy się grą.
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/README-DEV.txt b/README-DEV.txt
index fb4f464..eabd8b3 100644
--- a/README-DEV.txt
+++ b/README-DEV.txt
@@ -1,4 +1,4 @@
 README for Developers
 
 Please refer to our wiki for developers for current information. Its current address is:
-http://colobot.info/wiki/doku.php?id=developers
+http://colobot.info/wiki/
diff --git a/README.txt b/README.txt
index 6388b43..7745186 100644
--- a/README.txt
+++ b/README.txt
@@ -1,14 +1,30 @@
+EN
+
 Welcome to Colobot project repository
 
-This repository contains the source files of Colobot game released on open source license (GNU GPLv3) by the producer Epsitec CH. The sources were released and the rights granted to a group of Polish Colobot fans centered around the site http://colobot.cba.pl/ . This repository contains only the source code of the game. The necessary data files will soon be available as a separate download. For now, though, you can download the original download package released by Epsitec (the link is on http://colobot.cba.pl/ site).
+This is official repository for the open-source Colobot project developed by Polish Portal of Colobot (PPC; Polish: Polski Portal Colobota) with the official site at: http://colobot.cba.pl/.
+
+The source code contained here was released by Epsitec -- the original creator of the game -- on open source (GPLv3) license. The code was given and the rights granted specifically to PPC community in March 2012. Since then, we have been modifying the code and working on our goals, which are briefly summed up below. More information about the project in general will soon appear on our site and a wiki we are writing.
+
+This repository contains only the source code of the game. The game requires also data files which will soon be made available in separate packages. For now, though, you can download the original download package released by Epsitec (the link is on our site).
 
-For more information on the project, see the wiki pages.
 
 Status
 
-Our first goal has been reached now: the project has been successfully ported to CMake build system and MinGW compiler from the original MSVC6 project.
+Our main goals can be summed up in three milestones:
+
+Milestone 1 - Colobot Classic
+
+This is a version of the game that is comprised of the original source files with only minor changes and bugfixes. It is currently maintained in branch named "original" and the master branch is synced to it to provide a working version of the project. There will soon be download packages for the game, in several language versions.
+
+Milestone 2 - Colobot Gold
+
+This is a version of the game that we are now focusing our efforts on. It will be the original, refreshed game rewritten using SDL and OpenGL libraries, thus making it multiplatform. Development for this version is continued in dev branch and sub-branches dev-*. The data files will not be altered and the game will be as close to the original as possible. With this release, we hope to reach wider audience and gain more support.
+
+Milestone 3 - Colobot 2
+
+This will be a new installment in the Colobot series. We have many ideas for the new game and we are still discussing them. Generally, the development of this version will begin only after finishing Colobot Gold (it will be probably hosted in another repository, forked off the Colobot Gold code).
 
-Now our goal is to port the game to OpenGL and SDL, thus making it multiplatform. Further goals include adding new features to the game, though that will be decided later on.
 
 Compiling and running the game
 
@@ -16,4 +32,38 @@ For these instructions see HOWTO.txt file.
 
 Contact
 
-If you want to help in the project, please contact us on the forum on our website (there is also an English board).
+If you want to help in the project, please contact us on our IRC channel #colobot at pirc.pl or the forum on our website: http://colobot.cba.pl/forum (there is also an English board).
+
+PL
+
+Witamy w repozytorium projektu Colobot
+
+To jest oficjalne repozytorium z kodem projektu open-source Colobot rozwijanego przez Polski Portal Colobota (PPC; angielski: Polish Portal of Colobot) z oficjalnÄ… stronÄ…: http://colobot.cba.pl/.
+
+Kod źródłowy zawarty tutaj został wydany przez Epsitec -- oryginalnego twórcę gry -- na otwartej licencji (GPLv3). Kod został wydany i prawa nadane specjalnie dla społeczności PPC w marcu 2012. Od tamtej pory, zajmujemy się modyfikowaniem kodu i pracowaniem nad naszymi celami, które są krótko podsumowane poniżej. Więcej informacji o projekcie w ogóle pojawi się wkrótce na naszej stronie i na wiki, które w tej chwili piszemy.
+
+To repozytorium zawiera tylko kod źródłowy gry. Gra wymaga też plików danych, które niedługo zostaną przygotowane w osobnej paczce. Na razie, możesz pobrać oryginalną paczkę wydaną przez Epsitec (link znajduje się na naszej stronie).
+
+Status
+
+Nasze główne cele można podsumować w trzech krokach, które chcemy osiągnąć:
+
+Krok 1 - Colobot Classic
+
+To jest wersja gry, która składa się z oryginalnych źródeł, z jedynie niewielkimi zmianami i poprawkami. Obecnie znajduje się w gałęzi nazwanej "original", a gałąź master jest z nią zsynchronizowana, aby udostępnić działającą wersję projektu. Niedługo pojawią się paczki do pobrania gry w kilku wersjach językowych.
+
+Krok 2 - Colobot Gold
+
+To jest wersja gry, na której obecnie się skupiamy. Jest to oryginalna, odświeżona gra, przepisana z użyciem bibliotek SDL i OpenGL, w ten sposób czyniąc ją wieloplatformową. Rozwój tej wersji kontynuujemy w gałęzi dev i podgałęziach dev-*. Pliki danych nie będą zmienione dla tej wersji i gra będzie na tyle zbliżona do oryginału na ile to możliwe. Z tym wydaniem, chcemy dotrzeć do szerszej społeczności i uzyskać większe poparcie.
+
+Krok 3 - Colobot 2
+
+To będzie nowa część z cyklu gier Colobot. Mamy wiele pomysłów na nową grę i nadal dyskutujemy nad nimi. Ogólnie, rozwój tej wersji zacznie się po skończeniu wersji Colobot Gold (prawdopodobnie będzie hostowane w osobnym repozytorium, sforkowanym z kodu Colobot Gold).
+
+Kompilacja i uruchomienie gry
+
+Instrukcje te znajdujÄ… siÄ™ w pliku HOWTO.txt.
+
+Kontakt
+
+Jeżeli chcesz pomóc w projekcie, prosimy o kontakt na naszym kanale IRC: #colobot na pirc.pl albo na forum na naszej stronie: http://colobot.cba.pl/forum.
\ No newline at end of file
diff --git a/cmake/FindGLEW.cmake b/cmake/FindGLEW.cmake
new file mode 100644
index 0000000..94c9b32
--- /dev/null
+++ b/cmake/FindGLEW.cmake
@@ -0,0 +1,51 @@
+# CMake module to find GLEW
+# Borrowed from http://code.google.com/p/nvidia-texture-tools/
+# MIT license Copyright (c) 2007 NVIDIA Corporation
+
+# Try to find GLEW library and include path.
+# Once done this will define
+#
+# GLEW_FOUND
+# GLEW_INCLUDE_PATH
+# GLEW_LIBRARY
+#
+
+IF (WIN32)
+    FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
+    $ENV{PROGRAMFILES}/GLEW/include
+    ${PROJECT_SOURCE_DIR}/src/nvgl/glew/include
+    DOC "The directory where GL/glew.h resides")
+    FIND_LIBRARY( GLEW_LIBRARY
+    NAMES glew GLEW glew32 glew32s
+    PATHS
+    /mingw/bin # for MinGW's MSYS
+    /mingw/lib
+    ${PROJECT_SOURCE_DIR}/glew/bin # or in local directory
+    ${PROJECT_SOURCE_DIR}/glew/lib
+    DOC "The GLEW library")
+ELSE (WIN32)
+    FIND_PATH( GLEW_INCLUDE_PATH GL/glew.h
+    /usr/include
+    /usr/local/include
+    /sw/include
+    /opt/local/include
+    DOC "The directory where GL/glew.h resides")
+    FIND_LIBRARY( GLEW_LIBRARY
+    NAMES GLEW glew
+    PATHS
+    /usr/lib64
+    /usr/lib
+    /usr/local/lib64
+    /usr/local/lib
+    /sw/lib
+    /opt/local/lib
+    DOC "The GLEW library")
+ENDIF (WIN32)
+
+IF (GLEW_INCLUDE_PATH)
+    SET( GLEW_FOUND 1 CACHE STRING "Set to 1 if GLEW is found, 0 otherwise")
+ELSE (GLEW_INCLUDE_PATH)
+    SET( GLEW_FOUND 0 CACHE STRING "Set to 1 if GLEW is found, 0 otherwise")
+ENDIF (GLEW_INCLUDE_PATH)
+
+MARK_AS_ADVANCED( GLEW_FOUND )
diff --git a/src/CBot/CBot.aps b/src/CBot/CBot.aps
deleted file mode 100644
index cd294ec..0000000
--- a/src/CBot/CBot.aps
+++ /dev/null
diff --git a/src/CBot/CBot.cpp b/src/CBot/CBot.cpp
index e2b01a9..62d9fb7 100644
--- a/src/CBot/CBot.cpp
+++ b/src/CBot/CBot.cpp
@@ -1,4072 +1,3964 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////

-// compilation des diverses instructions

-// toutes les routines Compile sont statiques

-// et retournent un object selon ce qui a été trouvé comme instruction

-

-// principe de compilation:

-//	les routines Compile retournent un objet de la classe correspondant à l'opération trouvée

-//	il s'agit toujours d'une classe fille de CBotInstr.

-//	( les objets CBotInstr ne sont jamais utilisés directement )

-

-//	si la routine Compile retourne NULL, c'est que l'instruction est fausse

-//	ou incomprise.

-//	L'erreur se trouve alors sur la pile CBotCStack::IsOk() est FALSE

-

-

-#include "CBot.h"

-

-

-

-

-// les divers constructeurs / destructeurs

-// pour libérer tout selon l'arbre établi

-CBotInstr::CBotInstr()

-{

-	name	 = "CBotInstr";

-	m_next	 = NULL;

-	m_next2b = NULL;

-	m_next3	 = NULL;

-	m_next3b = NULL;

-}

-

-CBotInstr::~CBotInstr()

-{

-	delete	m_next;

-	delete	m_next2b;

-	delete	m_next3;

-	delete	m_next3b;

-}

-

-// compteur de boucles imbriquées,

-// pour détermniner les break et continue valides

-// et liste des labels utilisables

-

-int CBotInstr::m_LoopLvl	= 0;

-CBotStringArray

-	CBotInstr::m_labelLvl	= CBotStringArray();

-

-// ajoute un niveau avec un label

-void CBotInstr::IncLvl(CBotString& label)

-{

-	m_labelLvl.SetSize(m_LoopLvl+1);

-	m_labelLvl[m_LoopLvl] = label;

-	m_LoopLvl++;

-}

-

-// ajoute un niveau (instruction switch)

-void CBotInstr::IncLvl()

-{

-	m_labelLvl.SetSize(m_LoopLvl+1);

-	m_labelLvl[m_LoopLvl] = "#SWITCH";

-	m_LoopLvl++;

-}

-

-// libère un niveau

-void CBotInstr::DecLvl()

-{

-	m_LoopLvl--;

-	m_labelLvl[m_LoopLvl].Empty();

-}

-

-// controle la validité d'un break ou continu

-BOOL CBotInstr::ChkLvl(const CBotString& label, int type)

-{

-	int	i = m_LoopLvl;

-	while (--i>=0)

-	{

-		if ( type == ID_CONTINUE && m_labelLvl[i] == "#SWITCH") continue;

-		if ( label.IsEmpty() ) return TRUE;

-		if ( m_labelLvl[i] == label ) return TRUE;

-	}

-	return FALSE;

-}

-

-BOOL CBotInstr::IsOfClass(CBotString n)

-{

-	return name == n;

-}

-

-

-////////////////////////////////////////////////////////////////////////////

-// gestion de base de la classe CBotInstr

-

-// définie le token correspondant à l'instruction

-

-void CBotInstr::SetToken(CBotToken* p)

-{

-	m_token = *p;

-}

-

-void CBotInstr::SetToken(CBotString* name, int start, int end)

-{

-	SetToken( &CBotToken( *name, CBotString(), start, end));

-}

-

-

-// rend le type du token associé à l'instruction

-

-int CBotInstr::GivTokenType()

-{

-	return m_token.GivType();

-}

-

-// rend le token associé

-

-CBotToken* CBotInstr::GivToken()

-{

-	return &m_token;

-}

-

-// ajoute une instruction à la suite des autres

-

-void CBotInstr::AddNext(CBotInstr* n)

-{

-	CBotInstr*	p = this;

-	while ( p->m_next != NULL ) p = p->m_next;

-	p->m_next = n;

-}

-

-void CBotInstr::AddNext3(CBotInstr* n)

-{

-	CBotInstr*	p = this;

-	while ( p->m_next3 != NULL ) p = p->m_next3;

-	p->m_next3 = n;

-}

-

-void CBotInstr::AddNext3b(CBotInstr* n)

-{

-	CBotInstr*	p = this;

-	while ( p->m_next3b != NULL ) p = p->m_next3b;

-	p->m_next3b = n;

-}

-

-// donne l'instruction suivante

-

-CBotInstr* CBotInstr::GivNext()

-{

-	return m_next;

-}

-

-CBotInstr* CBotInstr::GivNext3()

-{

-	return m_next3;

-}

-

-CBotInstr* CBotInstr::GivNext3b()

-{

-	return m_next3b;

-}

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction, qui peut être 

-//	while, do, try, throw, if, for, switch, break, continu, return

-//	int, float, boolean, string,

-//	déclaration d'une instance d'une classe

-//	expression quelconque

-

-CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;

-

-	if ( p == NULL ) return NULL;

-

-	int type = p->GivType();			// quel est le prochaine token ?

-

-	// y a-t-il un label ?

-	if ( IsOfType( pp, TokenTypVar ) &&

-		 IsOfType( pp, ID_DOTS ) )

-	{

-		 type = pp->GivType();

-		 // seules ces instructions acceptent un label

-		 if (!IsOfTypeList( pp, ID_WHILE, ID_FOR, ID_DO, ID_REPEAT, 0 ))

-		 {

-			 pStack->SetError(TX_LABEL, pp->GivStart());

-			 return NULL;

-		 }

-	}

-

-	// appel la routine de compilation correspondant au token trouvé

-	switch (type)

-	{

-	case ID_WHILE:

-		return CBotWhile::Compile(p, pStack);

-

-	case ID_FOR:

-		return CBotFor::Compile(p, pStack);

-

-	case ID_DO:

-		return CBotDo::Compile(p, pStack);

-

-	case ID_REPEAT:

-		return CBotRepeat::Compile(p, pStack);

-

-	case ID_BREAK:

-	case ID_CONTINUE:

-		return CBotBreak::Compile(p, pStack);

-

-	case ID_SWITCH:

-		return CBotSwitch::Compile(p, pStack);

-

-	case ID_TRY:

-		return CBotTry::Compile(p, pStack);

-

-	case ID_THROW:

-		return CBotThrow::Compile(p, pStack);

-

-	case ID_DEBUGDD:

-		return CBotStartDebugDD::Compile(p, pStack);

-

-	case ID_INT:

-		return CBotInt::Compile(p, pStack);

-

-	case ID_FLOAT:

-		return CBotFloat::Compile(p, pStack);

-

-	case ID_STRING:

-		return CBotIString::Compile(p, pStack);

-

-	case ID_BOOLEAN:

-	case ID_BOOL:

-		return CBotBoolean::Compile(p, pStack);

-

-	case ID_IF:

-		return CBotIf::Compile(p, pStack);

-

-	case ID_RETURN:

-		return CBotReturn::Compile(p, pStack);

-

-	case ID_ELSE:

-		pStack->SetStartError(p->GivStart());

-		pStack->SetError(TX_ELSEWITHOUTIF, p->GivEnd());

-		return NULL;

-

-	case ID_CASE:

-		pStack->SetStartError(p->GivStart());

-		pStack->SetError(TX_OUTCASE, p->GivEnd());

-		return NULL;

-	}

-

-	pStack->SetStartError(p->GivStart());

-

-	// ne doit pas être un mot réservé par DefineNum

-	if ( p->GivType() == TokenTypDef )

-	{

-		pStack->SetError(TX_RESERVED, p);

-		return NULL;

-	}

-

-	// ce peut être une définition d'instance de class

-	CBotToken*	ppp = p;

-	if ( IsOfType( ppp, TokenTypVar ) /* && IsOfType( ppp, TokenTypVar )*/ )

-	{

-		if ( CBotClass::Find(p) != NULL )

-		{

-			// oui, compile la déclaration de l'instance

-			return CBotClassInst::Compile(p, pStack);

-		}

-	}

-

-	// ce peut être une instruction arithmétique

-	CBotInstr*	inst = CBotExpression::Compile(p, pStack);

-	if (IsOfType(p, ID_SEP))

-	{

-		return inst;

-	}

-	pStack->SetError(TX_ENDOF, p->GivStart());

-	delete inst;

-	return NULL;

-}

-

-BOOL CBotInstr::Execute(CBotStack* &pj)

-{

-	CBotString	ClassManquante = name;

-	ASM_TRAP();			// ne doit jamais passer par cette routine

-							// mais utiliser les routines des classes filles

-	return FALSE;

-}

-

-BOOL CBotInstr::Execute(CBotStack* &pj, CBotVar* pVar)

-{

-	if ( !Execute(pj) ) return FALSE;

-	pVar->SetVal( pj->GivVar() );

-	return TRUE;

-}

-

-void CBotInstr::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotString	ClassManquante = name;

-	ASM_TRAP();			// ne doit jamais passer par cette routine

-							// mais utiliser les routines des classes filles

-}

-

-

-BOOL CBotInstr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)

-{

-	ASM_TRAP();			// papa sait pas faire, voir les filles

-	return FALSE;

-}

-

-BOOL CBotInstr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)

-{

-	ASM_TRAP();			// papa sait pas faire, voir les filles

-	return FALSE;

-}

-

-void CBotInstr::RestoreStateVar(CBotStack* &pile, BOOL bMain)

-{

-	ASM_TRAP();			// papa sait pas faire, voir les filles

-}

-

-// cette routine n'est définie que pour la classe fille CBotCase

-// cela permet de faire l'appel CompCase sur toutes les instructions

-// pour savoir s'il s'agit d'un case pour la valeur désirée.

-

-BOOL CBotInstr::CompCase(CBotStack* &pj, int val)

-{

-	return FALSE;

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un bloc d'instruction " { i ; i ; } "

-

-// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe

-// l'objet retourné par Compile est généralement de type CBotListInstr

-

-

-CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal)

-{

-	pStack->SetStartError(p->GivStart());

-

-	if (IsOfType(p, ID_OPBLK))

-	{

-		CBotInstr* inst = CBotListInstr::Compile( p, pStack, bLocal );

-

-		if (IsOfType(p, ID_CLBLK))

-		{

-			return inst;

-		}

-

-		pStack->SetError(TX_CLOSEBLK, p->GivStart());	// manque la parenthèse

-		delete inst;

-		return NULL;

-	}

-

-	pStack->SetError(TX_OPENBLK, p->GivStart());

-	return NULL;

-}

-

-CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL bLocal)

-{

-	// est-ce un nouveau bloc ?

-	if ( p->GivType() == ID_OPBLK ) return CBotBlock::Compile(p, pStack);

-

-	// sinon, cherche une instruction unique à la place

-

-	// pour gérer les cas avec définition local à l'instructin (*)

-	CBotCStack* pStk = pStack->TokenStack(p, bLocal);

-

-	return pStack->Return( CBotInstr::Compile(p, pStk),	// une instruction unique

-						   pStk);

-}

-

-// (*) c'est le cas dans l'instruction suivante

-// if ( 1 == 1 ) int x = 0;

-// où la variable x n'est connue que dans le bloc qui suit le if.

-

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une liste d'instruction, séparés par des points-virgules

-

-CBotListInstr::CBotListInstr()

-{

-	m_Instr		= NULL;

-	name = "CBotListInstr";

-}

-

-CBotListInstr::~CBotListInstr()

-{

-	delete	m_Instr;

-}

-

-CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal)

-{

-	CBotCStack* pStk = pStack->TokenStack(p, bLocal);		// les variables sont locales

-

-	CBotListInstr* inst = new CBotListInstr();

-

-	while (TRUE)

-	{

-		if ( p == NULL ) break;

-

-		if (IsOfType(p, ID_SEP)) continue;				// instruction vide ignorée

-		if ( p->GivType() == ID_CLBLK ) break;			// déja plus d'instruction

-

-		if (IsOfType(p, 0))

-		{

-			pStack->SetError(TX_CLOSEBLK, p->GivStart());

-			delete inst;

-			return pStack->Return(NULL, pStk);

-		}

-

-		CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk );	// compile la suivante

-

-		if (!pStk->IsOk())

-		{

-			delete inst;

-			return pStack->Return(NULL, pStk);

-		}

-

-		if ( inst->m_Instr == NULL ) inst->m_Instr = i;

-		else inst->m_Instr->AddNext(i);							// ajoute à la suite

-	}

-	return pStack->Return(inst, pStk);

-}

-

-// exécute une liste d'instructions

-

-BOOL CBotListInstr::Execute(CBotStack* &pj)

-{

-

-	CBotStack*	pile = pj->AddStack(this, TRUE);//indispensable pour SetState()

-	if ( pile->StackOver() ) return pj->Return( pile );

-

-

-	CBotInstr*	p = m_Instr;									// la première expression

-

-	int		state = pile->GivState();

-	while (state-->0) p = p->GivNext();							// revient sur l'opération interrompue

-

-	if ( p != NULL ) while (TRUE)

-	{

-//		DEBUG( "CBotListInstr", pile->GivState(), pile );

-

-		if ( !p->Execute(pile) ) return FALSE;

-		p = p->GivNext();

-		if ( p == NULL ) break;

-		if (!pile->IncState()) ;//return FALSE;					// prêt pour la suivante

-	}

-

-	return pj->Return( pile );					// transmet en dessous

-}

-

-void CBotListInstr::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	CBotInstr*	p = m_Instr;									// la première expression

-

-	int		state = pile->GivState();

-	while ( p != NULL && state-- > 0)

-	{

-		p->RestoreState(pile, FALSE);

-		p = p->GivNext();							// revient sur l'opération interrompue

-	}

-

-	if ( p != NULL ) p->RestoreState(pile, TRUE);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compilation d'un élément se trouvant à gauche d'une assignation

-

-CBotLeftExprVar::CBotLeftExprVar()

-{

-	name	= "CBotLeftExprVar";

-	m_typevar	= -1;

-	m_nIdent	=  0;

-}

-

-CBotLeftExprVar::~CBotLeftExprVar()

-{

-}

-

-CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	// vérifie que le token est un nom de variable

-	if (p->GivType() != TokenTypVar)

-	{

-		pStack->SetError( TX_NOVAR, p->GivStart());

-		return NULL;

-	}

-

-	CBotLeftExprVar* inst = new CBotLeftExprVar();

-	inst->SetToken(p);

-	p = p->GivNext();

-

-	return inst;

-}

-

-// crée une variable et lui assigne le résultat de la pile

-BOOL CBotLeftExprVar::Execute(CBotStack* &pj)

-{

-	CBotVar*	 var1;

-	CBotVar*	 var2;

-

-	var1 = CBotVar::Create(m_token.GivString(), m_typevar);

-	var1->SetUniqNum(m_nIdent);					// avec cet identificateur unique

-	pj->AddVar(var1);							// la place sur la pile

-	

-	var2 = pj->GivVar();						// resultat sur la pile

-	if ( var2 ) var1->SetVal(var2);				// fait l'assignation

-

-	return TRUE;								// opération faite

-}

-

-void CBotLeftExprVar::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotVar*	 var1;

-

-	var1 = pj->FindVar(m_token.GivString());

-	if ( var1 == NULL ) ASM_TRAP();

-

-	var1->SetUniqNum(m_nIdent);					// avec cet identificateur unique

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'un tableau de n'importe quel type

-// int a[12];

-// point x[];

-

-CBotInstArray::CBotInstArray()

-{

-	m_var	  = NULL;

-	m_listass = NULL;

-	name = "CBotInstArray";

-}

-

-CBotInstArray::~CBotInstArray()

-{

-	delete m_var;

-	delete m_listass;

-}

-

-

-CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type)

-{

-	CBotCStack* pStk = pStack->TokenStack(p);

-

-	CBotInstArray*	inst = new CBotInstArray();		// crée l'objet

-

-	CBotToken*	vartoken = p;

-	inst->SetToken(vartoken);

-

-	// détermine l'expression valable pour l'élément gauche

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable ?

-		{

-			pStk->SetError(TX_REDEFVAR, vartoken);

-			goto error;

-		}

-

-		CBotInstr*	i;

-		while (IsOfType(p,  ID_OPBRK))							// avec des indices ?

-		{

-			if ( p->GivType() != ID_CLBRK )

-				i = CBotExpression::Compile( p, pStk );			// expression pour la valeur

-			else

-				i = new CBotEmpty();							// spécial si pas de formule

-

-			inst->AddNext3b(i);									// construit une liste

-			type = CBotTypResult(CBotTypArrayPointer, type);

-

-			if (!pStk->IsOk() || !IsOfType( p, ID_CLBRK ) )

-			{

-				pStk->SetError(TX_CLBRK, p->GivStart());

-				goto error;

-			}

-		}

-

-		CBotVar*   var = CBotVar::Create(vartoken, type);		// crée avec une instance

-		inst->m_typevar = type;

-

-		var->SetUniqNum(

-			((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-															// lui attribut un numéro unique

-		pStack->AddVar(var);									// la place sur la pile

-

-		if ( IsOfType(p, ID_ASS) )							// avec une assignation

-		{

-			inst->m_listass = CBotListArray::Compile( p, pStk, type.GivTypElem() );

-		}

-

-		if ( pStk->IsOk() ) return pStack->Return(inst, pStk);

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-

-// exécute la définition d'un tableau

-

-BOOL CBotInstArray::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile1 = pj->AddStack(this);

-//	if ( pile1 == EOX ) return TRUE;

-

-	CBotStack*	pile  = pile1;

-

-	if ( pile1->GivState() == 0 )

-	{

-		// cherche les dimensions max du tableau

-		CBotInstr*	p  = GivNext3b();							// les différentes formules

-		int			nb = 0;

-

-		while (p != NULL)

-		{

-			pile = pile->AddStack();							// petite place pour travailler

-			nb++;

-			if ( pile->GivState() == 0 )

-			{

-				if ( !p->Execute(pile) ) return FALSE;				// calcul de la taille // interrompu?

-				pile->IncState();

-			}

-			p = p->GivNext3b();

-		}

-

-		p	 = GivNext3b();

-		pile = pile1;											// revient sur la pile

-		int	 n = 0;

-		int	 max[100];

-

-		while (p != NULL)

-		{

-			pile = pile->AddStack();							// récupère la même petite place

-			CBotVar*	v = pile->GivVar();						// résultat

-			max[n] = v->GivValInt();							// valeur

-			if (max[n]>MAXARRAYSIZE)

-			{

-				pile->SetError(TX_OUTARRAY, &m_token);

-				return pj->Return ( pile );

-			}

-			n++;

-			p = p->GivNext3b();

-		}

-		while (n<100) max[n++] = 0;

-

-		m_typevar.SetArray( max );				// mémorise les limitations

-

-		// crée simplement un pointeur null

-		CBotVar*	var = CBotVar::Create(m_var->GivToken(), m_typevar);

-		var->SetPointer(NULL);

-		var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);

-		pj->AddVar(var);										// inscrit le tableau de base sur la pile

-

-#if		STACKMEM

-		pile1->AddStack()->Delete();

-#else

-		delete pile1->AddStack();								// plus besoin des indices

-#endif

-		pile1->IncState();

-	}

-

-	if ( pile1->GivState() == 1 )

-	{

-		if ( m_listass != NULL )								// il y a des assignation pour ce tableau

-		{

-			CBotVar* pVar = pj->FindVar(((CBotLeftExprVar*)m_var)->m_nIdent);

-

-			if ( !m_listass->Execute(pile1, pVar) ) return FALSE;

-		}

-		pile1->IncState();

-	}

-

-	if ( pile1->IfStep() ) return FALSE;							// montre ce pas ?

-

-	if ( m_next2b &&

-		 !m_next2b->Execute( pile1 ) ) return FALSE;

-

-	return pj->Return( pile1 );							// transmet en dessous

-}

-

-void CBotInstArray::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile1 = pj;

-

-	CBotVar*	var = pj->FindVar(m_var->GivToken()->GivString());

-	if ( var != NULL ) var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);

-

-	if ( bMain )

-	{

-					pile1 = pj->RestoreStack(this);

-		CBotStack*	pile  = pile1;

-		if ( pile == NULL ) return;

-

-		if ( pile1->GivState() == 0 )

-		{

-			// cherche les dimensions max du tableau

-			CBotInstr*	p  = GivNext3b();							// les différentes formules

-

-			while (p != NULL)

-			{

-				pile = pile->RestoreStack();						// petite place pour travailler

-				if ( pile == NULL ) return;

-				if ( pile->GivState() == 0 )

-				{

-					p->RestoreState(pile, bMain);					// calcul de la taille // interrompu!

-					return;

-				}

-				p = p->GivNext3b();

-			}

-		}

-		if ( pile1->GivState() == 1 && m_listass != NULL )

-		{

-			m_listass->RestoreState(pile1, bMain);

-		}

-

-	}

-

-

-	if ( m_next2b ) m_next2b->RestoreState( pile1, bMain );

-}

-

-// cas particulier pour les indices vides

-BOOL CBotEmpty :: Execute(CBotStack* &pj)

-{

-	CBotVar*	pVar = CBotVar::Create("", CBotTypInt);

-	pVar->SetValInt(-1);									// met la valeur -1 sur la pile

-	pj->SetVar(pVar);

-	return TRUE;

-}

-

-void CBotEmpty :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'une liste d'initialisation pour un tableau

-// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;

-

-

-CBotListArray::CBotListArray()

-{

-	m_expr	= NULL;

-	name = "CBotListArray";

-}

-

-CBotListArray::~CBotListArray()

-{

-	delete m_expr;

-}

-

-

-CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type)

-{

-	CBotCStack* pStk = pStack->TokenStack(p);

-

-	CBotToken* pp = p;

-

-	if ( IsOfType( p, ID_NULL ) )

-	{

-		CBotInstr* inst = new CBotExprNull ();

-		inst->SetToken( pp );

-//		CBotVar* var = CBotVar::Create("", CBotTypNullPointer);

-//		pStk->SetVar(var);

-		return pStack->Return(inst, pStk);			// ok avec élément vide

-	}

-

-	CBotListArray*	inst = new CBotListArray();		// crée l'objet

-

-	if ( IsOfType( p, ID_OPENPAR ) )

-	{

-		// prend chaque élément l'un après l'autre

-		if ( type.Eq( CBotTypArrayPointer ) )

-		{

-			type = type.GivTypElem();

-

-			pStk->SetStartError(p->GivStart());

-			if ( NULL == ( inst->m_expr = CBotListArray::Compile( p, pStk, type ) ) )

-			{

-				goto error;

-			}

-

-			while ( IsOfType( p, ID_COMMA ) )						// d'autres éléments ?

-			{

-				pStk->SetStartError(p->GivStart());

-

-				CBotInstr* i = CBotListArray::Compile( p, pStk, type );

-				if ( NULL == i )

-				{

-					goto error;

-				}

-

-				inst->m_expr->AddNext3(i);

-			}

-		}

-		else

-		{

-			pStk->SetStartError(p->GivStart());

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-			CBotVar* pv = pStk->GivVar();						// le résultat de l'expression

-

-			if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() ))		// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}

-

-			while ( IsOfType( p, ID_COMMA ) )						// d'autres éléments ?

-			{

-				pStk->SetStartError(p->GivStart());

-

-				CBotInstr* i = CBotTwoOpExpr::Compile( p, pStk ) ;

-				if ( NULL == i )

-				{

-					goto error;

-				}

-

-				CBotVar* pv = pStk->GivVar();						// le résultat de l'expression

-

-				if ( pv == NULL || !TypesCompatibles( type, pv->GivTypResult() ))		// type compatible ?

-				{

-					pStk->SetError(TX_BADTYPE, p->GivStart());

-					goto error;

-				}

-				inst->m_expr->AddNext3(i);

-			}

-		}

-

-		if (!IsOfType(p, ID_CLOSEPAR) )

-		{

-			pStk->SetError(TX_CLOSEPAR, p->GivStart());

-			goto error;

-		}

-

-		return pStack->Return(inst, pStk);

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-

-// exécute la définition d'un tableau

-

-BOOL CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar)

-{

-	CBotStack*	pile1 = pj->AddStack();

-//	if ( pile1 == EOX ) return TRUE;

-	CBotVar* pVar2;

-

-	CBotInstr* p = m_expr;

-

-	int n = 0;

-

-	for ( ; p != NULL ; n++, p = p->GivNext3() )

-	{

-		if ( pile1->GivState() > n ) continue;

-

-		pVar2 = pVar->GivItem(n, TRUE);

-

-		if ( !p->Execute(pile1, pVar2) ) return FALSE;		// évalue l'expression

-

-		pile1->IncState();

-	}

-

-	return pj->Return( pile1 );							// transmet en dessous

-}

-

-void CBotListArray::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain )

-	{

-		CBotStack*	pile  = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		CBotInstr* p = m_expr;

-

-		int	state = pile->GivState();

-

-		while( state-- > 0 ) p = p->GivNext3() ;

-

-		p->RestoreState(pile, bMain);					// calcul de la taille // interrompu!

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'une variable entière

-// int a, b = 12;

-

-CBotInt::CBotInt()

-{

-	m_next	= NULL;			// pour les définitions multiples

-	m_var	=

-	m_expr	= NULL;

-	name = "CBotInt";

-}

-

-CBotInt::~CBotInt()

-{

-	delete m_var;

-	delete m_expr;

-//	delete m_next;			// fait par le destructeur de la classe de base ~CBotInstr()

-}

-

-CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypResult type, BOOL first)

-{

-	if ( IsOfType(p, ID_OPBRK) )

-	{

-		if ( !IsOfType(p, ID_CLBRK) )

-		{

-			pStack->SetError(TX_CLBRK, p->GivStart());

-			return NULL;

-		}

-

-		CBotInstr*	inst = CompileArray(p, pStack, CBotTypResult( CBotTypArrayPointer, type ), FALSE);

-		if ( inst != NULL || !pStack->IsOk() ) return inst;

-	}

-

-	// compile une déclaration de tableau

-	if (first) return NULL ;

-

-	CBotInstr* inst = CBotInstArray::Compile( p, pStack, type );

-	if ( inst == NULL ) return NULL;

-

-	if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-	{

-		if ( NULL != ( inst->m_next2b = CBotInstArray::CompileArray(p, pStack, type, FALSE) ))	// compile la suivante

-		{

-			return inst;

-		}

-		delete inst;

-		return NULL;

-	}

-

-	if (IsOfType(p,  ID_SEP))							// instruction terminée

-	{

-		return inst;

-	}

-

-	delete inst;

-	pStack->SetError(TX_ENDOF, p->GivStart());

-	return NULL;

-}

-

-CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)

-{

-	CBotToken*	pp = cont ? NULL : p;		// pas de répétition du token "int"

-

-	if (!cont && !IsOfType(p, ID_INT)) return NULL;

-

-	CBotInt*	inst = (CBotInt*)CompileArray(p, pStack, CBotTypInt);

-	if ( inst != NULL || !pStack->IsOk() ) return inst;

-

-	CBotCStack* pStk = pStack->TokenStack(pp);

-

-	inst = new CBotInt();		// crée l'objet

-

-	inst->m_expr = NULL;

-

-	CBotToken*	vartoken = p;

-	inst->SetToken( vartoken );

-

-	// détermine l'expression valable pour l'élément gauche

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypInt;

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable

-		{

-			pStk->SetError(TX_REDEFVAR, vartoken);

-			goto error;

-		}

-

-		if (IsOfType(p,  ID_OPBRK))							// avec des indices ?

-		{

-			delete inst;									// n'est pas de type CBotInt

-			p = vartoken;									// revient sur le nom de la variable

-

-			// compile une déclaration de tableau

-

-			CBotInstr* inst2 = CBotInstArray::Compile( p, pStk, CBotTypInt );

-

-			if (!pStk->IsOk() )

-			{

-				pStk->SetError(TX_CLBRK, p->GivStart());

-				goto error;

-			}

-

-			if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-			{

-				if ( NULL != ( inst2->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) ))	// compile la suivante

-				{

-					return pStack->Return(inst2, pStk);

-				}

-			}

-			inst = (CBotInt*)inst2;

-			goto suite;			// pas d'assignation, variable déjà créée

-		}

-

-		if (IsOfType(p,  ID_ASS))							// avec une assignation ?

-		{

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-			if ( pStk->GivType() >= CBotTypBoolean )		// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}

-		}

-

-		{

-			CBotVar*	var = CBotVar::Create(vartoken, CBotTypInt);// crée la variable (après l'assignation évaluée)

-			var->SetInit(inst->m_expr != NULL);					// la marque initialisée si avec assignation

-			var->SetUniqNum(

-				((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-																// lui attribut un numéro unique

-			pStack->AddVar(var);									// la place sur la pile

-		}

-

-		if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-		{

-			if ( NULL != ( inst->m_next2b = CBotInt::Compile(p, pStk, TRUE, noskip) ))	// compile la suivante

-			{

-				return pStack->Return(inst, pStk);

-			}

-		}

-suite:

-		if (noskip || IsOfType(p,  ID_SEP))					// instruction terminée

-		{

-			return pStack->Return(inst, pStk);

-		}

-

-		pStk->SetError(TX_ENDOF, p->GivStart());

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute la définition de la variable entière

-

-BOOL CBotInt::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);	//indispensable pour SetState()

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState()==0)

-	{

-		if (m_expr && !m_expr->Execute(pile)) return FALSE;	// valeur initiale // interrompu?

-		m_var->Execute( pile );								// crée et fait l'assigation du résultat

-

-		if (!pile->SetState(1)) return FALSE;

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( m_next2b && 

-		 !m_next2b->Execute(pile)) return FALSE;				// autre(s) définition(s)

-

-	return pj->Return( pile );								// transmet en dessous

-}

-

-void CBotInt::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile = pj;

-	if ( bMain )

-	{

-		pile = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		if ( pile->GivState()==0)

-		{

-			if (m_expr) m_expr->RestoreState(pile, bMain);	// valeur initiale // interrompu!

-			return;

-		}

-	}

-

-	m_var->RestoreState(pile, bMain);

-

-	if ( m_next2b ) m_next2b->RestoreState(pile, bMain);			// autre(s) définition(s)

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'une variable booléen

-// int a, b = false;

-

-CBotBoolean::CBotBoolean()

-{

-	m_var	=

-	m_expr	= NULL;

-	name = "CBotBoolean";

-}

-

-CBotBoolean::~CBotBoolean()

-{

-	delete m_var;

-	delete m_expr;

-}

-

-CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)

-{

-	CBotToken*	pp = cont ? NULL : p;

-

-	if (!cont && !IsOfType(p, ID_BOOLEAN, ID_BOOL)) return NULL;

-

-	CBotBoolean*	inst = (CBotBoolean*)CompileArray(p, pStack, CBotTypBoolean);

-	if ( inst != NULL || !pStack->IsOk() ) return inst;

-

-	CBotCStack* pStk = pStack->TokenStack(pp);

-

-	inst = new CBotBoolean();

-

-	inst->m_expr = NULL;

-

-	CBotToken*	vartoken = p;

-	inst->SetToken( vartoken );

-	CBotVar*	var = NULL;

-

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypBoolean;

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable

-		{

-			pStk->SetError(TX_REDEFVAR, vartoken);

-			goto error;

-		}

-

-		if (IsOfType(p,  ID_OPBRK))							// avec des indices ?

-		{

-			delete inst;									// n'est pas de type CBotInt

-			p = vartoken;									// revient sur le nom de la variable

-

-			// compile une déclaration de tableau

-

-			inst = (CBotBoolean*)CBotInstArray::Compile( p, pStk, CBotTypBoolean );

-

-			if (!pStk->IsOk() )

-			{

-				pStk->SetError(TX_CLBRK, p->GivStart());

-				goto error;

-			}

-			goto suite;			// pas d'assignation, variable déjà créée

-		}

-

-		if (IsOfType(p,  ID_ASS))							// avec une assignation ?

-		{

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-			if ( !pStk->GivTypResult().Eq(CBotTypBoolean) )		// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}

-		}

-

-		var = CBotVar::Create(vartoken, CBotTypBoolean);// crée la variable (après l'assignation évaluée)

-		var->SetInit(inst->m_expr != NULL);					// la marque initialisée si avec assignation

-		var->SetUniqNum(

-			((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-															// lui attribut un numéro unique

-		pStack->AddVar(var);									// la place sur la pile

-suite:

-		if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-		{

-			if ( NULL != ( inst->m_next2b = CBotBoolean::Compile(p, pStk, TRUE, noskip) ))	// compile la suivante

-			{

-				return pStack->Return(inst, pStk);

-			}

-		}

-

-		if (noskip || IsOfType(p,  ID_SEP))							// instruction terminée

-		{

-			return pStack->Return(inst, pStk);

-		}

-

-		pStk->SetError(TX_ENDOF, p->GivStart());

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute une définition de variable booléenne

-

-BOOL CBotBoolean::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);//indispensable pour SetState()

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState()==0)

-	{

-		if (m_expr && !m_expr->Execute(pile)) return FALSE;	// valeur initiale // interrompu?

-		m_var->Execute( pile );								// crée et fait l'assigation du résultat

-

-		if (!pile->SetState(1)) return FALSE;

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( m_next2b &&

-		 !m_next2b->Execute(pile)) return FALSE;	// autre(s) définition(s)

-

-	return pj->Return( pile );								// transmet en dessous

-}

-

-void CBotBoolean::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile = pj;

-	if ( bMain )

-	{

-		pile = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		if ( pile->GivState()==0)

-		{

-			if (m_expr) m_expr->RestoreState(pile, bMain);		// valeur initiale interrompu?

-			return;

-		}

-	}

-

-	m_var->RestoreState( pile, bMain );				// 

-

-	if ( m_next2b )

-		 m_next2b->RestoreState(pile, bMain);				// autre(s) définition(s)

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'une variable réelle

-// int a, b = 12.4;

-

-CBotFloat::CBotFloat()

-{

-	m_var	=

-	m_expr	= NULL;

-	name = "CBotFloat";

-}

-

-CBotFloat::~CBotFloat()

-{

-	delete m_var;

-	delete m_expr;

-}

-

-CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)

-{

-	CBotToken*	pp = cont ? NULL : p;

-

-	if (!cont && !IsOfType(p, ID_FLOAT)) return NULL;

-

-	CBotFloat*	inst = (CBotFloat*)CompileArray(p, pStack, CBotTypFloat);

-	if ( inst != NULL || !pStack->IsOk() ) return inst;

-

-	CBotCStack* pStk = pStack->TokenStack(pp);

-

-	inst = new CBotFloat();

-

-	inst->m_expr = NULL;

-

-	CBotToken*	vartoken = p;

-	CBotVar*	var = NULL;

-	inst->SetToken(vartoken);

-

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypFloat;

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable

-		{

-			pStk->SetStartError(vartoken->GivStart());

-			pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());

-			goto error;

-		}

-

-		if (IsOfType(p,  ID_OPBRK))							// avec des indices ?

-		{

-			delete inst;									// n'est pas de type CBotInt

-			p = vartoken;									// revient sur le nom de la variable

-

-			// compile une déclaration de tableau

-

-			inst = (CBotFloat*)CBotInstArray::Compile( p, pStk, CBotTypFloat );

-

-			if (!pStk->IsOk() )

-			{

-				pStk->SetError(TX_CLBRK, p->GivStart());

-				goto error;

-			}

-			goto suite;			// pas d'assignation, variable déjà créée

-		}

-

-		if (IsOfType(p,  ID_ASS))							// avec une assignation ?

-		{

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-			if ( pStk->GivType() >= CBotTypBoolean )		// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}

-		}

-

-		var = CBotVar::Create(vartoken, CBotTypFloat);		// crée la variable (après l'assignation évaluée)

-		var->SetInit(inst->m_expr != NULL);					// la marque initialisée si avec assignation

-		var->SetUniqNum(

-			((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-															// lui attribut un numéro unique

-		pStack->AddVar(var);									// la place sur la pile

-suite:

-		if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-		{

-			if ( NULL != ( inst->m_next2b = CBotFloat::Compile(p, pStk, TRUE, noskip) ))	// compile la suivante

-			{

-				return pStack->Return(inst, pStk);

-			}

-		}

-

-		if (noskip || IsOfType(p,  ID_SEP))							// instruction terminée

-		{

-			return pStack->Return(inst, pStk);

-		}

-

-		pStk->SetError(TX_ENDOF, p->GivStart());

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute la défintion de la variable réelle

-

-BOOL CBotFloat::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);//indispensable pour SetState()

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState()==0)

-	{

-		if (m_expr && !m_expr->Execute(pile)) return FALSE;	// valeur initiale // interrompu?

-		m_var->Execute( pile );								// crée et fait l'assigation du résultat

-

-		if (!pile->SetState(1)) return FALSE;

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( m_next2b &&

-		 !m_next2b->Execute(pile)) return FALSE;	// autre(s) définition(s)

-

-	return pj->Return( pile );								// transmet en dessous

-}

-

-void CBotFloat::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile = pj;

-	if ( bMain )

-	{

-		pile = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		if ( pile->GivState()==0)

-		{

-			if (m_expr) m_expr->RestoreState(pile, bMain);		// valeur initiale interrompu?

-			return;

-		}

-	}

-

-	m_var->RestoreState( pile, bMain );				// 

-

-	if ( m_next2b )

-		 m_next2b->RestoreState(pile, bMain);				// autre(s) définition(s)

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// définition d'une variable chaîne de caractères

-// int a, b = "salut";

-

-CBotIString::CBotIString()

-{

-	m_var	=

-	m_expr	= NULL;

-	name = "CBotIString";

-}

-

-CBotIString::~CBotIString()

-{

-	delete m_var;

-	delete m_expr;

-}

-

-CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont, BOOL noskip)

-{

-	CBotToken*	pp = cont ? NULL : p;

-

-	if (!cont && !IsOfType(p, ID_STRING)) return NULL;

-

-	CBotIString*	inst = (CBotIString*)CompileArray(p, pStack, CBotTypString);

-	if ( inst != NULL || !pStack->IsOk() ) return inst;

-

-	CBotCStack* pStk = pStack->TokenStack(pp);

-

-	inst = new CBotIString();

-

-	inst->m_expr = NULL;

-

-	CBotToken*	vartoken = p;

-	inst->SetToken( vartoken );

-

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypString;

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable

-		{

-			pStk->SetStartError(vartoken->GivStart());

-			pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());

-			goto error;

-		}

-

-		if (IsOfType(p,  ID_ASS))							// avec une assignation ?

-		{

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-/*			if ( !pStk->GivTypResult().Eq(CBotTypString) )			// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}*/

-		}

-

-		CBotVar*	var = CBotVar::Create(vartoken, CBotTypString);		// crée la variable (après l'assignation évaluée)

-		var->SetInit(inst->m_expr != NULL);					// la marque initialisée si avec assignation

-		var->SetUniqNum(

-			((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-															// lui attribut un numéro unique

-		pStack->AddVar(var);									// la place sur la pile

-

-		if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-		{

-			if ( NULL != ( inst->m_next2b = CBotIString::Compile(p, pStk, TRUE, noskip) ))	// compile la suivante

-			{

-				return pStack->Return(inst, pStk);

-			}

-		}

-		

-		if (noskip || IsOfType(p,  ID_SEP))							// instruction terminée

-		{

-			return pStack->Return(inst, pStk);

-		}

-

-		pStk->SetError(TX_ENDOF, p->GivStart());

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute la définition de la variable string

-

-BOOL CBotIString::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);//indispensable pour SetState()

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState()==0)

-	{

-		if (m_expr && !m_expr->Execute(pile)) return FALSE;	// valeur initiale // interrompu?

-		m_var->Execute( pile );								// crée et fait l'assigation du résultat

-

-		if (!pile->SetState(1)) return FALSE;

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( m_next2b &&

-		 !m_next2b->Execute(pile)) return FALSE;	// autre(s) définition(s)

-

-	return pj->Return( pile );								// transmet en dessous

-}

-

-void CBotIString::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile = pj;

-	

-	if ( bMain )

-	{

-		pile = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		if ( pile->GivState()==0)

-		{

-			if (m_expr) m_expr->RestoreState(pile, bMain);		// valeur initiale interrompu?

-			return;

-		}

-	}

-

-	m_var->RestoreState( pile, bMain );				// 

-

-	if ( m_next2b )

-		 m_next2b->RestoreState(pile, bMain);				// autre(s) définition(s)

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une instruction de type " x = 123 " ou " z * 5 + 4 "

-// avec ou sans assignation donc

-

-CBotExpression::CBotExpression()

-{

-	m_leftop	= NULL;

-	m_rightop	= NULL;

-	name = "CBotExpression";

-}

-

-CBotExpression::~CBotExpression()

-{

-	delete	m_leftop;

-	delete	m_rightop;

-}

-

-CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;

-

-	CBotExpression* inst = new CBotExpression();

-

-	inst->m_leftop = CBotLeftExpr::Compile(p, pStack);

-

-	inst->SetToken(p);

-	int  OpType = p->GivType();

-

-	if ( pStack->IsOk() &&

-		 IsOfTypeList(p, ID_ASS, ID_ASSADD, ID_ASSSUB, ID_ASSMUL, ID_ASSDIV, ID_ASSMODULO, 

-								 ID_ASSAND, ID_ASSXOR, ID_ASSOR, 

-								 ID_ASSSL , ID_ASSSR,  ID_ASSASR, 0 ))

-	{

-		if ( inst->m_leftop == NULL )

-		{

-			pStack->SetError(TX_BADLEFT, p->GivEnd());

-			delete inst;

-			return NULL;

-		}

-

-		inst->m_rightop = CBotExpression::Compile(p, pStack);

-		if (inst->m_rightop == NULL)

-		{

-			delete inst;

-			return NULL;

-		}

-

-		CBotTypResult	type1 = pStack->GivTypResult();

-

-		// récupère la variable pour la marquer assignée

-		CBotVar*	var = NULL;

-		inst->m_leftop->ExecuteVar(var, pStack);

-		if ( var == NULL )

-		{

-			delete inst;

-			return NULL;

-		}

-

-		if (OpType != ID_ASS && var->GivInit() != IS_DEF)

-		{

-			pStack->SetError(TX_NOTINIT, pp);

-			delete inst;

-			return NULL;

-		}

-

-		CBotTypResult type2 = var->GivTypResult();

-

-		// quels sont les types acceptables ?

-		switch (OpType)

-		{

-		case ID_ASS:

-	//		if (type2 == CBotTypClass) type2 = -1;		// pas de classe

-			if ( (type1.Eq(CBotTypPointer) && type2.Eq(CBotTypPointer) ) ||

-				 (type1.Eq(CBotTypClass)   && type2.Eq(CBotTypClass)   ) )

-			{

-/*				CBotClass*	c1 = type1.GivClass();

-				CBotClass*	c2 = type2.GivClass();

-				if ( !c1->IsChildOf(c2) ) type2.SetType(-1);	// pas la même classe

-//-				if ( !type1.Eq(CBotTypClass) ) var->SetPointer(pStack->GivVar()->GivPointer());*/

-				var->SetInit(2);

-			}

-			else

-				var->SetInit(TRUE);

-

-			break;

-		case ID_ASSADD:

-			if (type2.Eq(CBotTypBoolean) ||

-				type2.Eq(CBotTypPointer) ) type2 = -1;		// nombres et chaines

-			break;

-		case ID_ASSSUB:

-		case ID_ASSMUL:

-		case ID_ASSDIV:

-		case ID_ASSMODULO:

-			if (type2.GivType() >= CBotTypBoolean) type2 = -1;	// nombres uniquement

-			break;

-		}

-

-		if (!TypeCompatible( type1, type2, OpType ))

-		{

-			pStack->SetError(TX_BADTYPE, &inst->m_token);

-			delete inst;

-			return NULL;

-		}

-

-		return inst;		// types compatibles ?

-	}

-

-	delete inst;

-//	p = p->GivNext();

-	int start, end, error = pStack->GivError(start, end);

-

-	p = pp;										// revient au début

-	pStack->SetError(0,0);						// oublie l'erreur

-

-//	return CBotTwoOpExpr::Compile(p, pStack);	// essaie sans assignation

-	CBotInstr* i = CBotTwoOpExpr::Compile(p, pStack);	// essaie sans assignation

-	if ( i != NULL && error == TX_PRIVATE && p->GivType() == ID_ASS )

-		pStack->ResetError( error, start, end );

-	return i;

-}

-

-// exécute une expression avec assignation

-

-BOOL CBotExpression::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile  = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	CBotToken*	pToken = m_leftop->GivToken();

-	CBotVar*	pVar = NULL;

-

-	CBotStack*  pile1 = pile;

-

-	BOOL		IsInit = TRUE;

-	CBotVar*	result = NULL;

-

-	// doit être fait avant pour les indices éventuels (pile peut être changée)

-	if ( !m_leftop->ExecuteVar(pVar, pile, NULL, FALSE) ) return FALSE;	// variable avant évaluation de la valeur droite

-

-//	DEBUG( "CBotExpression::Execute", -1, pj);

-	if ( pile1->GivState()==0)

-	{

-		pile1->SetCopyVar(pVar);								// garde une copie sur la pile (si interrompu)

-		pile1->IncState();

-	}

-

-	CBotStack*	pile2 = pile->AddStack();						// attention pile et surtout pas pile1

-

-	if ( pile2->GivState()==0)

-	{

-//		DEBUG( "CBotExpression::Execute", -2, pj);

-		if (m_rightop && !m_rightop->Execute(pile2)) return FALSE;	// valeur initiale // interrompu?

-		pile2->IncState();

-	}

-

-	if ( pile1->GivState() == 1 )

-	{

-//		DEBUG( "CBotExpression::Execute", -3, pj);

-		if ( m_token.GivType() != ID_ASS )

-		{

-			pVar = pile1->GivVar();										// récupére si interrompu

-			IsInit = pVar->GivInit();

-			if ( IsInit == IS_NAN )

-			{

-				pile2->SetError(TX_OPNAN, m_leftop->GivToken());

-				return pj->Return(pile2);

- 			}

-			result = CBotVar::Create("", pVar->GivTypResult(2));

-		}

-

-		switch ( m_token.GivType() )

-		{

-		case ID_ASS:

-			break;

-		case ID_ASSADD:

-			result->Add(pile1->GivVar(), pile2->GivVar());			// additionne

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSSUB:

-			result->Sub(pile1->GivVar(), pile2->GivVar());			// soustrait

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSMUL:

-			result->Mul(pile1->GivVar(), pile2->GivVar());			// multiplie

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSDIV:

-			if (IsInit && 

-				result->Div(pile1->GivVar(), pile2->GivVar()))		// divise

-				pile2->SetError(TX_DIVZERO, &m_token);

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSMODULO:

-			if (IsInit && 

-				result->Modulo(pile1->GivVar(), pile2->GivVar()))	// reste de la division

-				pile2->SetError(TX_DIVZERO, &m_token);

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSAND:

-			result->And(pile1->GivVar(), pile2->GivVar());			// multiplie

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSXOR:

-			result->XOr(pile1->GivVar(), pile2->GivVar());

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSOR:

-			result->Or(pile1->GivVar(), pile2->GivVar());

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSSL:

-			result->SL(pile1->GivVar(), pile2->GivVar());

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSSR:

-			result->SR(pile1->GivVar(), pile2->GivVar());

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		case ID_ASSASR:

-			result->ASR(pile1->GivVar(), pile2->GivVar());

-			pile2->SetVar(result);									// re-place le résultat

-			break;

-		default:

-			ASM_TRAP();

-		}

-		if (!IsInit)

-			pile2->SetError(TX_NOTINIT, m_leftop->GivToken());

-

-		pile1->IncState();

-	}

-

-//	DEBUG( "CBotExpression::Execute", -4, pj);

-	if ( !m_leftop->Execute( pile2, pile1 ) )

-		return FALSE;											// crée et fait l'assigation du résultat

-

-	return pj->Return( pile2 );									// transmet en dessous

-}

-

-

-void CBotExpression::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain )

-	{

-		CBotToken*	pToken = m_leftop->GivToken();

-		CBotVar*	pVar = NULL;

-

-		CBotStack*	pile  = pj->RestoreStack(this);

-		if ( pile == NULL ) return;

-

-		CBotStack*  pile1 = pile;

-	

-

-		if ( pile1->GivState()==0)

-		{

-			m_leftop->RestoreStateVar(pile, TRUE);	// variable avant évaluation de la valeur droite

-			return;

-		}

-

-		m_leftop->RestoreStateVar(pile, FALSE);	// variable avant évaluation de la valeur droite

-

-		CBotStack*	pile2 = pile->RestoreStack();						// attention pile et surtout pas pile1

-		if ( pile2 == NULL ) return;

-

-		if ( pile2->GivState()==0)

-		{

-			if (m_rightop) m_rightop->RestoreState(pile2, bMain);		// valeur initiale // interrompu?

-			return;

-		}

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une instruction de type " ( condition ) "

-// la condition doit être de type booléen

-

-// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe

-// l'objet retourné par Compile est généralement de type CBotExpression

-

-CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	pStack->SetStartError(p->GivStart());

-	if ( IsOfType(p, ID_OPENPAR ))

-	{

-		CBotInstr* inst = CBotBoolExpr::Compile( p, pStack );

-		if ( NULL != inst )

-		{

-			if ( IsOfType(p, ID_CLOSEPAR ))

-			{

-				return inst;

-			}

-			pStack->SetError(TX_CLOSEPAR, p->GivStart());	// manque la parenthèse

-		}

-		delete inst;

-	}

-

-	pStack->SetError(TX_OPENPAR, p->GivStart());	// manque la parenthèse

-

-	return NULL;

-}

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une instruction de type " condition "

-// la condition doit être de type booléen

-

-// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe

-// l'objet retourné par Compile est généralement de type CBotExpression

-

-CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	pStack->SetStartError(p->GivStart());

-

-	CBotInstr* inst = CBotTwoOpExpr::Compile( p, pStack );

-

-	if ( NULL != inst )

-	{

-		if ( pStack->GivTypResult().Eq(CBotTypBoolean) )

-		{

-			return inst;

-		}

-		pStack->SetError(TX_NOTBOOL, p->GivStart());	// n'est pas un booléan

-	}

-

-	delete inst;

-	return NULL;

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile soit :

-//	une instruction entre parenthèses (...)

-//	une expression unaire (négatif, not)

-//	nom de variable

-//	les variables prè et post incrémentées ou décrémentées

-//	un nombre donné par DefineNum

-//	une constante

-//	un appel de procédure

-//	l'instruction new

-

-// cette classe n'a pas de constructeur, car il n'y a jamais d'instance de cette classe

-// l'objet retourné par Compile est de la classe correspondant à l'instruction

-

-CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->TokenStack();

-

-	pStk->SetStartError(p->GivStart());

-

-	// est-ce une expression entre parenthèse ?

-	if (IsOfType(p, ID_OPENPAR))

-	{

-		CBotInstr* inst = CBotExpression::Compile( p, pStk );

-

-		if ( NULL != inst )

-		{

-			if (IsOfType(p, ID_CLOSEPAR))

-			{

-				return pStack->Return(inst, pStk);

-			}

-			pStk->SetError(TX_CLOSEPAR, p->GivStart());

-		}

-		delete inst;

-		return pStack->Return(NULL, pStk);

-	}

-

-	// est-ce une opération unaire ?

-	CBotInstr* inst = CBotExprUnaire::Compile(p, pStk);

-	if (inst != NULL || !pStk->IsOk())

-		return pStack->Return(inst, pStk);

-

-	// est-ce un nom de variable ?

-	if (p->GivType() == TokenTypVar)

-	{

-		// c'est peut-être un appel de méthode sans le "this." devant

-		inst =  CBotExprVar::CompileMethode(p, pStk);

-		if ( inst != NULL ) return pStack->Return(inst, pStk);

-

-

-		// est-ce un appel de procédure ?

-		inst =  CBotInstrCall::Compile(p, pStk);

-		if ( inst != NULL || !pStk->IsOk() )

-			return pStack->Return(inst, pStk);

-

-

-		CBotToken* pvar = p;

-		// non, c'est une variable "ordinaire"

-		inst =  CBotExprVar::Compile(p, pStk);

-

-		CBotToken* pp = p;

-		// post incrémenté ou décrémenté ?

-		if (IsOfType(p, ID_INC, ID_DEC))

-		{

-			if ( pStk->GivType() >= CBotTypBoolean )

-			{

-				pStk->SetError(TX_BADTYPE, pp);

-				delete inst;

-				return pStack->Return(NULL, pStk);

-			}

-

-			// recompile la variable pour read-only

-			delete inst;

-			p = pvar;

-			inst =  CBotExprVar::Compile(p, pStk, PR_READ);

-			p = p->GivNext();

-

-			CBotPostIncExpr* i = new CBotPostIncExpr();

-			i->SetToken(pp);

-			i->m_Instr = inst;	// instruction associée

-			return pStack->Return(i, pStk);

-		}

-		return pStack->Return(inst, pStk);

-	}

-

-	// est-ce une variable préincrémentée ou prédécrémentée ?

-	CBotToken* pp = p;

-	if (IsOfType(p, ID_INC, ID_DEC))

-	{

-		CBotPreIncExpr* i = new CBotPreIncExpr();

-		i->SetToken(pp);

-

-		if (p->GivType() == TokenTypVar)

-		{

-			if (NULL != (i->m_Instr =  CBotExprVar::Compile(p, pStk, PR_READ)))

-			{

-				if ( pStk->GivType() >= CBotTypBoolean )

-				{

-					pStk->SetError(TX_BADTYPE, pp);

-					delete inst;

-					return pStack->Return(NULL, pStk);

-				}

-				return pStack->Return(i, pStk);

-			}

-			delete i;

-			return pStack->Return(NULL, pStk);

-		}

-	}

-

-	// est-ce un nombre  ou un DefineNum ?

-	if (p->GivType() == TokenTypNum || 

-		p->GivType() == TokenTypDef )

-	{

-		CBotInstr* inst = CBotExprNum::Compile( p, pStk );

-		return pStack->Return(inst, pStk);

-	}

-

-	// est-ce une chaine ?

-	if (p->GivType() == TokenTypString)

-	{

-		CBotInstr* inst = CBotExprAlpha::Compile(p, pStk);

-		return pStack->Return(inst, pStk);

-	}

-

-	// est un élément "true" ou "false"

-	if (p->GivType() == ID_TRUE ||

-		p->GivType() == ID_FALSE )

-	{

-		CBotInstr* inst = CBotExprBool::Compile( p, pStk );

-		return pStack->Return(inst, pStk);

-	}

-

-	// est un objet à créer avec new

-	if (p->GivType() == ID_NEW)

-	{

-		CBotInstr* inst = CBotNew::Compile( p, pStk );

-		return pStack->Return(inst, pStk);

-	}

-

-	// est un pointeur nul

-	if (IsOfType( p, ID_NULL ))

-	{

-		CBotInstr* inst = new CBotExprNull ();

-		inst->SetToken( pp );

-		CBotVar* var = CBotVar::Create("", CBotTypNullPointer);

-		pStk->SetVar(var);

-		return pStack->Return(inst, pStk);

-	}

-

-	// est un nombre nan

-	if (IsOfType( p, ID_NAN ))

-	{

-		CBotInstr* inst = new CBotExprNan ();

-		inst->SetToken( pp );

-		CBotVar* var = CBotVar::Create("", CBotTypInt);

-		var->SetInit(IS_NAN);

-		pStk->SetVar(var);

-		return pStack->Return(inst, pStk);

-	}

-

-

-	return pStack->Return(NULL, pStk);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// gestion du post et pré- incrément/décrément

-

-// il n'y a pas de routine Compile, l'objet est créé directement

-// dans CBotParExpr::Compile

-

-CBotPostIncExpr::CBotPostIncExpr()

-{

-	m_Instr = NULL;

-	name	= "CBotPostIncExpr";

-}

-

-CBotPostIncExpr::~CBotPostIncExpr()

-{

-	delete	m_Instr;

-}

-

-CBotPreIncExpr::CBotPreIncExpr()

-{

-	m_Instr = NULL;

-	name	= "CBotPreIncExpr";

-}

-

-CBotPreIncExpr::~CBotPreIncExpr()

-{

-	delete	m_Instr;

-}

-

-BOOL CBotPostIncExpr::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile1 = pj->AddStack(this);

-	CBotStack*	pile2 = pile1;

-

-	CBotVar*	var1 = NULL;

-

-	if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE;		// récupère la variable selon champs et index

-

-	pile1->SetState(1);

-	pile1->SetCopyVar(var1);								// place le résultat (avant incrémentation);

-

-	CBotStack* pile3 = pile2->AddStack(this); 

-	if ( pile3->IfStep() ) return FALSE;

-

-	if ( var1->GivInit() == IS_NAN )

-	{

-		pile1->SetError( TX_OPNAN, &m_token );

-	}

-

-	if ( var1->GivInit() != IS_DEF )

-	{

-		pile1->SetError( TX_NOTINIT, &m_token );

-	}

-

-	if (GivTokenType() == ID_INC) var1->Inc();

-	else						  var1->Dec();

-

-	return pj->Return(pile1);						// opération faite, résultat sur pile2

-}

-

-void CBotPostIncExpr::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile1 = pj->RestoreStack(this);

-	if ( pile1 == NULL ) return;

-

-	((CBotExprVar*)m_Instr)->RestoreStateVar(pile1, bMain);

-

-	if ( pile1 != NULL ) pile1->RestoreStack(this);

-}

-

-BOOL CBotPreIncExpr::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	CBotVar*	 var1;

-

-	if ( pile->GivState() == 0 )

-	{

-		CBotStack*	pile2 = pile;

-		if ( !((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, TRUE) ) return FALSE;		// récupère la variable selon champs et index

-																								// pile2 est modifié en retour

-

-		if ( var1->GivInit() == IS_NAN )

-		{

-			pile->SetError( TX_OPNAN, &m_token );

-			return pj->Return(pile);						// opération faite

-		}

-

-		if ( var1->GivInit() != IS_DEF )

-		{

-			pile->SetError( TX_NOTINIT, &m_token );

-			return pj->Return(pile);						// opération faite

-		}

-

-		if (GivTokenType() == ID_INC) var1->Inc();

-		else						  var1->Dec();		// ((CBotVarInt*)var1)->m_val

-

-		pile->IncState();

-	}

-

-	if ( !m_Instr->Execute(pile) ) return FALSE;

-	return pj->Return(pile);						// opération faite

-}

-

-

-void CBotPreIncExpr::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	if ( pile->GivState() == 0 )

-	{

-		return;

-	}

-

-	m_Instr->RestoreState(pile, bMain);

-}

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une expression unaire

-//	+

-//	-

-//	not

-//	!

-//	~

-

-CBotExprUnaire::CBotExprUnaire()

-{

-	m_Expr = NULL;

-	name = "CBotExprUnaire";

-}

-

-CBotExprUnaire::~CBotExprUnaire()

-{

-	delete m_Expr;

-}

-

-CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	int op = p->GivType();

-	CBotToken*	pp = p;

-	if ( !IsOfTypeList( p, ID_ADD, ID_SUB, ID_LOG_NOT, ID_TXT_NOT, ID_NOT, 0 ) ) return NULL;

-

-	CBotCStack* pStk = pStack->TokenStack(pp);

-

-	CBotExprUnaire* inst = new CBotExprUnaire();

-	inst->SetToken(pp);

-

-	if ( NULL != (inst->m_Expr = CBotParExpr::Compile( p, pStk )) )

-	{

-		if ( op == ID_ADD && pStk->GivType() < CBotTypBoolean )		// seulement avec des nombre

-			return pStack->Return(inst, pStk);

-		if ( op == ID_SUB && pStk->GivType() < CBotTypBoolean )		// seulement avec des nombre

-			return pStack->Return(inst, pStk);

-		if ( op == ID_NOT && pStk->GivType() < CBotTypFloat )		// seulement avec des entiers

-			return pStack->Return(inst, pStk);

-		if ( op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens

-			return pStack->Return(inst, pStk);

-		if ( op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean) )// seulement avec des booléens

-			return pStack->Return(inst, pStk);

-

-		pStk->SetError(TX_BADTYPE, &inst->m_token);

-	}

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute l'expresson unaire

-

-BOOL CBotExprUnaire::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState() == 0 )

-	{

-		if (!m_Expr->Execute( pile )) return FALSE;					// interrompu ?

-		pile->IncState();

-	}

-

-	CBotStack* pile2 = pile->AddStack();

-	if ( pile2->IfStep() ) return FALSE;

-

-	CBotVar*	var = pile->GivVar();								// récupère le résultat sur la pile

-

-	switch (GivTokenType())

-	{

-	case ID_ADD:

-		break;														// ne fait donc rien

-	case ID_SUB:

-		var->Neg();													// change le signe

-		break;

-	case ID_NOT:

-	case ID_LOG_NOT:

-	case ID_TXT_NOT:

-		var->Not();

-		break;

-	}

-	return pj->Return(pile);										// transmet en dessous

-}

-

-void CBotExprUnaire::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile = pj->RestoreStack(this);

-	if ( pile == NULL) return;

-

-	if ( pile->GivState() == 0 )

-	{

-		m_Expr->RestoreState( pile, bMain );						// interrompu ici !

-		return;

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// gestion des index pour les tableaux

-// array [ expression ]

-

-

-CBotIndexExpr::CBotIndexExpr()

-{

-	m_expr	= NULL;

-	name	= "CBotIndexExpr";

-}

-

-CBotIndexExpr::~CBotIndexExpr()

-{

-	delete	m_expr;

-}

-

-// trouve un champ à partir de l'instance à la compilation

-

-BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)

-{

-	if ( pVar->GivType(1) != CBotTypArrayPointer )

-		ASM_TRAP();

-

-	pVar = ((CBotVarArray*)pVar)->GivItem(0, FALSE);			// à la compilation rend l'élément [0]

-	if ( pVar == NULL )

-	{

-		pile->SetError(TX_OUTARRAY, m_token.GivEnd());

-		return FALSE;

-	}

-	if ( m_next3 != NULL ) return m_next3->ExecuteVar(pVar, pile);

-	return TRUE;

-}

-

-// idem à l'exécution

-// attention, modifie le pointeur à la pile volontairement

-// place les index calculés sur la pile supplémentaire

-

-BOOL CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)

-{

-	CBotStack*	pj = pile;

-//	DEBUG( "CBotIndexExpr::ExecuteVar", -1 , pj);

-

-	if ( pVar->GivType(1) != CBotTypArrayPointer )

-		ASM_TRAP();

-

-	pile = pile->AddStack();

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState() == 0 )

-	{

-		if ( !m_expr->Execute(pile) ) return FALSE;

-		pile->IncState();

-	}

-	// traite les tableaux

-

-	CBotVar* p = pile->GivVar();							// résultat sur la pile

-

-	if ( p == NULL || p->GivType() > CBotTypDouble )

-	{

-		pile->SetError(TX_BADINDEX, prevToken);

-		return pj->Return(pile);

-	}

-

-	int n = p->GivValInt();									// position dans le tableau

-//	DEBUG( "CBotIndexExpr::ExecuteVar", n , pj);

-

-	pVar = ((CBotVarArray*)pVar)->GivItem(n, bExtend);

-	if ( pVar == NULL )

-	{

-		pile->SetError(TX_OUTARRAY, prevToken);

-		return pj->Return(pile);

-	}

-

-//	DEBUG( "CBotIndexExpr::ExecuteVar", -2 , pj);

-	//if ( bUpdate )

-		pVar->Maj(pile->GivPUser(), TRUE);

-

-//	DEBUG( "CBotIndexExpr::ExecuteVar", -3 , pj);

-	if ( m_next3 != NULL && 

-		 !m_next3->ExecuteVar(pVar, pile, prevToken, bStep, bExtend) ) return FALSE;

-

-//	DEBUG( "CBotIndexExpr::ExecuteVar", -4 , pj);

-	return TRUE;										// ne libère pas la pile

-														// pour éviter de recalculer les index deux fois le cas échéant

-}

-

-void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)

-{

-	pile = pile->RestoreStack();

-	if ( pile == NULL ) return;

-

-	if ( bMain && pile->GivState() == 0 )

-	{

-		m_expr->RestoreState(pile, TRUE);

-		return;

-	}

-

-	if ( m_next3 ) 

-		 m_next3->RestoreStateVar(pile, bMain);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// gestion des champs dans une instance (opérateur point)

-// toto.x

-

-

-CBotFieldExpr::CBotFieldExpr()

-{

-	name		= "CBotFieldExpr";

-	m_nIdent	= 0;

-}

-

-CBotFieldExpr::~CBotFieldExpr()

-{

-}

-

-void CBotFieldExpr::SetUniqNum(int num)

-{

-	m_nIdent = num;

-}

-

-

-// trouve un champ à partir de l'instance à la compilation

-

-BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)

-{

-	if ( pVar->GivType(1) != CBotTypPointer )

-		ASM_TRAP();

-

-//	pVar = pVar->GivItem(m_token.GivString());

-	pVar = pVar->GivItemRef(m_nIdent);

-	if ( pVar == NULL )

-	{

-		pile->SetError(TX_NOITEM, &m_token);

-		return FALSE;

-	}

-

-	if ( m_next3 != NULL &&

-		 !m_next3->ExecuteVar(pVar, pile) ) return FALSE;

-

-	return TRUE;

-}

-

-// idem à l'exécution

-

-BOOL CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend)

-{

-	CBotStack*	pj = pile;

-	pile = pile->AddStack(this);				// modifie pile en sortie

-	if ( pile == EOX ) return TRUE;

-

-//	DEBUG( "CBotFieldExpre::ExecuteVar "+m_token.GivString(), 0, pj );

-

-	if ( pVar->GivType(1) != CBotTypPointer )

-		ASM_TRAP();

-

-	CBotVarClass* pItem = pVar->GivPointer();

-	if ( pItem == NULL )

-	{

-		pile->SetError(TX_NULLPT, prevToken);

-		return pj->Return( pile );

-	}

-	if ( pItem->GivUserPtr() == OBJECTDELETED )

-	{

-		pile->SetError(TX_DELETEDPT, prevToken);

-		return pj->Return( pile );

-	}

-

-	if ( bStep && pile->IfStep() ) return FALSE;

-

-//	pVar = pVar->GivItem(m_token.GivString());

-	pVar = pVar->GivItemRef(m_nIdent);

-	if ( pVar == NULL )

-	{

-		pile->SetError(TX_NOITEM, &m_token);

-		return pj->Return( pile );

-	}

-

-	if ( pVar->IsStatic() )

-	{

-//		DEBUG( "IsStatic", 0, pj) ;

-		// pour une variable statique, la prend dans la classe elle-même

-		CBotClass* pClass = pItem->GivClass();

-		pVar = pClass->GivItem(m_token.GivString());

-//		DEBUG( "done "+pVar->GivName(), 0, pj) ;

-	}

-

-	// demande la mise à jour de l'élément, s'il y a lieu

-	pVar->Maj(pile->GivPUser(), TRUE);

-

-	if ( m_next3 != NULL && 

-		 !m_next3->ExecuteVar(pVar, pile, &m_token, bStep, bExtend) ) return FALSE;

-

-	return TRUE;										// ne libère pas la pile

-														// pour conserver l'état SetState() correspondant à l'étape

-}

-

-void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, BOOL bMain)

-{

-	pj = pj->RestoreStack(this);				// modifie pj en sortie

-	if ( pj == NULL ) return;

-

-	if ( m_next3 != NULL ) 

-		 m_next3->RestoreStateVar(pj, bMain);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un opérande gauche pour une assignation

-

-CBotLeftExpr::CBotLeftExpr()

-{

-	name	= "CBotLeftExpr";

-	m_nIdent = 0;

-}

-

-CBotLeftExpr::~CBotLeftExpr()

-{

-}

-

-// compile une expression pour un left-opérande ( à gauche d'une assignation)

-// cela peut être

-// toto

-// toto[ 3 ]

-// toto.x

-// toto.pos.x

-// toto[2].pos.x

-// toto[1].pos[2].x

-// toto[1][2][3]

-

-CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->TokenStack();

-

-	pStk->SetStartError(p->GivStart());

-

-	// est-ce un nom de variable ?

-	if (p->GivType() == TokenTypVar)

-	{

-		CBotLeftExpr* inst = new CBotLeftExpr();					// crée l'objet

-

-		inst->SetToken(p);

-

-		CBotVar*	 var;

-		

-		if ( NULL != (var = pStk->FindVar(p)) )						// cherche si variable connue

-		{

-			inst->m_nIdent = var->GivUniqNum();

-			if (inst->m_nIdent > 0 && inst->m_nIdent < 9000)

-			{

-				if ( var->IsPrivate(PR_READ) &&

-					 !pStk->GivBotCall()->m_bCompileClass)

-				{

-					pStk->SetError( TX_PRIVATE, p );

-					goto err;

-				}

-				// il s'agit d'un élement de la classe courante

-				// ajoute l'équivalent d'un this. devant

-				CBotToken pthis("this");

-				inst->SetToken(&pthis);

-				inst->m_nIdent = -2;							// ident pour this

-

-				CBotFieldExpr* i = new CBotFieldExpr();			// nouvel élément

-				i->SetToken( p );								// garde le nom du token

-				inst->AddNext3(i);								// ajoute à la suite

-

-				var = pStk->FindVar(pthis);

-				var = var->GivItem(p->GivString());

-				i->SetUniqNum(var->GivUniqNum());

-			}

-			p = p->GivNext();										// token suivant

-

-			while (TRUE)

-			{

-				if ( var->GivType() == CBotTypArrayPointer )		// s'il sagit d'un tableau 

-				{

-					if ( IsOfType( p, ID_OPBRK ) )						// regarde s'il y a un index

-					{

-						CBotIndexExpr* i = new CBotIndexExpr();

-						i->m_expr = CBotExpression::Compile(p, pStk);		// compile la formule

-						inst->AddNext3(i);									// ajoute à la chaine

-

-						var = ((CBotVarArray*)var)->GivItem(0,TRUE);		// donne le composant [0]

-

-						if ( i->m_expr == NULL )

-						{

-							pStk->SetError( TX_BADINDEX, p->GivStart() );

-							goto err;

-						}

-

-						if ( !pStk->IsOk() || !IsOfType( p, ID_CLBRK ) )

-						{

-							pStk->SetError( TX_CLBRK, p->GivStart() );

-							goto err;

-						}

-						continue;

-					}

-				}

-

-				if ( var->GivType(1) == CBotTypPointer )				// pour les classes

-				{

-					if ( IsOfType(p, ID_DOT) )

-					{

-						CBotToken* pp = p;

-

-						CBotFieldExpr* i = new CBotFieldExpr();			// nouvel élément

-						i->SetToken( pp );								// garde le nom du token

-						inst->AddNext3(i);								// ajoute à la suite

-

-						if ( p->GivType() == TokenTypVar )				// doit être un nom

-						{

-							var = var->GivItem(p->GivString());			// récupère l'item correpondant

-							if ( var != NULL )

-							{

-								if ( var->IsPrivate(PR_READ) &&

-									 !pStk->GivBotCall()->m_bCompileClass)

-								{

-									pStk->SetError( TX_PRIVATE, pp );

-									goto err;

-								}

-

-								i->SetUniqNum(var->GivUniqNum());

-								p = p->GivNext();						// saute le nom

-								continue;

-							}

-							pStk->SetError( TX_NOITEM, p );

-						}

-						pStk->SetError( TX_DOT, p->GivStart() );

-						goto err;

-					}

-				}

-				break;

-			}

-

-

-			if ( pStk->IsOk() ) return (CBotLeftExpr*) pStack->Return(inst, pStk);

-		}

-		pStk->SetError(TX_UNDEFVAR, p);

-err:

-		delete inst;

-		return (CBotLeftExpr*) pStack->Return(NULL, pStk);

-	}

-

-	return (CBotLeftExpr*) pStack->Return(NULL, pStk);

-}

-

-// exécute, trouve une variable et lui assigne le résultat de la pile

-

-BOOL CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array)

-{

-	CBotStack*	pile = pj->AddStack();

-//	if ( pile == EOX ) return TRUE;

-

-//	if ( pile->IfStep() ) return FALSE;

-

-	CBotVar*	 var1 = NULL;

-	CBotVar*	 var2 = NULL;

-

-//	var1 = pile->FindVar(m_token, FALSE, TRUE);

-	if (!ExecuteVar( var1, array, NULL, FALSE )) return FALSE;

-															// retrouve la variable (et pas la copie)

-	if (pile->IfStep()) return FALSE;

-

-	if ( var1 )

-	{

-		var2 = pj->GivVar();								// resultat sur la pile d'entrée

-		if ( var2 )

-		{

-			CBotTypResult t1 = var1->GivTypResult();

-			CBotTypResult t2 = var2->GivTypResult();

-			if ( t2.Eq(CBotTypPointer) )

-			{

-				CBotClass*	c1 = t1.GivClass();

-				CBotClass*	c2 = t2.GivClass();

-				if ( !c2->IsChildOf(c1))

-				{

-					CBotToken* pt = &m_token;

-					pile->SetError(TX_BADTYPE, pt);

-					return pj->Return(pile);								// opération faite

-				}

-			}

-			var1->SetVal(var2);						// fait l'assignation

-		}

-		pile->SetCopyVar( var1 );							// remplace sur la pile par une copie de la variable elle-même

-															// (pour avoir le nom)

-	}

-

-	return pj->Return(pile);								// opération faite

-}

-

-// retrouve une variable pendant la compilation

-

-BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)

-{

-	pVar = pile->FindVar(m_token);

-	if ( pVar == NULL ) return FALSE;

-

-	if ( m_next3 != NULL &&

-		 !m_next3->ExecuteVar(pVar, pile) ) return FALSE;

-

-	return TRUE;

-}

-

-// retrouve une variable à l'exécution

-

-BOOL CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep)

-{

-	pile = pile->AddStack( this );			// déplace la pile

-

-	pVar = pile->FindVar(m_nIdent);

-	if ( pVar == NULL )

-	{

-#ifdef	_DEBUG

-		ASM_TRAP();

-#endif

-		pile->SetError(2, &m_token);

-		return FALSE;

-	}

-

-	if ( bStep && m_next3 == NULL && pile->IfStep() ) return FALSE;

-

-	if ( m_next3 != NULL && 

-		 !m_next3->ExecuteVar(pVar, pile, &m_token, bStep, TRUE) ) return FALSE;

-

-	return TRUE;

-}

-

-void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, BOOL bMain)

-{

-	pile = pile->RestoreStack( this );			// déplace la pile

-	if ( pile == NULL ) return;

-

-	if ( m_next3 != NULL ) 

-		 m_next3->RestoreStateVar(pile, bMain);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-// transforme une chaîne en nombre entier

-// peut être de la forme 0xabc123

-

-long GivNumInt( const char* p )

-{

-	long	num = 0;

-	while (*p >= '0' && *p <= '9')

-	{

-		num = num * 10 + *p - '0';

-		p++;

-	}

-	if ( *p == 'x' || *p == 'X' )

-	{

-		while (*++p != 0)

-		{

-			if ( *p >= '0' && *p <= '9' )

-			{

-				num = num * 16 + *p - '0';

-				continue;

-			}

-			if ( *p >= 'A' && *p <= 'F' )

-			{

-				num = num * 16 + *p - 'A' + 10;

-				continue;

-			}

-			if ( *p >= 'a' && *p <= 'f' )

-			{

-				num = num * 16 + *p - 'a' + 10;

-				continue;

-			}

-			break;

-		}

-	}

-	return num;

-}

-

-// transforme une chaîne en un nombre réel

-

-extern float GivNumFloat( const char* p )

-{

-	double	num = 0;

-	double	div	= 10;

-	BOOL	bNeg = FALSE;

-

-	if (*p == '-')

-	{

-		bNeg = TRUE;

-		p++;

-	}

-	while (*p >= '0' && *p <= '9')

-	{

-		num = num * 10. + (*p - '0');

-		p++;

-	}

-

-	if ( *p == '.' )

-	{

-		p++;

-		while (*p >= '0' && *p <= '9')

-		{

-			num = num + (*p - '0') / div;

-			div = div * 10;

-			p++;

-		}

-	}

-

-	int	exp = 0;

-	if ( *p == 'e' || *p == 'E' )

-	{

-		char neg = 0;

-		p++;

-		if ( *p == '-' || *p == '+' ) neg = *p++;

-

-		while (*p >= '0' && *p <= '9')

-		{

-			exp = exp * 10 + (*p - '0');

-			p++;

-		}

-		if ( neg == '-' ) exp = -exp;

-	}

-

-	while ( exp > 0 )

-	{

-		num *= 10.0;

-		exp--;

-	}

-

-	while ( exp < 0 )

-	{

-		num /= 10.0;

-		exp++;

-	}

-

-	if ( bNeg ) num = -num;

-	return (float)num;

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un token représentant un nombre

-

-CBotExprNum::CBotExprNum()

-{

-	name	= "CBotExprNum";

-}

-

-CBotExprNum::~CBotExprNum()

-{

-}

-

-CBotInstr* CBotExprNum::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->TokenStack();

-

-	CBotExprNum* inst = new CBotExprNum();

-

-	inst->SetToken(p);

-	CBotString	s = p->GivString();

-

-	inst->m_numtype = CBotTypInt;

-	if ( p->GivType() == TokenTypDef )

-	{

-		inst->m_valint = p->GivIdKey();

-	}

-	else

-	{

-		if ( s.Find('.') >= 0 || ( s.Find('x') < 0 && ( s.Find('e') >= 0 || s.Find('E') >= 0 ) ) )

-		{

-			inst->m_numtype = CBotTypFloat;

-			inst->m_valfloat = GivNumFloat(s);

-		}

-		else

-		{

-			inst->m_valint = GivNumInt(s);

-		}

-	}

-

-	if (pStk->NextToken(p))

-	{

-		CBotVar*	var = CBotVar::Create((CBotToken*)NULL, inst->m_numtype);

-		pStk->SetVar(var);

-

-		return pStack->Return(inst, pStk);

-	}

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute, retourne le nombre correspondant

-

-BOOL CBotExprNum::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, m_numtype);

-

-	CBotString	nombre ;

-	if ( m_token.GivType() == TokenTypDef )

-	{

-		nombre = m_token.GivString();

-	}

-

-	switch (m_numtype)

-	{

-	case CBotTypShort:

-	case CBotTypInt:

-		var->SetValInt( m_valint, nombre );			// valeur du nombre

-		break;

-	case CBotTypFloat:

-		var->SetValFloat( m_valfloat );				// valeur du nombre

-		break;

-	}

-	pile->SetVar( var );							// mis sur la pile

-

-	return pj->Return(pile);						// c'est ok

-}

-

-void CBotExprNum::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un token représentant une chaine de caractères

-

-CBotExprAlpha::CBotExprAlpha()

-{

-	name	= "CBotExprAlpha";

-}

-

-CBotExprAlpha::~CBotExprAlpha()

-{

-}

-

-CBotInstr* CBotExprAlpha::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->TokenStack();

-

-	CBotExprAlpha* inst = new CBotExprAlpha();

-

-	inst->SetToken(p);

-	p = p->GivNext();

-

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypString);

-	pStk->SetVar(var);

-

-	return pStack->Return(inst, pStk);

-}

-

-// exécute, retourne la chaîne correspondante

-

-BOOL CBotExprAlpha::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypString);

-

-	CBotString	chaine = m_token.GivString();

-	chaine = chaine.Mid(1, chaine.GivLength()-2);	// enlève les guillemets

-

-	var->SetValString( chaine );					// valeur du nombre

-

-	pile->SetVar( var );							// mis sur la pile

-

-	return pj->Return(pile);

-}

-

-void CBotExprAlpha::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un token représentant true ou false

-

-CBotExprBool::CBotExprBool()

-{

-	name = "CBotExprBool";

-}

-

-CBotExprBool::~CBotExprBool()

-{

-}

-

-CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->TokenStack();

-	CBotExprBool* inst = NULL;

-

-	if ( p->GivType() == ID_TRUE ||

-		 p->GivType() == ID_FALSE )

-	{

-		inst = new CBotExprBool();

-		inst->SetToken(p);							// mémorise l'opération false ou true

-		p = p->GivNext();

-

-		CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);

-		pStk->SetVar(var);

-	}

-

-	return pStack->Return(inst, pStk);

-}

-

-// exécute, retourne true ou false

-

-BOOL CBotExprBool::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);

-

-	if (GivTokenType() == ID_TRUE)	  var->SetValInt(1);

-	else							  var->SetValInt(0);

-

-	pile->SetVar( var );										// mis sur la pile

-	return pj->Return(pile);									// transmet en dessous

-}

-

-void CBotExprBool::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-// gestion de l'opérande "null"

-

-CBotExprNull::CBotExprNull()

-{

-	name = "CBotExprNull";

-}

-

-CBotExprNull::~CBotExprNull()

-{

-}

-

-// exécute, retourne un pointeur vide

-

-BOOL CBotExprNull::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypNullPointer);

-

-	var->SetInit(TRUE);								// pointeur null valide

-	pile->SetVar( var );							// mis sur la pile

-	return pj->Return(pile);						// transmet en dessous

-}

-

-void CBotExprNull::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-// gestion de l'opérande "nan"

-

-CBotExprNan::CBotExprNan()

-{

-	name = "CBotExprNan";

-}

-

-CBotExprNan::~CBotExprNan()

-{

-}

-

-// exécute, retourne un pointeur vide

-

-BOOL CBotExprNan::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-	CBotVar*	var = CBotVar::Create((CBotToken*)NULL, CBotTypInt);

-

-	var->SetInit(IS_NAN);							// nombre nan

-	pile->SetVar( var );							// mis sur la pile

-	return pj->Return(pile);						// transmet en dessous

-}

-

-void CBotExprNan::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un nom de variable

-// vérifie qu'elle est connue sur la pile

-// et qu'elle a été initialisée

-

-CBotExprVar::CBotExprVar()

-{

-	name	= "CBotExprVar";

-	m_nIdent = 0;

-}

-

-CBotExprVar::~CBotExprVar()

-{

-}

-

-CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat)

-{

-	CBotToken*	pDebut = p;

-	CBotCStack* pStk = pStack->TokenStack();

-

-	pStk->SetStartError(p->GivStart());

-

-	// est-ce un nom de variable ?

-	if (p->GivType() == TokenTypVar)

-	{

-		CBotInstr* inst = new CBotExprVar();					// crée l'objet

-

-		inst->SetToken(p);

-

-		CBotVar*	 var;

-		

-		if ( NULL != (var = pStk->FindVar(p)) )					// cherche si variable connue

-		{

-			int		ident = var->GivUniqNum();

-			((CBotExprVar*)inst)->m_nIdent = ident;				// l'identifie par son numéro

-

-			if (ident > 0 && ident < 9000)

-			{

-				if ( var->IsPrivate(privat) &&

-					 !pStk->GivBotCall()->m_bCompileClass)

-				{

-					pStk->SetError( TX_PRIVATE, p );

-					goto err;

-				}

-

-				// il s'agit d'un élement de la classe courante

-				// ajoute l'équivalent d'un this. devant

-				inst->SetToken(&CBotToken("this"));

-				((CBotExprVar*)inst)->m_nIdent = -2;			// ident pour this

-

-				CBotFieldExpr* i = new CBotFieldExpr();			// nouvel élément

-				i->SetToken( p );								// garde le nom du token

-				i->SetUniqNum(ident);

-				inst->AddNext3(i);								// ajoute à la suite

-			}

-

-			p = p->GivNext();										// token suivant

-

-			while (TRUE)

-			{

-				if ( var->GivType() == CBotTypArrayPointer )			// s'il sagit d'un tableau 

-				{

-					if ( IsOfType( p, ID_OPBRK ) )						// regarde s'il y a un index

-					{

-						CBotIndexExpr* i = new CBotIndexExpr();

-						i->m_expr = CBotExpression::Compile(p, pStk);		// compile la formule

-						inst->AddNext3(i);									// ajoute à la chaine

-

-						var = ((CBotVarArray*)var)->GivItem(0,TRUE);		// donne le composant [0]

-

-						if ( i->m_expr == NULL )

-						{

-							pStk->SetError( TX_BADINDEX, p->GivStart() );

-							goto err;

-						}

-						if ( !pStk->IsOk() || !IsOfType( p, ID_CLBRK ) )

-						{

-							pStk->SetError( TX_CLBRK, p->GivStart() );

-							goto err;

-						}

-						continue;

-					}

-	////			pStk->SetError( TX_OPBRK, p->GivStart() );

-				}

-				if ( var->GivType(1) == CBotTypPointer )				// pour les classes

-				{

-					if ( IsOfType(p, ID_DOT) )

-					{

-						CBotToken* pp = p;

-

-						if ( p->GivType() == TokenTypVar )				// doit être un nom

-						{

-							if ( p->GivNext()->GivType() == ID_OPENPAR )// un appel de méthode ?

-							{

-								CBotInstr* i = CBotInstrMethode::Compile(p, pStk, var);

-								if ( !pStk->IsOk() ) goto err;

-								inst->AddNext3(i);								// ajoute à la suite

-								return pStack->Return(inst, pStk);

-							}

-							else

-							{

-								CBotFieldExpr* i = new CBotFieldExpr();			// nouvel élément

-								i->SetToken( pp );								// garde le nom du token

-								inst->AddNext3(i);								// ajoute à la suite

-								var = var->GivItem(p->GivString());			// récupère l'item correpondant

-								if ( var != NULL )

-								{

-									i->SetUniqNum(var->GivUniqNum());

-									if ( var->IsPrivate() &&

-									 !pStk->GivBotCall()->m_bCompileClass)

-									{

-										pStk->SetError( TX_PRIVATE, pp );

-										goto err;

-									}

-								}

-							}

-

-

-							if ( var != NULL )

-							{

-								p = p->GivNext();						// saute le nom

-								continue;

-							}

-							pStk->SetError( TX_NOITEM, p );

-							goto err;

-						}

-						pStk->SetError( TX_DOT, p->GivStart() );

-						goto err;

-					}

-				}

-

-				break;

-			}

-

-			pStk->SetCopyVar(var);									// place une copie de la variable sur la pile (pour le type)

-			if ( pStk->IsOk() ) return pStack->Return(inst, pStk);

-		}

-		pStk->SetError(TX_UNDEFVAR, p);

-err:

-		delete inst;

-		return pStack->Return(NULL, pStk);

-	}

-

-	return pStack->Return(NULL, pStk);

-}

-

-CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;

-	CBotCStack* pStk = pStack->TokenStack();

-

-	pStk->SetStartError(pp->GivStart());

-

-	// est-ce un nom de variable ?

-	if (pp->GivType() == TokenTypVar)

-	{

-		CBotToken pthis("this");

-		CBotVar*	 var = pStk->FindVar(pthis);

-		if ( var == 0 ) return pStack->Return(NULL, pStk);

-

-		CBotInstr* inst = new CBotExprVar();					// crée l'objet

-		

-		// il s'agit d'un élement de la classe courante

-		// ajoute l'équivalent d'un this. devant

-		inst->SetToken(&pthis);

-		((CBotExprVar*)inst)->m_nIdent = -2;					// ident pour this

-

-		CBotToken* pp = p;

-

-		if ( pp->GivType() == TokenTypVar )						// doit être un nom

-		{

-			if ( pp->GivNext()->GivType() == ID_OPENPAR )		// un appel de méthode ?

-			{

-				CBotInstr* i = CBotInstrMethode::Compile(pp, pStk, var);

-				if ( pStk->IsOk() )

-				{

-					inst->AddNext3(i);							// ajoute à la suite

-					p = pp;										// instructions passées

-					return pStack->Return(inst, pStk);

-				}

-				pStk->SetError(0,0);							// l'erreur n'est pas traitée ici

-			}

-		}

-		delete inst;

-	}

-	return pStack->Return(NULL, pStk);

-}

-

-

-// exécute, rend la valeur d'une variable

-

-BOOL CBotExprVar::Execute(CBotStack* &pj)

-{

-	CBotVar*	 pVar = NULL;

-	CBotStack*	 pile  = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-//	if ( pile->IfStep() ) return FALSE;

-

-	CBotStack*	 pile1 = pile;

-

-	if ( pile1->GivState() == 0 )

-	{

-		if ( !ExecuteVar(pVar, pile, NULL, TRUE) ) return FALSE;		// récupère la variable selon champs et index

-//		DEBUG("CBotExprVar::Execute", 1 , pj);

-

-		if ( pVar ) pile1->SetCopyVar(pVar);							// la place une copie sur la pile

-		else

-		{

-//--		pile1->SetVar(NULL);								// la pile contient déjà le resultat (méthode)

-			return pj->Return(pile1);

-		}

-		pile1->IncState();

-	}

-

-	pVar = pile1->GivVar();										// récupère si interrompu

-

-	if ( pVar == NULL )

-	{

-//		pile1->SetError(TX_NULLPT, &m_token);

-		return pj->Return(pile1);

-	}

-

-	if ( pVar->GivInit() == IS_UNDEF )

-	{

-		CBotToken* pt = &m_token;

-		while ( pt->GivNext() != NULL ) pt = pt->GivNext();

-		pile1->SetError(TX_NOTINIT, pt);

-		return pj->Return(pile1);

-	}

-	return pj->Return(pile1);									// opération faite

-}

-

-void CBotExprVar::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	 pile  = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	CBotStack*	 pile1 = pile;

-

-	if ( pile1->GivState() == 0 )

-	{

-		RestoreStateVar(pile, bMain);	// récupère la variable selon champs et index

-		return;

-	}

-}

-

-// retrouve une variable à l'exécution

-

-BOOL CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep)

-{

-	CBotStack*	pile = pj;

-	pj = pj->AddStack( this );

-

-	if ( bStep && m_nIdent>0 && pj->IfStep() ) return FALSE;

-

-	pVar = pj->FindVar(m_nIdent, TRUE);						// cherche la variable avec mise à jour si nécessaire

-	if ( pVar == NULL )

-	{

-#ifdef	_DEBUG

-		ASM_TRAP();

-#endif

-		pj->SetError(1, &m_token);

-		return FALSE;

-	}

-	if ( m_next3 != NULL &&

-		 !m_next3->ExecuteVar(pVar, pj, &m_token, bStep, FALSE) )

-			return FALSE;										// Champs d'une instance, tableau, méthode ?

-

-	return pile->ReturnKeep( pj );								// ne rend pas la pile mais récupère le résultat si une méthode a été appelée

-}

-

-

-// retrouve une variable à l'exécution

-

-void CBotExprVar::RestoreStateVar(CBotStack* &pj, BOOL bMain)

-{

-	pj = pj->RestoreStack( this );

-	if ( pj == NULL ) return;

-

-	if ( m_next3 != NULL )

-		 m_next3->RestoreStateVar(pj, bMain);

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-// compile une liste de paramètres

-

-CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)

-{

-	BOOL		first = TRUE;

-	CBotInstr*	ret = NULL;							// pour la liste à retourner

-

-//	pStack->SetStartError(p->GivStart());

-	CBotCStack*	pile = pStack;

-	int			i = 0;

-

-	if ( IsOfType(p, ID_OPENPAR) )

-	{

-		int	start, end;

-		if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)

-		{

-			start = p->GivStart();

-			pile = pile->TokenStack();						// garde les résultats sur la pile

-

-			if ( first ) pStack->SetStartError(start);

-			first = FALSE;

-

-			CBotInstr*	param = CBotExpression::Compile(p, pile);

-			end	  = p->GivStart();

-

-			if ( !pile->IsOk() )

-			{

-				return pStack->Return(NULL, pile);

-			}

-

-			if ( ret == NULL ) ret = param;

-			else ret->AddNext(param);						// construit la liste

-

-			if ( param != NULL )

-			{

-				if ( pile->GivTypResult().Eq(99) )

-				{

-					delete pStack->TokenStack();

-					pStack->SetError(TX_VOID, p->GivStart());

-					return NULL;

-				}

-				ppVars[i] = pile->GivVar();

-				ppVars[i]->GivToken()->SetPos(start, end);

-				i++;

-

-				if (IsOfType(p, ID_COMMA)) continue;		// saute la virgule

-				if (IsOfType(p, ID_CLOSEPAR)) break;

-			}

-

-			pStack->SetError(TX_CLOSEPAR, p->GivStart());

-			delete pStack->TokenStack();

-			return NULL;

-		}

-	}

-	ppVars[i] = NULL;

-	return	ret;

-}

-

-//////////////////////////////////////////////////////////////////////////////////////////

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile un appel d'une méthode

-

-CBotInstrMethode::CBotInstrMethode()

-{

-	m_Parameters	= NULL;

-	m_MethodeIdent  = 0;

-//	m_nThisIdent	= 0;

-	name = "CBotInstrMethode";

-}

-

-CBotInstrMethode::~CBotInstrMethode()

-{

-	delete	m_Parameters;

-}

-

-CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* var)

-{

-	CBotInstrMethode* inst = new CBotInstrMethode();

-	inst->SetToken(p);									// token correspondant

-

-//	inst->m_nThisIdent = CBotVar::NextUniqNum();

-

-	if ( NULL != var )

-	{

-		CBotToken*	pp = p;

-		p = p->GivNext();

-

-		if ( p->GivType() == ID_OPENPAR )

-		{

-			inst->m_NomMethod = pp->GivString();

-

-			// compile la liste des paramètres

-			CBotVar*	ppVars[1000];

-			inst->m_Parameters = CompileParams(p, pStack, ppVars);

-

-			if ( pStack->IsOk() )

-			{

-				CBotClass* pClass = var->GivClass();	// pointeur à la classe

-				inst->m_ClassName = pClass->GivName();	// le nom de la classe

-				CBotTypResult r = pClass->CompileMethode(inst->m_NomMethod, var, ppVars, 

-														 pStack, inst->m_MethodeIdent);

-				delete pStack->TokenStack();			// libères les paramètres encore sur la pile

-				inst->m_typRes = r;

-

-				if (inst->m_typRes.GivType() > 20)

-				{

-					pStack->SetError(inst->m_typRes.GivType(), pp);

-					delete	inst;

-					return	NULL;

-				}

-				// met un résultat sur la pile pour avoir quelque chose

-				if (inst->m_typRes.GivType() > 0)

-				{

-					CBotVar*	pResult = CBotVar::Create("", inst->m_typRes);

-					if (inst->m_typRes.Eq(CBotTypClass))

-					{

-//						CBotClass*	pClass = CBotClass::Find(inst->m_RetClassName);

-						pResult->SetClass(inst->m_typRes.GivClass());

-					}

-					pStack->SetVar(pResult);

-				}

-				return inst;

-			}

-			delete inst;

-			return NULL;

-		}

-	}

-	pStack->SetError( 1234, p );

-	delete inst;

-	return NULL;

-}

-

-// exécute l'appel de méthode

-

-BOOL CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep, BOOL bExtend)

-{

-	CBotVar*	ppVars[1000];

-	CBotStack*	pile1 = pj->AddStack(this, TRUE);		// une place pour la copie de This

-//	if ( pile1 == EOX ) return TRUE;

-

-//	DEBUG( "CBotInstrMethode::ExecuteVar", 0, pj );

-

-	if ( pVar->GivPointer() == NULL )

-	{

-		pj->SetError( TX_NULLPT, prevToken );

-	}

-

-	if ( pile1->IfStep() ) return FALSE;

-

-	CBotStack*	pile2 = pile1->AddStack();				// et pour les paramètres à venir

-

-	if ( pile1->GivState() == 0)

-	{

-		CBotVar*	pThis = CBotVar::Create(pVar);

-		pThis->Copy(pVar);

-		// la valeur de This doit être prise avant l'évaluation des paramètres

-		// Test.Action( Test = Autre );

-		// Action doit agir sur la valeur avant Test = Autre !!

-		pThis->SetName("this");

-//		pThis->SetUniqNum(m_nThisIdent);

-		pThis->SetUniqNum(-2);

-		pile1->AddVar(pThis);

-		pile1->IncState();

-	}

-	int		i = 0;

-

-	CBotInstr*	p = m_Parameters;

-	// évalue les paramètres

-	// et place les valeurs sur la pile

-	// pour pouvoir être interrompu n'importe quand

-	if ( p != NULL) while ( TRUE )

-	{

-		if ( pile2->GivState() == 0 )

-		{

-			if (!p->Execute(pile2)) return FALSE;		// interrompu ici ?

-			if (!pile2->SetState(1)) return FALSE;		// marque spéciale pour reconnaîre les paramètres

-		}

-		ppVars[i++] = pile2->GivVar();					// construit la liste des pointeurs

-		pile2 = pile2->AddStack();						// de la place sur la pile pour les résultats

-		p = p->GivNext();

-		if ( p == NULL) break;

-	}

-	ppVars[i] = NULL;

-

-	CBotClass*	pClass = CBotClass::Find(m_ClassName);

-	CBotVar*	pThis  = pile1->FindVar(-2);

-	CBotVar*	pResult = NULL;

-	if (m_typRes.GivType() > 0) pResult = CBotVar::Create("", m_typRes);

-	if (m_typRes.Eq(CBotTypClass))

-	{

-//		CBotClass*	pClass = CBotClass::Find(m_RetClassName);

-		pResult->SetClass(m_typRes.GivClass());

-	}

-	CBotVar*	pRes = pResult;

-

-	if ( !pClass->ExecuteMethode(m_MethodeIdent, m_NomMethod, 

-								 pThis, ppVars, 

-								 pResult, pile2, GivToken())) return FALSE;	// interrompu

-	if (pRes != pResult) delete pRes;

-

-	pVar = NULL;				// ne retourne pas une valeur par cela

-	return pj->Return(pile2);	// libère toute la pile

-}

-

-void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotVar*	ppVars[1000];

-	CBotStack*	pile1 = pile->RestoreStack(this);		// une place pour la copie de This

-	if ( pile1 == NULL ) return;

-

-	CBotStack*	pile2 = pile1->RestoreStack();			// et pour les paramètres à venir

-	if ( pile2 == NULL ) return;

-

-	CBotVar*	pThis  = pile1->FindVar("this");

-//	pThis->SetUniqNum(m_nThisIdent);

-	pThis->SetUniqNum(-2);

-

-	int		i = 0;

-

-	CBotInstr*	p = m_Parameters;

-	// évalue les paramètres

-	// et place les valeurs sur la pile

-	// pour pouvoir être interrompu n'importe quand

-	if ( p != NULL) while ( TRUE )

-	{

-		if ( pile2->GivState() == 0 )

-		{

-			p->RestoreState(pile2, TRUE);				// interrompu ici !

-			return;

-		}

-		ppVars[i++] = pile2->GivVar();					// construit la liste des pointeurs

-		pile2 = pile2->RestoreStack();

-		if ( pile2 == NULL ) return;

-

-		p = p->GivNext();

-		if ( p == NULL) break;

-	}

-	ppVars[i] = NULL;

-

-	CBotClass*	pClass = CBotClass::Find(m_ClassName);

-	CBotVar*	pResult = NULL;

-

-	CBotVar*	pRes = pResult;

-

-	pClass->RestoreMethode(m_MethodeIdent, m_NomMethod, 

-								 pThis, ppVars, pile2);

-}

-

-

-BOOL CBotInstrMethode::Execute(CBotStack* &pj)

-{

-	CBotVar*	ppVars[1000];

-	CBotStack*	pile1 = pj->AddStack(this, TRUE);		// une place pour la copie de This

-//	if ( pile1 == EOX ) return TRUE;

-

-	if ( pile1->IfStep() ) return FALSE;

-

-	CBotStack*	pile2 = pile1->AddStack();				// et pour les paramètres à venir

-

-	if ( pile1->GivState() == 0)

-	{

-		CBotVar*	pThis = pile1->CopyVar(m_token);

-		// la valeur de This doit être prise avant l'évaluation des paramètres

-		// Test.Action( Test = Autre );

-		// Action doit agir sur la valeur avant Test = Autre !!

-		pThis->SetName("this");

-		pile1->AddVar(pThis);

-		pile1->IncState();

-	}

-	int		i = 0;

-

-	CBotInstr*	p = m_Parameters;

-	// évalue les paramètres

-	// et place les valeurs sur la pile

-	// pour pouvoir être interrompu n'importe quand

-	if ( p != NULL) while ( TRUE )

-	{

-		if ( pile2->GivState() == 0 )

-		{

-			if (!p->Execute(pile2)) return FALSE;		// interrompu ici ?

-			if (!pile2->SetState(1)) return FALSE;		// marque spéciale pour reconnaîre les paramètres

-		}

-		ppVars[i++] = pile2->GivVar();					// construit la liste des pointeurs

-		pile2 = pile2->AddStack();						// de la place sur la pile pour les résultats

-		p = p->GivNext();

-		if ( p == NULL) break;

-	}

-	ppVars[i] = NULL;

-

-	CBotClass*	pClass = CBotClass::Find(m_ClassName);

-	CBotVar*	pThis  = pile1->FindVar("this");

-	CBotVar*	pResult = NULL;

-	if (m_typRes.GivType()>0) pResult = CBotVar::Create("", m_typRes);

-	if (m_typRes.Eq(CBotTypClass))

-	{

-//		CBotClass*	pClass = CBotClass::Find(m_RetClassName);

-		pResult->SetClass(m_typRes.GivClass());

-	}

-	CBotVar*	pRes = pResult;

-

-	if ( !pClass->ExecuteMethode(m_MethodeIdent, m_NomMethod, 

-								 pThis, ppVars, 

-								 pResult, pile2, GivToken())) return FALSE;	// interrompu

-

-	// met la nouvelle valeur de this à la place de l'ancienne variable

-	CBotVar*	old = pile1->FindVar(m_token);

-	old->Copy(pThis, FALSE);

-

-	if (pRes != pResult) delete pRes;

-

-	return pj->Return(pile2);	// libère toute la pile

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "new" 

-

-CBotNew::CBotNew()

-{

-	name			= "CBotNew";

-	m_Parameters	= NULL;

-	m_nMethodeIdent = 0;

-//	m_nThisIdent	= 0;

-}

-

-CBotNew::~CBotNew()

-{

-}

-

-CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken* pp = p;

-	if ( !IsOfType(p, ID_NEW) ) return NULL;

-

-	// vérifie que le token est un nom de classe

-	if (p->GivType() != TokenTypVar) return NULL;

-

-	CBotClass* pClass = CBotClass::Find(p);

-	if (pClass == NULL)

-	{

-		pStack->SetError(TX_BADNEW, p);

-		return NULL;

-	}

-/*	if ( !pClass->m_IsDef )

-	{

-		pStack->SetError(TX_BADNEW, p);

-		return NULL;

-	}*/

-

-	CBotNew* inst = new CBotNew();

-	inst->SetToken(pp);

-

-	inst->m_vartoken = p;

-	p = p->GivNext();

-

-	// crée l'objet sur le "tas"

-	// avec un pointeur sur cet objet

-	CBotVar*	pVar = CBotVar::Create("", pClass);

-//	inst->m_nThisIdent = CBotVar::NextUniqNum();

-

-	// fait l'appel du créateur

-	CBotCStack* pStk = pStack->TokenStack();

-	{

-		// regarde s'il y a des paramètres

-		CBotVar*	ppVars[1000];

-		inst->m_Parameters = CompileParams(p, pStk, ppVars);

-		if ( !pStk->IsOk() ) goto error;

-

-		// le constructeur existe-il ?

-//		CBotString	noname;

-		CBotTypResult r = pClass->CompileMethode(pClass->GivName(), pVar, ppVars, pStk, inst->m_nMethodeIdent);

-		delete pStk->TokenStack();							// libère le supplément de pile

-		int typ = r.GivType();

-

-		// s'il n'y a pas de constructeur, et pas de paramètres non plus, c'est ok

-		if ( typ == TX_UNDEFCALL && inst->m_Parameters == NULL ) typ = 0;

-		pVar->SetInit(TRUE);								// marque l'instance comme init

-

-		if (typ>20)

-		{

-			pStk->SetError(typ, inst->m_vartoken.GivEnd());

-			goto error;

-		}

-

-		// si le constructeur n'existe pas, mais qu'il y a des paramètres

-		if (typ<0 && inst->m_Parameters != NULL)

-		{

-			pStk->SetError(TX_NOCONST, &inst->m_vartoken);

-			goto error;

-		}

-

-		// rend le pointeur à l'objet sur la pile

-		pStk->SetVar(pVar);

-		return pStack->Return(inst, pStk);

-	}

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// exécute une instruction "new"

-

-BOOL CBotNew::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);				//pile principale

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	CBotStack*	pile1 = pj->AddStack2();				//pile secondaire

-

-	CBotVar*	pThis = NULL;

-

-	CBotToken*	pt = &m_vartoken;

-	CBotClass*	pClass = CBotClass::Find(pt);

-

-	// crée la variable "this" de type pointeur à l'objet

-

-	if ( pile->GivState()==0)

-	{

-		// crée une instance de la classe demandée

-		// et initialise le pointeur à cet objet

-

-		pThis = CBotVar::Create("this", pClass);

-//		pThis->SetUniqNum( m_nThisIdent ) ;

-		pThis->SetUniqNum( -2 ) ;

-

-		pile1->SetVar(pThis);								// la place sur la pile1

-		pile->IncState();

-	}

-

-	// retrouve le pointeur this si on a été interrompu

-	if ( pThis == NULL)

-	{

-		pThis = pile1->GivVar();								// retrouve le pointeur

-	}

-

-	// y a-t-il une assignation ou des paramètres (constructeur)

-	if ( pile->GivState()==1)

-	{	

-		// évalue le constructeur de l'instance

-

-		CBotVar*	ppVars[1000];

-		CBotStack*	pile2 = pile;

-

-		int		i = 0;

-

-		CBotInstr*	p = m_Parameters;

-		// évalue les paramètres

-		// et place les valeurs sur la pile

-		// pour pouvoir être interrompu n'importe quand

-

-		if ( p != NULL) while ( TRUE )

-		{

-			pile2 = pile2->AddStack();						// de la place sur la pile pour les résultats

-			if ( pile2->GivState() == 0 )

-			{

-				if (!p->Execute(pile2)) return FALSE;		// interrompu ici ?

-				pile2->SetState(1);

-			}

-			ppVars[i++] = pile2->GivVar();

-			p = p->GivNext();

-			if ( p == NULL) break;

-		}

-		ppVars[i] = NULL;

-

-		// crée une variable pour le résultat

-		CBotVar*	pResult = NULL;						// constructeurs toujours void

-

-		if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(), 

-									 pThis, ppVars, 

-									 pResult, pile2, GivToken())) return FALSE;	// interrompu

-

-		pThis->ConstructorSet();		// signale que le constructeur a été appelé

-//		pile->Return(pile2);							// libère un bout de pile

-

-//		pile->IncState();

-	}

-

-	return pj->Return( pile1 );							// transmet en dessous

-}

-

-void CBotNew::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile = pj->RestoreStack(this);			//pile principale

-	if ( pile == NULL ) return;

-

-	CBotStack*	pile1 = pj->AddStack2();				//pile secondaire

-

-	CBotToken*	pt = &m_vartoken;

-	CBotClass*	pClass = CBotClass::Find(pt);

-

-	// crée la variable "this" de type pointeur à l'objet

-

-	if ( pile->GivState()==0)

-	{

-		return;

-	}

-

-	CBotVar* pThis = pile1->GivVar();					// retrouve le pointeur

-//	pThis->SetUniqNum( m_nThisIdent );

-	pThis->SetUniqNum( -2 );

-

-	// y a-t-il une assignation ou des paramètres (constructeur)

-	if ( pile->GivState()==1)

-	{	

-		// évalue le constructeur de l'instance

-

-		CBotVar*	ppVars[1000];

-		CBotStack*	pile2 = pile;

-

-		int		i = 0;

-

-		CBotInstr*	p = m_Parameters;

-		// évalue les paramètres

-		// et place les valeurs sur la pile

-		// pour pouvoir être interrompu n'importe quand

-

-		if ( p != NULL) while ( TRUE )

-		{

-			pile2 = pile2->RestoreStack();				// de la place sur la pile pour les résultats

-			if ( pile2 == NULL ) return;

-

-			if ( pile2->GivState() == 0 )

-			{

-				p->RestoreState(pile2, bMain);			// interrompu ici !

-				return;

-			}

-			ppVars[i++] = pile2->GivVar();

-			p = p->GivNext();

-			if ( p == NULL) break;

-		}

-		ppVars[i] = NULL;

-

-		pClass->RestoreMethode(m_nMethodeIdent, m_vartoken.GivString(), pThis,

-							   ppVars, pile2)	;		// interrompu ici !

-	}

-}

-

-/////////////////////////////////////////////////////////////

-// regarde si deux résultats sont compatibles pour faire une opération

-

-BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op )

-{

-	int	t1 = type1.GivType();

-	int	t2 = type2.GivType();

-

-	int max = (t1 > t2) ? t1 : t2;

-

-	if ( max == 99 ) return FALSE;					// un résultat est void ?

-

-	// cas particulier pour les concaténation de chaînes

-	if (op == ID_ADD && max >= CBotTypString) return TRUE;

-	if (op == ID_ASSADD && max >= CBotTypString) return TRUE;

-	if (op == ID_ASS && t1 == CBotTypString) return TRUE;

-

-	if ( max >= CBotTypBoolean )

-	{

-		if ( (op == ID_EQ || op == ID_NE) && 

-			 (t1 == CBotTypPointer && t2 == CBotTypNullPointer)) return TRUE;

-		if ( (op == ID_EQ || op == ID_NE || op == ID_ASS) && 

-			 (t2 == CBotTypPointer && t1 == CBotTypNullPointer)) return TRUE;

-		if ( (op == ID_EQ || op == ID_NE) && 

-			 (t1 == CBotTypArrayPointer && t2 == CBotTypNullPointer)) return TRUE;

-		if ( (op == ID_EQ || op == ID_NE || op == ID_ASS) && 

-			 (t2 == CBotTypArrayPointer && t1 == CBotTypNullPointer)) return TRUE;

-		if (t2 != t1) return FALSE;

-		if (t1 == CBotTypArrayPointer) return type1.Compare(type2);

-		if (t1 == CBotTypPointer ||

-			t1 == CBotTypClass   ||

-			t1 == CBotTypIntrinsic )

-		{

-			CBotClass*	c1 = type1.GivClass();

-			CBotClass*	c2 = type2.GivClass();

-

-			return c1->IsChildOf(c2) || c2->IsChildOf(c1);

-			// accepte le caste à l'envers,

-			// l'opération sera refusée à l'exécution si le pointeur n'est pas compatible

-		}

-

-		return TRUE;

-	}

-

-	type1.SetType(max);

-	type2.SetType(max);

-	return TRUE;

-}

-

-// regarde si deux variables sont compatible pour un passage de paramètre

-

-BOOL TypesCompatibles( const CBotTypResult& type1, const CBotTypResult& type2 )

-{

-	int	t1 = type1.GivType();

-	int	t2 = type2.GivType();

-

-	if ( t1 == CBotTypIntrinsic ) t1 = CBotTypClass;

-	if ( t2 == CBotTypIntrinsic ) t2 = CBotTypClass;

-

-	int max = (t1 > t2) ? t1 : t2;

-

-	if ( max == 99 ) return FALSE;					// un résultat est void ?

-

-	if ( max >= CBotTypBoolean )

-	{

-		if ( t2 != t1 ) return FALSE;

-

-		if ( max == CBotTypArrayPointer )

-			return TypesCompatibles(type1.GivTypElem(), type2.GivTypElem());

-

-		if ( max == CBotTypClass || max == CBotTypPointer )

-			return type1.GivClass() == type2.GivClass() ;

-

-		return TRUE ;

-	}

-	return TRUE;

-}

-

-

-/////////////////////////////////////////////////////////////////////////////////////

-// Gestion des fichiers

-

-// nécessaire car il n'est pas possible de faire le fopen dans le programme principal

-// et les fwrite ou fread dans une dll en utilisant le FILE* rendu.

-

-FILE* fOpen(const char* name, const char* mode)

-{

-	return fopen(name, mode);

-}

-

-int fClose(FILE* filehandle)

-{

-	return fclose(filehandle);

-}

-

-size_t fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle)

-{

-	return fwrite(buffer, elemsize, length, filehandle);

-}

-

-size_t fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle)

-{

-	return fread(buffer, elemsize, length, filehandle);

-}

-

-size_t fWrite(const void *buffer, size_t length, FILE* filehandle)

-{

-	return fwrite(buffer, 1, length, filehandle);

-}

-

-size_t fRead(void *buffer, size_t length, FILE* filehandle)

-{

-	return fread(buffer, 1, length, filehandle);

-}

-

-

-////////////////////////////////////////

-

-

-#if	FALSE

-

-CBotString num(int n)

-{

-	CBotString	s;

-	if ( n<0 ) {n = -n; s += "-";}

-	if ( n > 9 )

-	{

-		s += num(n/10);

-	}

-	s += '0' + n%10;

-	return s;

-}

-

-extern void DEBUG( const char* text, int val, CBotStack* pile )

-{

-	CBotProgram* p = pile->GivBotCall(TRUE);

-	if ( !p->m_bDebugDD ) return;

-

-	FILE* pf = fopen("CbotDebug.txt", "a");

-

-	fputs( text, pf );

-

-	CBotString v = " " + num(val) + "\n";

-	fputs( v, pf );

-

-	fclose( pf);

-}

-

-#endif

+// * 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  http://www.gnu.org/licenses/.
+///////////////////////////////////////////////////////////////////////
+
+// compilation of various instructions
+// compile all routines as static
+// and return an object according to what was found as instruction
+
+// compiler principle:
+// compile the routines return an object of the class corresponding to the operation found
+// this is always a subclass of CBotInstr.
+// (CBotInstr objects are never used directly)
+
+
+// compiles if the routine returns NULL is that the statement is false
+// or misunderstood.
+// the error is then on the stack CBotCStack :: Isok () is false
+
+
+
+#include "CBot.h"
+
+CBotInstr::CBotInstr()
+{
+    name     = "CBotInstr";
+    m_next   = NULL;
+    m_next2b = NULL;
+    m_next3  = NULL;
+    m_next3b = NULL;
+}
+
+CBotInstr::~CBotInstr()
+{
+    delete m_next;
+    delete m_next2b;
+    delete m_next3;
+    delete m_next3b;
+}
+
+// counter of nested loops,
+// to determine the break and continue valid
+// list of labels used
+
+
+int             CBotInstr::m_LoopLvl     = 0;
+CBotStringArray CBotInstr::m_labelLvl    = CBotStringArray();
+
+// adds a level with a label
+void CBotInstr::IncLvl(CBotString& label)
+{
+    m_labelLvl.SetSize(m_LoopLvl+1);
+    m_labelLvl[m_LoopLvl] = label;
+    m_LoopLvl++;
+}
+
+// adds a level (switch statement)
+void CBotInstr::IncLvl()
+{
+    m_labelLvl.SetSize(m_LoopLvl+1);
+    m_labelLvl[m_LoopLvl] = "#SWITCH";
+    m_LoopLvl++;
+}
+
+// free a level
+void CBotInstr::DecLvl()
+{
+    m_LoopLvl--;
+    m_labelLvl[m_LoopLvl].Empty();
+}
+
+// control validity of break and continue
+bool CBotInstr::ChkLvl(const CBotString& label, int type)
+{
+    int    i = m_LoopLvl;
+    while (--i>=0)
+    {
+        if ( type == ID_CONTINUE && m_labelLvl[i] == "#SWITCH") continue;
+        if (label.IsEmpty()) return true;
+        if (m_labelLvl[i] == label) return true;
+    }
+    return false;
+}
+
+bool CBotInstr::IsOfClass(CBotString n)
+{
+    return name == n;
+}
+
+
+////////////////////////////////////////////////////////////////////////////
+// database management class CBotInstr
+
+// set the token corresponding to the instruction
+
+void CBotInstr::SetToken(CBotToken* p)
+{
+    m_token = *p;
+}
+
+// return the type of the token assicated with the instruction
+
+int CBotInstr::GivTokenType()
+{
+    return m_token.GivType();
+}
+
+// return associated token
+
+CBotToken* CBotInstr::GivToken()
+{
+    return &m_token;
+}
+
+// adds the statement following  the other
+
+void CBotInstr::AddNext(CBotInstr* n)
+{
+    CBotInstr*    p = this;
+    while (p->m_next != NULL) p = p->m_next;
+    p->m_next = n;
+}
+
+void CBotInstr::AddNext3(CBotInstr* n)
+{
+    CBotInstr*    p = this;
+    while (p->m_next3 != NULL) p = p->m_next3;
+    p->m_next3 = n;
+}
+
+void CBotInstr::AddNext3b(CBotInstr* n)
+{
+    CBotInstr*    p = this;
+    while (p->m_next3b != NULL) p = p->m_next3b;
+    p->m_next3b = n;
+}
+
+// returns next statement
+
+CBotInstr* CBotInstr::GivNext()
+{
+    return m_next;
+}
+
+CBotInstr* CBotInstr::GivNext3()
+{
+    return m_next3;
+}
+
+CBotInstr* CBotInstr::GivNext3b()
+{
+    return m_next3b;
+}
+
+///////////////////////////////////////////////////////////////////////////
+// compile an instruction which can be
+// while, do, try, throw, if, for, switch, break, continue, return
+// int, float, boolean, string,
+// declaration of an instance of a class
+// arbitrary expression
+
+
+CBotInstr* CBotInstr::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*    pp = p;
+
+    if (p == NULL) return NULL;
+
+    int type = p->GivType();            // what is the next token
+
+    // is it a lable?
+    if (IsOfType(pp, TokenTypVar) &&
+         IsOfType(pp, ID_DOTS))
+    {
+         type = pp->GivType();
+         // these instructions accept only lable
+         if (!IsOfTypeList(pp, ID_WHILE, ID_FOR, ID_DO, ID_REPEAT, 0))
+         {
+             pStack->SetError(TX_LABEL, pp->GivStart());
+             return NULL;
+         }
+    }
+
+    // call routine corresponding to the compilation token found
+    switch (type)
+    {
+    case ID_WHILE:
+        return CBotWhile::Compile(p, pStack);
+
+    case ID_FOR:
+        return CBotFor::Compile(p, pStack);
+
+    case ID_DO:
+        return CBotDo::Compile(p, pStack);
+
+    case ID_REPEAT:
+        return CBotRepeat::Compile(p, pStack);
+
+    case ID_BREAK:
+    case ID_CONTINUE:
+        return CBotBreak::Compile(p, pStack);
+
+    case ID_SWITCH:
+        return CBotSwitch::Compile(p, pStack);
+
+    case ID_TRY:
+        return CBotTry::Compile(p, pStack);
+
+    case ID_THROW:
+        return CBotThrow::Compile(p, pStack);
+
+    case ID_DEBUGDD:
+        return CBotStartDebugDD::Compile(p, pStack);
+
+    case ID_INT:
+        return CBotInt::Compile(p, pStack);
+
+    case ID_FLOAT:
+        return CBotFloat::Compile(p, pStack);
+
+    case ID_STRING:
+        return CBotIString::Compile(p, pStack);
+
+    case ID_BOOLEAN:
+    case ID_BOOL:
+        return CBotBoolean::Compile(p, pStack);
+
+    case ID_IF:
+        return CBotIf::Compile(p, pStack);
+
+    case ID_RETURN:
+        return CBotReturn::Compile(p, pStack);
+
+    case ID_ELSE:
+        pStack->SetStartError(p->GivStart());
+        pStack->SetError(TX_ELSEWITHOUTIF, p->GivEnd());
+        return NULL;
+
+    case ID_CASE:
+        pStack->SetStartError(p->GivStart());
+        pStack->SetError(TX_OUTCASE, p->GivEnd());
+        return NULL;
+    }
+
+    pStack->SetStartError(p->GivStart());
+
+    // should not be a reserved word DefineNum
+    if (p->GivType() == TokenTypDef)
+    {
+        pStack->SetError(TX_RESERVED, p);
+        return NULL;
+    }
+
+    // this might be an instance of class definnition
+    CBotToken*    ppp = p;
+    if (IsOfType(ppp, TokenTypVar))
+    {
+        if (CBotClass::Find(p) != NULL)
+        {
+            // yes, compiles the declaration of the instance
+            return CBotClassInst::Compile(p, pStack);
+        }
+    }
+
+    // this can be an arythmetic instruction
+    CBotInstr*    inst = CBotExpression::Compile(p, pStack);
+    if (IsOfType(p, ID_SEP))
+    {
+        return inst;
+    }
+    pStack->SetError(TX_ENDOF, p->GivStart());
+    delete inst;
+    return NULL;
+}
+
+bool CBotInstr::Execute(CBotStack* &pj)
+{
+    CBotString    ClassManquante = name;
+    ASM_TRAP();            // should never go through this routine
+                            // but use the routines of the subclasses
+    return false;
+}
+
+bool CBotInstr::Execute(CBotStack* &pj, CBotVar* pVar)
+{
+    if (!Execute(pj)) return false;
+    pVar->SetVal(pj->GivVar());
+    return true;
+}
+
+void CBotInstr::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotString    ClassManquante = name;
+    ASM_TRAP();            // should never go through this routine
+                           // but use the routines of the subclasses
+}
+
+
+bool CBotInstr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
+{
+    ASM_TRAP();            // dad do not know, see the girls
+    return false;
+}
+
+bool CBotInstr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend)
+{
+    ASM_TRAP();            // dad do not know, see the girls
+    return false;
+}
+
+void CBotInstr::RestoreStateVar(CBotStack* &pile, bool bMain)
+{
+    ASM_TRAP();            // dad do not know, see the girls
+}
+
+// this routine is defined only for the subclass CBotCase
+// this allows to make the call on all instructions CompCase
+// to see if it's a case to the desired value.
+
+bool CBotInstr::CompCase(CBotStack* &pj, int val)
+{
+    return false;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compiles a statement block " { i ; i ; } "
+
+// this class have no constructor because there is never an instance of this
+// class (TODO what about default constructor?)
+// the object returned by Compile is usually of type CBotListInstr
+
+
+CBotInstr* CBotBlock::Compile(CBotToken* &p, CBotCStack* pStack, bool bLocal)
+{
+    pStack->SetStartError(p->GivStart());
+
+    if (IsOfType(p, ID_OPBLK))
+    {
+        CBotInstr* inst = CBotListInstr::Compile(p, pStack, bLocal);
+
+        if (IsOfType(p, ID_CLBLK))
+        {
+            return inst;
+        }
+
+        pStack->SetError(TX_CLOSEBLK, p->GivStart());    // missing parenthesis
+        delete inst;
+        return NULL;
+    }
+
+    pStack->SetError(TX_OPENBLK, p->GivStart());
+    return NULL;
+}
+
+CBotInstr* CBotBlock::CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, bool bLocal)
+{
+    // is this a new block
+    if (p->GivType() == ID_OPBLK) return CBotBlock::Compile(p, pStack);
+
+    // otherwise, look for a single statement instead
+
+    // to handle the case with local definition instruction (*)
+    CBotCStack* pStk = pStack->TokenStack(p, bLocal);
+
+    return pStack->Return( CBotInstr::Compile(p, pStk),    // a single instruction
+                           pStk);
+}
+
+// (*) is the case in the following statement
+// if (1 == 1) int x = 0;
+// where the variable x is known only in the block following the if
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compiles a list of instructions separated by semicolons
+
+CBotListInstr::CBotListInstr()
+{
+    m_Instr        = NULL;
+    name = "CBotListInstr";
+}
+
+CBotListInstr::~CBotListInstr()
+{
+    delete    m_Instr;
+}
+
+CBotInstr* CBotListInstr::Compile(CBotToken* &p, CBotCStack* pStack, bool bLocal)
+{
+    CBotCStack* pStk = pStack->TokenStack(p, bLocal);        // variables are local
+
+    CBotListInstr* inst = new CBotListInstr();
+
+    while (true)
+    {
+        if (p == NULL) break;
+
+        if (IsOfType(p, ID_SEP)) continue;              // empty statement ignored
+        if (p->GivType() == ID_CLBLK) break;
+
+        if (IsOfType(p, 0))
+        {
+            pStack->SetError(TX_CLOSEBLK, p->GivStart());
+            delete inst;
+            return pStack->Return(NULL, pStk);
+        }
+
+        CBotInstr* i = CBotBlock::CompileBlkOrInst(p, pStk);    // compiles next
+
+        if (!pStk->IsOk())
+        {
+            delete inst;
+            return pStack->Return(NULL, pStk);
+        }
+
+        if (inst->m_Instr == NULL) inst->m_Instr = i;
+        else inst->m_Instr->AddNext(i);                            // added a result
+    }
+    return pStack->Return(inst, pStk);
+}
+
+// executes a set of instructions
+
+bool CBotListInstr::Execute(CBotStack* &pj)
+{
+
+    CBotStack*    pile = pj->AddStack(this, true);                //needed for SetState()
+    if (pile->StackOver() ) return pj->Return( pile);
+
+
+    CBotInstr*    p = m_Instr;                                    // the first expression
+
+    int        state = pile->GivState();
+    while (state-->0) p = p->GivNext();                            // returns to the interrupted operation
+
+    if (p != NULL) while (true)
+    {
+        if (!p->Execute(pile)) return false;
+        p = p->GivNext();
+        if (p == NULL) break;
+        if (!pile->IncState()) ;//return false;                    // ready for next
+    }
+
+    return pj->Return(pile);
+}
+
+void CBotListInstr::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*    pile = pj->RestoreStack(this);
+    if (pile == NULL) return;
+
+    CBotInstr*    p = m_Instr;                                    // the first expression
+
+    int        state = pile->GivState();
+    while ( p != NULL && state-- > 0)
+    {
+        p->RestoreState(pile, false);
+        p = p->GivNext();                            // returns to the interrupted operation
+    }
+
+    if (p != NULL) p->RestoreState(pile, true);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compilation of an element to the left of an assignment
+
+CBotLeftExprVar::CBotLeftExprVar()
+{
+    name    = "CBotLeftExprVar";
+    m_typevar    = -1;
+    m_nIdent    =  0;
+}
+
+CBotLeftExprVar::~CBotLeftExprVar()
+{
+}
+
+CBotInstr* CBotLeftExprVar::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    // verifies that the token is a variable name
+    if (p->GivType() != TokenTypVar)
+    {
+        pStack->SetError( TX_NOVAR, p->GivStart());
+        return NULL;
+    }
+
+    CBotLeftExprVar* inst = new CBotLeftExprVar();
+    inst->SetToken(p);
+    p = p->GivNext();
+
+    return inst;
+}
+
+// creates a variable and assigns the result to the stack 
+bool CBotLeftExprVar::Execute(CBotStack* &pj)
+{
+    CBotVar*     var1;
+    CBotVar*     var2;
+
+    var1 = CBotVar::Create(m_token.GivString(), m_typevar);
+    var1->SetUniqNum(m_nIdent);                             // with the unique identifier
+    pj->AddVar(var1);                                       // place it on the stack
+
+    var2 = pj->GivVar();                                    // result on the stack
+    if (var2) var1->SetVal(var2);                           // do the assignment
+
+    return true;
+}
+
+void CBotLeftExprVar::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotVar*     var1;
+
+    var1 = pj->FindVar(m_token.GivString());
+    if (var1 == NULL) ASM_TRAP();
+
+    var1->SetUniqNum(m_nIdent);                    // with the unique identifier
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// defining an array of any type
+// int a[12];
+// point x[];
+
+CBotInstArray::CBotInstArray()
+{
+    m_var      = NULL;
+    m_listass = NULL;
+    name = "CBotInstArray";
+}
+
+CBotInstArray::~CBotInstArray()
+{
+    delete m_var;
+    delete m_listass;
+}
+
+
+CBotInstr* CBotInstArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type)
+{
+    CBotCStack* pStk = pStack->TokenStack(p);
+
+    CBotInstArray*    inst = new CBotInstArray();
+
+    CBotToken*    vartoken = p;
+    inst->SetToken(vartoken);
+
+    // determinse the expression is valid for the item on the left side
+    if (NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )))
+    {
+        if (pStk->CheckVarLocal(vartoken))                              // redefinition of the variable?
+        {
+            pStk->SetError(TX_REDEFVAR, vartoken);
+            goto error;
+        }
+
+        CBotInstr*    i;
+        while (IsOfType(p,  ID_OPBRK))
+        {
+            if (p->GivType() != ID_CLBRK)
+                i = CBotExpression::Compile(p, pStk);                   // expression for the value
+            else
+                i = new CBotEmpty();                                    // if no special formula
+
+            inst->AddNext3b(i);                                         // construct a list
+            type = CBotTypResult(CBotTypArrayPointer, type);
+
+            if (!pStk->IsOk() || !IsOfType(p, ID_CLBRK ))
+            {
+                pStk->SetError(TX_CLBRK, p->GivStart());
+                goto error;
+            }
+        }
+
+        CBotVar*   var = CBotVar::Create(vartoken, type);               // create an instance
+        inst->m_typevar = type;
+
+        var->SetUniqNum(
+            ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+        pStack->AddVar(var);                                            // place it on the stack
+
+        if (IsOfType(p, ID_ASS))                                        // with an assignment
+        {
+            inst->m_listass = CBotListArray::Compile(p, pStk, type.GivTypElem());
+        }
+
+        if (pStk->IsOk()) return pStack->Return(inst, pStk);
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+
+// executes the definition of an array
+
+bool CBotInstArray::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile1 = pj->AddStack(this);
+
+    CBotStack*    pile  = pile1;
+
+    if (pile1->GivState() == 0)
+    {
+        // seek the maximum dimension of the table
+        CBotInstr*    p  = GivNext3b();                             // the different formulas
+        int            nb = 0;
+
+        while (p != NULL)
+        {
+            pile = pile->AddStack();                                // little room to work
+            nb++;
+            if (pile->GivState() == 0)
+            {
+                if (!p->Execute(pile)) return false;                // size calculation //interrupted?
+                pile->IncState();
+            }
+            p = p->GivNext3b();
+        }
+
+        p     = GivNext3b();
+        pile = pile1;                                               // returns to the stack
+        int     n = 0;
+        int     max[100];
+
+        while (p != NULL)
+        {
+            pile = pile->AddStack();
+            CBotVar*    v = pile->GivVar();                         // result
+            max[n] = v->GivValInt();                                // value
+            if (max[n]>MAXARRAYSIZE)
+            {
+                pile->SetError(TX_OUTARRAY, &m_token);
+                return pj->Return (pile);
+            }
+            n++;
+            p = p->GivNext3b();
+        }
+        while (n<100) max[n++] = 0;
+
+        m_typevar.SetArray(max);                                    // store the limitations
+
+        // create simply a NULL pointer
+        CBotVar*    var = CBotVar::Create(m_var->GivToken(), m_typevar);
+        var->SetPointer(NULL);
+        var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);
+        pj->AddVar(var);
+
+#if        STACKMEM
+        pile1->AddStack()->Delete();
+#else
+        delete pile1->AddStack();                                   // need more indices
+#endif
+        pile1->IncState();
+    }
+
+    if (pile1->GivState() == 1)
+    {
+        if (m_listass != NULL)                                      // there is the assignment for this table
+        {
+            CBotVar* pVar = pj->FindVar(((CBotLeftExprVar*)m_var)->m_nIdent);
+
+            if (!m_listass->Execute(pile1, pVar)) return false;
+        }
+        pile1->IncState();
+    }
+
+    if (pile1->IfStep()) return false;
+
+    if ( m_next2b &&
+         !m_next2b->Execute(pile1 )) return false;
+
+    return pj->Return(pile1);
+}
+
+void CBotInstArray::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*    pile1 = pj;
+
+    CBotVar*    var = pj->FindVar(m_var->GivToken()->GivString());
+    if (var != NULL) var->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);
+
+    if (bMain)
+    {
+        pile1 = pj->RestoreStack(this);
+        CBotStack*    pile  = pile1;
+        if (pile == NULL) return;
+
+        if (pile1->GivState() == 0)
+        {
+            // seek the maximum dimension of the table
+            CBotInstr*    p  = GivNext3b();
+
+            while (p != NULL)
+            {
+                pile = pile->RestoreStack();
+                if (pile == NULL) return;
+                if (pile->GivState() == 0)
+                {
+                    p->RestoreState(pile, bMain);
+                    return;
+                }
+                p = p->GivNext3b();
+            }
+        }
+        if (pile1->GivState() == 1 && m_listass != NULL)
+        {
+            m_listass->RestoreState(pile1, bMain);
+        }
+
+    }
+
+    if (m_next2b ) m_next2b->RestoreState( pile1, bMain);
+}
+
+// special case for empty indexes
+bool CBotEmpty :: Execute(CBotStack* &pj)
+{
+    CBotVar*    pVar = CBotVar::Create("", CBotTypInt);
+    pVar->SetValInt(-1);
+    pj->SetVar(pVar);
+    return true;
+}
+
+void CBotEmpty :: RestoreState(CBotStack* &pj, bool bMain)
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// defining a list table initialization
+// int [ ] a [ ] = (( 1, 2, 3 ) , ( 3, 2, 1 )) ;
+
+
+CBotListArray::CBotListArray()
+{
+    m_expr    = NULL;
+    name = "CBotListArray";
+}
+
+CBotListArray::~CBotListArray()
+{
+    delete m_expr;
+}
+
+
+CBotInstr* CBotListArray::Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type)
+{
+    CBotCStack* pStk = pStack->TokenStack(p);
+
+    CBotToken* pp = p;
+
+    if (IsOfType( p, ID_NULL ))
+    {
+        CBotInstr* inst = new CBotExprNull ();
+        inst->SetToken(pp);
+        return pStack->Return(inst, pStk);            // ok with empty element
+    }
+
+    CBotListArray*    inst = new CBotListArray();
+
+    if (IsOfType( p, ID_OPENPAR ))
+    {
+        // each element takes the one after the other
+        if (type.Eq( CBotTypArrayPointer ))
+        {
+            type = type.GivTypElem();
+
+            pStk->SetStartError(p->GivStart());
+            if (NULL == ( inst->m_expr = CBotListArray::Compile( p, pStk, type ) ))
+            {
+                goto error;
+            }
+
+            while (IsOfType( p, ID_COMMA ))                                     // other elements?
+            {
+                pStk->SetStartError(p->GivStart());
+
+                CBotInstr* i = CBotListArray::Compile(p, pStk, type);
+                if (NULL == i)
+                {
+                    goto error;
+                }
+
+                inst->m_expr->AddNext3(i);
+            }
+        }
+        else
+        {
+            pStk->SetStartError(p->GivStart());
+            if (NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )))
+            {
+                goto error;
+            }
+            CBotVar* pv = pStk->GivVar();                                       // result of the expression
+
+            if (pv == NULL || !TypesCompatibles( type, pv->GivTypResult()))     // compatible type?
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }
+
+            while (IsOfType( p, ID_COMMA ))                                      // other elements?
+            {
+                pStk->SetStartError(p->GivStart());
+
+                CBotInstr* i = CBotTwoOpExpr::Compile(p, pStk) ;
+                if (NULL == i)
+                {
+                    goto error;
+                }
+
+                CBotVar* pv = pStk->GivVar();                                   // result of the expression
+
+                if (pv == NULL || !TypesCompatibles( type, pv->GivTypResult())) // compatible type?
+                {
+                    pStk->SetError(TX_BADTYPE, p->GivStart());
+                    goto error;
+                }
+                inst->m_expr->AddNext3(i);
+            }
+        }
+
+        if (!IsOfType(p, ID_CLOSEPAR) )
+        {
+            pStk->SetError(TX_CLOSEPAR, p->GivStart());
+            goto error;
+        }
+
+        return pStack->Return(inst, pStk);
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+
+// executes the definition of an array
+
+bool CBotListArray::Execute(CBotStack* &pj, CBotVar* pVar)
+{
+    CBotStack*    pile1 = pj->AddStack();
+    CBotVar* pVar2;
+
+    CBotInstr* p = m_expr;
+
+    int n = 0;
+
+    for (; p != NULL ; n++, p = p->GivNext3())
+    {
+        if (pile1->GivState() > n) continue;
+
+        pVar2 = pVar->GivItem(n, true);
+
+        if (!p->Execute(pile1, pVar2)) return false;        // evaluate expression
+
+        pile1->IncState();
+    }
+
+    return pj->Return(pile1);
+}
+
+void CBotListArray::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain)
+    {
+        CBotStack*    pile  = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        CBotInstr* p = m_expr;
+
+        int    state = pile->GivState();
+
+        while(state-- > 0) p = p->GivNext3() ;
+
+        p->RestoreState(pile, bMain);                    // size calculation //interrupted!
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// definition of an integer variable
+// int a, b = 12;
+
+CBotInt::CBotInt()
+{
+    m_next    = NULL;            // for multiple definitions
+    m_var    =
+    m_expr    = NULL;
+    name = "CBotInt";
+}
+
+CBotInt::~CBotInt()
+{
+    delete m_var;
+    delete m_expr;
+}
+
+CBotInstr* CBotInstr::CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypResult type, bool first)
+{
+    if (IsOfType(p, ID_OPBRK))
+    {
+        if (!IsOfType(p, ID_CLBRK))
+        {
+            pStack->SetError(TX_CLBRK, p->GivStart());
+            return NULL;
+        }
+
+        CBotInstr*    inst = CompileArray(p, pStack, CBotTypResult(CBotTypArrayPointer, type), false);
+        if (inst != NULL || !pStack->IsOk()) return inst;
+    }
+
+    // compiles an array declaration
+    if (first) return NULL ;
+
+    CBotInstr* inst = CBotInstArray::Compile(p, pStack, type);
+    if (inst == NULL) return NULL;
+
+    if (IsOfType(p,  ID_COMMA)) // several definitions
+    {
+        if (NULL != ( inst->m_next2b = CBotInstArray::CompileArray(p, pStack, type, false)))    // compiles next one
+        {
+            return inst;
+        }
+        delete inst;
+        return NULL;
+    }
+
+    if (IsOfType(p,  ID_SEP))                            // end of instruction
+    {
+        return inst;
+    }
+
+    delete inst;
+    pStack->SetError(TX_ENDOF, p->GivStart());
+    return NULL;
+}
+
+CBotInstr* CBotInt::Compile(CBotToken* &p, CBotCStack* pStack, bool cont, bool noskip)
+{
+    CBotToken*    pp = cont ? NULL : p;        // no repetition of the token "int"
+
+    if (!cont && !IsOfType(p, ID_INT)) return NULL;
+
+    CBotInt*    inst = (CBotInt*)CompileArray(p, pStack, CBotTypInt);
+    if (inst != NULL || !pStack->IsOk()) return inst;
+
+    CBotCStack* pStk = pStack->TokenStack(pp);
+
+    inst = new CBotInt();
+
+    inst->m_expr = NULL;
+
+    CBotToken*    vartoken = p;
+    inst->SetToken(vartoken);
+
+    // determines the expression is valid for the item on the left side
+    if (NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )))
+    {
+        ((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypInt;
+        if (pStk->CheckVarLocal(vartoken))  // redefinition of the variable
+        {
+            pStk->SetError(TX_REDEFVAR, vartoken);
+            goto error;
+        }
+
+        if (IsOfType(p,  ID_OPBRK))
+        {
+            delete inst;    // type is not CBotInt
+            p = vartoken;   // returns the variable name
+
+            // compiles an array declaration
+
+            CBotInstr* inst2 = CBotInstArray::Compile(p, pStk, CBotTypInt);
+
+            if (!pStk->IsOk() )
+            {
+                pStk->SetError(TX_CLBRK, p->GivStart());
+                goto error;
+            }
+
+            if (IsOfType(p,  ID_COMMA))     // several definition chained
+            {
+                if (NULL != ( inst2->m_next2b = CBotInt::Compile(p, pStk, true, noskip)))    // compile the next one
+                {
+                    return pStack->Return(inst2, pStk);
+                }
+            }
+            inst = (CBotInt*)inst2;
+            goto suite;     // no assignment, variable already created
+        }
+
+        if (IsOfType(p,  ID_ASS))   // with an assignment?
+        {
+            if (NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )))
+            {
+                goto error;
+            }
+            if (pStk->GivType() >= CBotTypBoolean)  // compatible type ?
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }
+        }
+
+        {
+            CBotVar*    var = CBotVar::Create(vartoken, CBotTypInt);// create the variable (evaluated after the assignment)
+            var->SetInit(inst->m_expr != NULL);     // if initialized with assignment
+            var->SetUniqNum( //set it with a unique number
+                ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+            pStack->AddVar(var);    // place it on the stack
+        }
+
+        if (IsOfType(p,  ID_COMMA))     // chained several definitions
+        {
+            if (NULL != ( inst->m_next2b = CBotInt::Compile(p, pStk, true, noskip)))    // compile next one
+            {
+                return pStack->Return(inst, pStk);
+            }
+        }
+suite:
+        if (noskip || IsOfType(p,  ID_SEP))                    // instruction is completed
+        {
+            return pStack->Return(inst, pStk);
+        }
+
+        pStk->SetError(TX_ENDOF, p->GivStart());
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// execute the definition of the integer variable
+
+bool CBotInt::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);    // essential for SetState()
+
+    if ( pile->GivState()==0)
+    {
+        if (m_expr && !m_expr->Execute(pile)) return false;    // initial value // interrupted?
+        m_var->Execute(pile);                                // creates and assign the result
+
+        if (!pile->SetState(1)) return false;
+    }
+
+    if (pile->IfStep()) return false;
+
+    if ( m_next2b && 
+         !m_next2b->Execute(pile)) return false;                // other(s) definition(s)
+
+    return pj->Return(pile);                                // forward below
+}
+
+void CBotInt::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*    pile = pj;
+    if (bMain)
+    {
+        pile = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        if ( pile->GivState()==0)
+        {
+            if (m_expr) m_expr->RestoreState(pile, bMain);    // initial value // interrupted?
+            return;
+        }
+    }
+
+    m_var->RestoreState(pile, bMain);
+
+    if (m_next2b) m_next2b->RestoreState(pile, bMain);            // other(s) definition(s)
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// defining a boolean variable
+// int a, b = false;
+
+CBotBoolean::CBotBoolean()
+{
+    m_var    =
+    m_expr    = NULL;
+    name = "CBotBoolean";
+}
+
+CBotBoolean::~CBotBoolean()
+{
+    delete m_var;
+    delete m_expr;
+}
+
+CBotInstr* CBotBoolean::Compile(CBotToken* &p, CBotCStack* pStack, bool cont, bool noskip)
+{
+    CBotToken*    pp = cont ? NULL : p;
+
+    if (!cont && !IsOfType(p, ID_BOOLEAN, ID_BOOL)) return NULL;
+
+    CBotBoolean*    inst = (CBotBoolean*)CompileArray(p, pStack, CBotTypBoolean);
+    if (inst != NULL || !pStack->IsOk()) return inst;
+
+    CBotCStack* pStk = pStack->TokenStack(pp);
+
+    inst = new CBotBoolean();
+
+    inst->m_expr = NULL;
+
+    CBotToken*    vartoken = p;
+    inst->SetToken(vartoken);
+    CBotVar*    var = NULL;
+
+    if (NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )))
+    {
+        ((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypBoolean;
+        if (pStk->CheckVarLocal(vartoken))                    // redefinition of the variable
+        {
+            pStk->SetError(TX_REDEFVAR, vartoken);
+            goto error;
+        }
+
+        if (IsOfType(p,  ID_OPBRK))
+        {
+            delete inst;                                    // type is not CBotInt
+            p = vartoken;                                    // resutns to the variable name
+
+            // compiles an array declaration
+
+            inst = (CBotBoolean*)CBotInstArray::Compile(p, pStk, CBotTypBoolean);
+
+            if (!pStk->IsOk() )
+            {
+                pStk->SetError(TX_CLBRK, p->GivStart());
+                goto error;
+            }
+            goto suite;            // no assignment, variable already created
+        }
+
+        if (IsOfType(p,  ID_ASS))
+        {
+            if (NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )))
+            {
+                goto error;
+            }
+            if (!pStk->GivTypResult().Eq(CBotTypBoolean))
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }
+        }
+
+        var = CBotVar::Create(vartoken, CBotTypBoolean);// create the variable (evaluated after the assignment)
+        var->SetInit(inst->m_expr != NULL);
+        var->SetUniqNum(
+            ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+        pStack->AddVar(var);
+suite:
+        if (IsOfType(p,  ID_COMMA))
+        {
+            if (NULL != ( inst->m_next2b = CBotBoolean::Compile(p, pStk, true, noskip)))
+            {
+                return pStack->Return(inst, pStk);
+            }
+        }
+
+        if (noskip || IsOfType(p,  ID_SEP))
+        {
+            return pStack->Return(inst, pStk);
+        }
+
+        pStk->SetError(TX_ENDOF, p->GivStart());
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// executes a boolean variable definition
+
+bool CBotBoolean::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);//essential for SetState()
+
+    if ( pile->GivState()==0)
+    {
+        if (m_expr && !m_expr->Execute(pile)) return false;
+        m_var->Execute(pile);
+
+        if (!pile->SetState(1)) return false;
+    }
+
+    if (pile->IfStep()) return false;
+
+    if ( m_next2b &&
+         !m_next2b->Execute(pile)) return false;
+
+    return pj->Return(pile);
+}
+
+void CBotBoolean::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*    pile = pj;
+    if (bMain)
+    {
+        pile = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        if ( pile->GivState()==0)
+        {
+            if (m_expr) m_expr->RestoreState(pile, bMain);        // initial value interrupted?
+            return;
+        }
+    }
+
+    m_var->RestoreState(pile, bMain);
+
+    if (m_next2b)
+         m_next2b->RestoreState(pile, bMain);                // other(s) definition(s)
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// definition of a real/float variable
+// int a, b = 12.4;
+
+CBotFloat::CBotFloat()
+{
+    m_var    =
+    m_expr    = NULL;
+    name = "CBotFloat";
+}
+
+CBotFloat::~CBotFloat()
+{
+    delete m_var;
+    delete m_expr;
+}
+
+CBotInstr* CBotFloat::Compile(CBotToken* &p, CBotCStack* pStack, bool cont, bool noskip)
+{
+    CBotToken*    pp = cont ? NULL : p;
+
+    if (!cont && !IsOfType(p, ID_FLOAT)) return NULL;
+
+    CBotFloat*    inst = (CBotFloat*)CompileArray(p, pStack, CBotTypFloat);
+    if (inst != NULL || !pStack->IsOk()) return inst;
+
+    CBotCStack* pStk = pStack->TokenStack(pp);
+
+    inst = new CBotFloat();
+
+    inst->m_expr = NULL;
+
+    CBotToken*    vartoken = p;
+    CBotVar*    var = NULL;
+    inst->SetToken(vartoken);
+
+    if (NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )))
+    {
+        ((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypFloat;
+        if (pStk->CheckVarLocal(vartoken))                    // redefinition of a variable
+        {
+            pStk->SetStartError(vartoken->GivStart());
+            pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
+            goto error;
+        }
+
+        if (IsOfType(p,  ID_OPBRK))
+        {
+            delete inst;
+            p = vartoken;
+            inst = (CBotFloat*)CBotInstArray::Compile(p, pStk, CBotTypFloat);
+
+            if (!pStk->IsOk() )
+            {
+                pStk->SetError(TX_CLBRK, p->GivStart());
+                goto error;
+            }
+            goto suite;            // no assignment, variable already created
+        }
+
+        if (IsOfType(p,  ID_ASS))
+        {
+            if (NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )))
+            {
+                goto error;
+            }
+            if (pStk->GivType() >= CBotTypBoolean)
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }
+        }
+
+        var = CBotVar::Create(vartoken, CBotTypFloat);
+        var->SetInit(inst->m_expr != NULL);
+        var->SetUniqNum(
+            ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+        pStack->AddVar(var);
+suite:
+        if (IsOfType(p,  ID_COMMA))
+        {
+            if (NULL != ( inst->m_next2b = CBotFloat::Compile(p, pStk, true, noskip)))
+            {
+                return pStack->Return(inst, pStk);
+            }
+        }
+
+        if (noskip || IsOfType(p,  ID_SEP))
+        {
+            return pStack->Return(inst, pStk);
+        }
+
+        pStk->SetError(TX_ENDOF, p->GivStart());
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// executes the definition of a real variable
+
+bool CBotFloat::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if ( pile->GivState()==0)
+    {
+        if (m_expr && !m_expr->Execute(pile)) return false;
+        m_var->Execute(pile);
+
+        if (!pile->SetState(1)) return false;
+    }
+
+    if (pile->IfStep()) return false;
+
+    if ( m_next2b &&
+         !m_next2b->Execute(pile)) return false;
+
+    return pj->Return(pile);
+}
+
+void CBotFloat::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*    pile = pj;
+    if (bMain)
+    {
+        pile = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        if ( pile->GivState()==0)
+        {
+            if (m_expr) m_expr->RestoreState(pile, bMain);
+            return;
+        }
+    }
+
+    m_var->RestoreState(pile, bMain);
+
+    if (m_next2b)
+         m_next2b->RestoreState(pile, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// define a string variable
+// int a, b = "salut";
+
+CBotIString::CBotIString()
+{
+    m_var    =
+    m_expr    = NULL;
+    name = "CBotIString";
+}
+
+CBotIString::~CBotIString()
+{
+    delete m_var;
+    delete m_expr;
+}
+
+CBotInstr* CBotIString::Compile(CBotToken* &p, CBotCStack* pStack, bool cont, bool noskip)
+{
+    CBotToken*    pp = cont ? NULL : p;
+
+    if (!cont && !IsOfType(p, ID_STRING)) return NULL;
+
+    CBotIString*    inst = (CBotIString*)CompileArray(p, pStack, CBotTypString);
+    if (inst != NULL || !pStack->IsOk()) return inst;
+
+    CBotCStack* pStk = pStack->TokenStack(pp);
+
+    inst = new CBotIString();
+
+    inst->m_expr = NULL;
+
+    CBotToken*    vartoken = p;
+    inst->SetToken(vartoken);
+
+    if (NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )))
+    {
+        ((CBotLeftExprVar*)inst->m_var)->m_typevar = CBotTypString;
+        if (pStk->CheckVarLocal(vartoken))
+        {
+            pStk->SetStartError(vartoken->GivStart());
+            pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
+            goto error;
+        }
+
+        if (IsOfType(p,  ID_ASS))
+        {
+            if (NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )))
+            {
+                goto error;
+            }
+/*            if (!pStk->GivTypResult().Eq(CBotTypString))            // type compatible ?
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }*/
+        }
+
+        CBotVar*    var = CBotVar::Create(vartoken, CBotTypString);
+        var->SetInit(inst->m_expr != NULL);
+        var->SetUniqNum(
+            ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+        pStack->AddVar(var);
+
+        if (IsOfType(p,  ID_COMMA))
+        {
+            if (NULL != ( inst->m_next2b = CBotIString::Compile(p, pStk, true, noskip)))
+            {
+                return pStack->Return(inst, pStk);
+            }
+        }
+
+        if (noskip || IsOfType(p,  ID_SEP))
+        {
+            return pStack->Return(inst, pStk);
+        }
+
+        pStk->SetError(TX_ENDOF, p->GivStart());
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// executes the definition of the string variable
+
+bool CBotIString::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if ( pile->GivState()==0)
+    {
+        if (m_expr && !m_expr->Execute(pile)) return false;
+        m_var->Execute(pile);
+
+        if (!pile->SetState(1)) return false;
+    }
+
+    if (pile->IfStep()) return false;
+
+    if ( m_next2b &&
+         !m_next2b->Execute(pile)) return false;
+
+    return pj->Return(pile);
+}
+
+void CBotIString::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*    pile = pj;
+
+    if (bMain)
+    {
+        pile = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        if ( pile->GivState()==0)
+        {
+            if (m_expr) m_expr->RestoreState(pile, bMain);
+            return;
+        }
+    }
+
+    m_var->RestoreState(pile, bMain);
+
+    if (m_next2b)
+         m_next2b->RestoreState(pile, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compiles a statement such as " x = 123 " ou " z * 5 + 4 "
+// with or without assignment
+
+CBotExpression::CBotExpression()
+{
+    m_leftop    = NULL;
+    m_rightop    = NULL;
+    name = "CBotExpression";
+}
+
+CBotExpression::~CBotExpression()
+{
+    delete    m_leftop;
+    delete    m_rightop;
+}
+
+CBotInstr* CBotExpression::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*    pp = p;
+
+    CBotExpression* inst = new CBotExpression();
+
+    inst->m_leftop = CBotLeftExpr::Compile(p, pStack);
+
+    inst->SetToken(p);
+    int  OpType = p->GivType();
+
+    if ( pStack->IsOk() &&
+         IsOfTypeList(p, ID_ASS, ID_ASSADD, ID_ASSSUB, ID_ASSMUL, ID_ASSDIV, ID_ASSMODULO, 
+                                 ID_ASSAND, ID_ASSXOR, ID_ASSOR, 
+                                 ID_ASSSL , ID_ASSSR,  ID_ASSASR, 0 ))
+    {
+        if (inst->m_leftop == NULL)
+        {
+            pStack->SetError(TX_BADLEFT, p->GivEnd());
+            delete inst;
+            return NULL;
+        }
+
+        inst->m_rightop = CBotExpression::Compile(p, pStack);
+        if (inst->m_rightop == NULL)
+        {
+            delete inst;
+            return NULL;
+        }
+
+        CBotTypResult    type1 = pStack->GivTypResult();
+
+        // get the variable assigned to mark
+        CBotVar*    var = NULL;
+        inst->m_leftop->ExecuteVar(var, pStack);
+        if (var == NULL)
+        {
+            delete inst;
+            return NULL;
+        }
+
+        if (OpType != ID_ASS && var->GivInit() != IS_DEF)
+        {
+            pStack->SetError(TX_NOTINIT, pp);
+            delete inst;
+            return NULL;
+        }
+
+        CBotTypResult type2 = var->GivTypResult();
+
+        // what types are acceptable?
+        switch (OpType)
+        {
+        case ID_ASS:
+    //        if (type2 == CBotTypClass) type2 = -1;
+            if ((type1.Eq(CBotTypPointer) && type2.Eq(CBotTypPointer)) ||
+                 (type1.Eq(CBotTypClass)   && type2.Eq(CBotTypClass)   ) )
+            {
+/*                CBotClass*    c1 = type1.GivClass();
+                CBotClass*    c2 = type2.GivClass();
+                if (!c1->IsChildOf(c2)) type2.SetType(-1);
+//-                if (!type1.Eq(CBotTypClass)) var->SetPointer(pStack->GivVar()->GivPointer());*/
+                var->SetInit(2);
+            }
+            else
+                var->SetInit(true);
+
+            break;
+        case ID_ASSADD:
+            if (type2.Eq(CBotTypBoolean) ||
+                type2.Eq(CBotTypPointer) ) type2 = -1;        // numbers and strings
+            break;
+        case ID_ASSSUB:
+        case ID_ASSMUL:
+        case ID_ASSDIV:
+        case ID_ASSMODULO:
+            if (type2.GivType() >= CBotTypBoolean) type2 = -1;    // numbers only
+            break;
+        }
+
+        if (!TypeCompatible(type1, type2, OpType))
+        {
+            pStack->SetError(TX_BADTYPE, &inst->m_token);
+            delete inst;
+            return NULL;
+        }
+
+        return inst;        // compatible type?
+    }
+
+    delete inst;
+    int start, end, error = pStack->GivError(start, end);
+
+    p = pp;                                        // returns to the top
+    pStack->SetError(0,0);                        // forget the error
+
+    CBotInstr* i = CBotTwoOpExpr::Compile(p, pStack);    // tries without assignment
+    if (i != NULL && error == TX_PRIVATE && p->GivType() == ID_ASS)
+        pStack->ResetError(error, start, end);
+    return i;
+}
+
+// executes an expression with assignment
+
+bool CBotExpression::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile  = pj->AddStack(this);
+
+    CBotToken*    pToken = m_leftop->GivToken();
+    CBotVar*    pVar = NULL;
+
+    CBotStack*  pile1 = pile;
+
+    bool        IsInit = true;
+    CBotVar*    result = NULL;
+
+    // must be done before any indexes (stack can be changed)
+    if (!m_leftop->ExecuteVar(pVar, pile, NULL, false)) return false;    // variable before accessing the value on the right
+
+    if ( pile1->GivState()==0)
+    {
+        pile1->SetCopyVar(pVar);    // keeps the copy on the stack (if interrupted)
+        pile1->IncState();
+    }
+
+    CBotStack*    pile2 = pile->AddStack();
+
+    if ( pile2->GivState()==0)
+    {
+        if (m_rightop && !m_rightop->Execute(pile2)) return false;    // initial value // interrupted?
+        pile2->IncState();
+    }
+
+    if (pile1->GivState() == 1)
+    {
+        if (m_token.GivType() != ID_ASS)
+        {
+            pVar = pile1->GivVar();     // recovers if interrupted
+            IsInit = pVar->GivInit();
+            if (IsInit == IS_NAN)
+            {
+                pile2->SetError(TX_OPNAN, m_leftop->GivToken());
+                return pj->Return(pile2);
+             }
+            result = CBotVar::Create("", pVar->GivTypResult(2));
+        }
+
+        switch (m_token.GivType())
+        {
+        case ID_ASS:
+            break;
+        case ID_ASSADD:
+            result->Add(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSSUB:
+            result->Sub(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSMUL:
+            result->Mul(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSDIV:
+            if (IsInit && 
+                result->Div(pile1->GivVar(), pile2->GivVar()))
+                pile2->SetError(TX_DIVZERO, &m_token);
+            pile2->SetVar(result);
+            break;
+        case ID_ASSMODULO:
+            if (IsInit && 
+                result->Modulo(pile1->GivVar(), pile2->GivVar()))
+                pile2->SetError(TX_DIVZERO, &m_token);
+            pile2->SetVar(result);
+            break;
+        case ID_ASSAND:
+            result->And(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSXOR:
+            result->XOr(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSOR:
+            result->Or(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSSL:
+            result->SL(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSSR:
+            result->SR(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        case ID_ASSASR:
+            result->ASR(pile1->GivVar(), pile2->GivVar());
+            pile2->SetVar(result);
+            break;
+        default:
+            ASM_TRAP();
+        }
+        if (!IsInit)
+            pile2->SetError(TX_NOTINIT, m_leftop->GivToken());
+
+        pile1->IncState();
+    }
+
+    if (!m_leftop->Execute( pile2, pile1 ))
+        return false;
+
+    return pj->Return(pile2);
+}
+
+
+void CBotExpression::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain)
+    {
+        CBotToken*    pToken = m_leftop->GivToken();
+        CBotVar*    pVar = NULL;
+
+        CBotStack*    pile  = pj->RestoreStack(this);
+        if (pile == NULL) return;
+
+        CBotStack*  pile1 = pile;
+
+        if ( pile1->GivState()==0)
+        {
+            m_leftop->RestoreStateVar(pile, true); 
+            return;
+        }
+
+        m_leftop->RestoreStateVar(pile, false);
+
+        CBotStack*    pile2 = pile->RestoreStack();
+        if (pile2 == NULL) return;
+
+        if ( pile2->GivState()==0)
+        {
+            if (m_rightop) m_rightop->RestoreState(pile2, bMain);
+            return;
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a statement such as "(condition)"
+// the condition must be Boolean
+
+// this class has no constructor, because there is never an instance of this class
+// the object returned by Compile is usually type CBotExpression
+
+
+CBotInstr* CBotCondition::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    pStack->SetStartError(p->GivStart());
+    if (IsOfType(p, ID_OPENPAR))
+    {
+        CBotInstr* inst = CBotBoolExpr::Compile(p, pStack);
+        if (NULL != inst)
+        {
+            if (IsOfType(p, ID_CLOSEPAR))
+            {
+                return inst;
+            }
+            pStack->SetError(TX_CLOSEPAR, p->GivStart());    // missing parenthesis
+        }
+        delete inst;
+    }
+
+    pStack->SetError(TX_OPENPAR, p->GivStart());    // missing parenthesis
+
+    return NULL;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a statement such as "(condition)"
+// the condition must be Boolean
+//
+// this class has no constructor, because there is never an instance of this
+// class
+// the object returned by Compile is usually type CBotExpression
+//
+
+CBotInstr* CBotBoolExpr::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    pStack->SetStartError(p->GivStart());
+
+    CBotInstr* inst = CBotTwoOpExpr::Compile(p, pStack);
+
+    if (NULL != inst)
+    {
+        if (pStack->GivTypResult().Eq(CBotTypBoolean))
+        {
+            return inst;
+        }
+        pStack->SetError(TX_NOTBOOL, p->GivStart());    // is not a boolean
+    }
+
+    delete inst;
+    return NULL;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile either:
+// instruction in parentheses (...)
+// a unary expression (negative, not)
+// variable name
+// variables pre and post-incremented or decremented
+// a given number DefineNum
+// a constant
+// procedure call
+// new statement
+//
+// this class has no constructor, because there is never an instance of this class
+// the object returned by Compile is the class corresponding to the instruction
+
+
+CBotInstr* CBotParExpr::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->TokenStack();
+
+    pStk->SetStartError(p->GivStart());
+
+    // is it an expression in parentheses?
+    if (IsOfType(p, ID_OPENPAR))
+    {
+        CBotInstr* inst = CBotExpression::Compile(p, pStk);
+
+        if (NULL != inst)
+        {
+            if (IsOfType(p, ID_CLOSEPAR))
+            {
+                return pStack->Return(inst, pStk);
+            }
+            pStk->SetError(TX_CLOSEPAR, p->GivStart());
+        }
+        delete inst;
+        return pStack->Return(NULL, pStk);
+    }
+
+    // is this a unary operation?
+    CBotInstr* inst = CBotExprUnaire::Compile(p, pStk);
+    if (inst != NULL || !pStk->IsOk())
+        return pStack->Return(inst, pStk);
+
+    // is it a variable name?
+    if (p->GivType() == TokenTypVar)
+    {
+        // this may be a method call without the "this." before
+        inst =  CBotExprVar::CompileMethode(p, pStk);
+        if (inst != NULL) return pStack->Return(inst, pStk);
+
+
+        // is it a procedure call?
+        inst =  CBotInstrCall::Compile(p, pStk);
+        if (inst != NULL || !pStk->IsOk())
+            return pStack->Return(inst, pStk);
+
+
+        CBotToken* pvar = p;
+        // no, it an "ordinaty" variable
+        inst =  CBotExprVar::Compile(p, pStk);
+
+        CBotToken* pp = p;
+        // post incremented or decremented?
+        if (IsOfType(p, ID_INC, ID_DEC))
+        {
+            if (pStk->GivType() >= CBotTypBoolean)
+            {
+                pStk->SetError(TX_BADTYPE, pp);
+                delete inst;
+                return pStack->Return(NULL, pStk);
+            }
+
+            // recompile the variable for read-only
+            delete inst;
+            p = pvar;
+            inst =  CBotExprVar::Compile(p, pStk, PR_READ);
+            p = p->GivNext();
+
+            CBotPostIncExpr* i = new CBotPostIncExpr();
+            i->SetToken(pp);
+            i->m_Instr = inst;    // associated statement
+            return pStack->Return(i, pStk);
+        }
+        return pStack->Return(inst, pStk);
+    }
+
+    // pre increpemted or pre decremented?
+    CBotToken* pp = p;
+    if (IsOfType(p, ID_INC, ID_DEC))
+    {
+        CBotPreIncExpr* i = new CBotPreIncExpr();
+        i->SetToken(pp);
+
+        if (p->GivType() == TokenTypVar)
+        {
+            if (NULL != (i->m_Instr =  CBotExprVar::Compile(p, pStk, PR_READ)))
+            {
+                if (pStk->GivType() >= CBotTypBoolean)
+                {
+                    pStk->SetError(TX_BADTYPE, pp);
+                    delete inst;
+                    return pStack->Return(NULL, pStk);
+                }
+                return pStack->Return(i, pStk);
+            }
+            delete i;
+            return pStack->Return(NULL, pStk);
+        }
+    }
+
+    // is it a number or DefineNum?
+    if (p->GivType() == TokenTypNum || 
+        p->GivType() == TokenTypDef )
+    {
+        CBotInstr* inst = CBotExprNum::Compile(p, pStk);
+        return pStack->Return(inst, pStk);
+    }
+
+    // is this a chaine?
+    if (p->GivType() == TokenTypString)
+    {
+        CBotInstr* inst = CBotExprAlpha::Compile(p, pStk);
+        return pStack->Return(inst, pStk);
+    }
+
+    // is a "true" or "false"
+    if (p->GivType() == ID_TRUE ||
+        p->GivType() == ID_FALSE )
+    {
+        CBotInstr* inst = CBotExprBool::Compile(p, pStk);
+        return pStack->Return(inst, pStk);
+    }
+
+    // is an object to be created with new
+    if (p->GivType() == ID_NEW)
+    {
+        CBotInstr* inst = CBotNew::Compile(p, pStk);
+        return pStack->Return(inst, pStk);
+    }
+
+    // is a null pointer
+    if (IsOfType(p, ID_NULL))
+    {
+        CBotInstr* inst = new CBotExprNull ();
+        inst->SetToken(pp);
+        CBotVar* var = CBotVar::Create("", CBotTypNullPointer);
+        pStk->SetVar(var);
+        return pStack->Return(inst, pStk);
+    }
+
+    // is a number nan
+    if (IsOfType(p, ID_NAN))
+    {
+        CBotInstr* inst = new CBotExprNan ();
+        inst->SetToken(pp);
+        CBotVar* var = CBotVar::Create("", CBotTypInt);
+        var->SetInit(IS_NAN);
+        pStk->SetVar(var);
+        return pStack->Return(inst, pStk);
+    }
+
+
+    return pStack->Return(NULL, pStk);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// Management of pre-and post increment / decrement
+// There is no routine Compiles, the object is created directly
+// Compiles in CBotParExpr ::
+
+
+CBotPostIncExpr::CBotPostIncExpr()
+{
+    m_Instr = NULL;
+    name    = "CBotPostIncExpr";
+}
+
+CBotPostIncExpr::~CBotPostIncExpr()
+{
+    delete    m_Instr;
+}
+
+CBotPreIncExpr::CBotPreIncExpr()
+{
+    m_Instr = NULL;
+    name    = "CBotPreIncExpr";
+}
+
+CBotPreIncExpr::~CBotPreIncExpr()
+{
+    delete    m_Instr;
+}
+
+bool CBotPostIncExpr::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile1 = pj->AddStack(this);
+    CBotStack*    pile2 = pile1;
+
+    CBotVar*    var1 = NULL;
+
+    // retrieves the variable fields and indexes according
+    if (!((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, true)) return false;
+
+    pile1->SetState(1);
+    pile1->SetCopyVar(var1);                                // places the result (before incrementation);
+
+    CBotStack* pile3 = pile2->AddStack(this); 
+    if (pile3->IfStep()) return false;
+
+    if (var1->GivInit() == IS_NAN)
+    {
+        pile1->SetError(TX_OPNAN, &m_token);
+    }
+
+    if (var1->GivInit() != IS_DEF)
+    {
+        pile1->SetError(TX_NOTINIT, &m_token);
+    }
+
+    if (GivTokenType() == ID_INC) var1->Inc();
+    else                          var1->Dec();
+
+    return pj->Return(pile1);                        // operation done, result on pile2
+}
+
+void CBotPostIncExpr::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*    pile1 = pj->RestoreStack(this);
+    if (pile1 == NULL) return;
+
+    ((CBotExprVar*)m_Instr)->RestoreStateVar(pile1, bMain);
+
+    if (pile1 != NULL) pile1->RestoreStack(this);
+}
+
+bool CBotPreIncExpr::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+
+    CBotVar*     var1;
+
+    if (pile->GivState() == 0)
+    {
+        CBotStack*    pile2 = pile;
+        // retrieves the variable fields and indexes according
+        // pile2 is modified on return
+        if (!((CBotExprVar*)m_Instr)->ExecuteVar(var1, pile2, NULL, true)) return false;
+
+        if (var1->GivInit() == IS_NAN)
+        {
+            pile->SetError(TX_OPNAN, &m_token);
+            return pj->Return(pile);    // operation performed
+        }
+
+        if (var1->GivInit() != IS_DEF)
+        {
+            pile->SetError(TX_NOTINIT, &m_token);
+            return pj->Return(pile);    // operation performed
+        }
+
+        if (GivTokenType() == ID_INC) var1->Inc();
+        else                          var1->Dec();  // ((CBotVarInt*)var1)->m_val
+
+        pile->IncState();
+    }
+
+    if (!m_Instr->Execute(pile)) return false;
+    return pj->Return(pile);    // operation performed
+}
+
+
+void CBotPreIncExpr::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*    pile = pj->RestoreStack(this);
+    if (pile == NULL) return;
+
+    if (pile->GivState() == 0)
+    {
+        return;
+    }
+
+    m_Instr->RestoreState(pile, bMain);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile an unary expression
+//    +
+//    -
+//    not
+//    !
+//    ~
+
+CBotExprUnaire::CBotExprUnaire()
+{
+    m_Expr = NULL;
+    name = "CBotExprUnaire";
+}
+
+CBotExprUnaire::~CBotExprUnaire()
+{
+    delete m_Expr;
+}
+
+CBotInstr* CBotExprUnaire::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    int op = p->GivType();
+    CBotToken*    pp = p;
+    if (!IsOfTypeList( p, ID_ADD, ID_SUB, ID_LOG_NOT, ID_TXT_NOT, ID_NOT, 0 )) return NULL;
+
+    CBotCStack* pStk = pStack->TokenStack(pp);
+
+    CBotExprUnaire* inst = new CBotExprUnaire();
+    inst->SetToken(pp);
+
+    if (NULL != (inst->m_Expr = CBotParExpr::Compile( p, pStk )))
+    {
+        if (op == ID_ADD && pStk->GivType() < CBotTypBoolean)        // only with the number
+            return pStack->Return(inst, pStk);
+        if (op == ID_SUB && pStk->GivType() < CBotTypBoolean)        // only with the numer
+            return pStack->Return(inst, pStk);
+        if (op == ID_NOT && pStk->GivType() < CBotTypFloat)        // only with an integer
+            return pStack->Return(inst, pStk);
+        if (op == ID_LOG_NOT && pStk->GivTypResult().Eq(CBotTypBoolean))// only with boolean
+            return pStack->Return(inst, pStk);
+        if (op == ID_TXT_NOT && pStk->GivTypResult().Eq(CBotTypBoolean))// only with boolean
+            return pStack->Return(inst, pStk);
+
+        pStk->SetError(TX_BADTYPE, &inst->m_token);
+    }
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// executes unary expression
+
+bool CBotExprUnaire::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->GivState() == 0)
+    {
+        if (!m_Expr->Execute(pile)) return false;                    // interrupted ?
+        pile->IncState();
+    }
+
+    CBotStack* pile2 = pile->AddStack();
+    if (pile2->IfStep()) return false;
+
+    CBotVar*    var = pile->GivVar();                                // get the result on the stack
+
+    switch (GivTokenType())
+    {
+    case ID_ADD:
+        break;
+    case ID_SUB:
+        var->Neg();                                                  // change the sign
+        break;
+    case ID_NOT:
+    case ID_LOG_NOT:
+    case ID_TXT_NOT:
+        var->Not();
+        break;
+    }
+    return pj->Return(pile);                                        // forwards below
+}
+
+void CBotExprUnaire::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*    pile = pj->RestoreStack(this);
+    if ( pile == NULL) return;
+
+    if (pile->GivState() == 0)
+    {
+        m_Expr->RestoreState(pile, bMain);                        // interrupted here!
+        return;
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// index management for arrays
+// array [ expression ]
+
+
+CBotIndexExpr::CBotIndexExpr()
+{
+    m_expr    = NULL;
+    name    = "CBotIndexExpr";
+}
+
+CBotIndexExpr::~CBotIndexExpr()
+{
+    delete    m_expr;
+}
+
+// finds a field from the instance at compile time
+
+bool CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
+{
+    if (pVar->GivType(1) != CBotTypArrayPointer)
+        ASM_TRAP();
+
+    pVar = ((CBotVarArray*)pVar)->GivItem(0, false);    // at compile time makes the element [0]
+    if (pVar == NULL)
+    {
+        pile->SetError(TX_OUTARRAY, m_token.GivEnd());
+        return false;
+    }
+    if (m_next3 != NULL) return m_next3->ExecuteVar(pVar, pile);
+    return true;
+}
+
+// attention, changes the pointer to the stack intentionally
+// place the index calculated on the additional stack
+
+
+bool CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend)
+{
+    CBotStack*    pj = pile;
+
+    if (pVar->GivType(1) != CBotTypArrayPointer)
+        ASM_TRAP();
+
+    pile = pile->AddStack();
+
+    if (pile->GivState() == 0)
+    {
+        if (!m_expr->Execute(pile)) return false;
+        pile->IncState();
+    }
+    // handles array
+
+    CBotVar* p = pile->GivVar();    // result on the stack
+
+    if (p == NULL || p->GivType() > CBotTypDouble)
+    {
+        pile->SetError(TX_BADINDEX, prevToken);
+        return pj->Return(pile);
+    }
+
+    int n = p->GivValInt();     // position in the table
+
+    pVar = ((CBotVarArray*)pVar)->GivItem(n, bExtend);
+    if (pVar == NULL)
+    {
+        pile->SetError(TX_OUTARRAY, prevToken);
+        return pj->Return(pile);
+    }
+
+    pVar->Maj(pile->GivPUser(), true);
+
+    if ( m_next3 != NULL && 
+         !m_next3->ExecuteVar(pVar, pile, prevToken, bStep, bExtend) ) return false;
+
+    // does not release the stack
+    // to avoid recalculation of the index twice where appropriate
+    return true;
+}
+
+void CBotIndexExpr::RestoreStateVar(CBotStack* &pile, bool bMain)
+{
+    pile = pile->RestoreStack();
+    if (pile == NULL) return;
+
+    if (bMain && pile->GivState() == 0)
+    {
+        m_expr->RestoreState(pile, true);
+        return;
+    }
+
+    if (m_next3) 
+         m_next3->RestoreStateVar(pile, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// field management in an instance (dot operator)
+// toto.x
+
+
+CBotFieldExpr::CBotFieldExpr()
+{
+    name        = "CBotFieldExpr";
+    m_nIdent    = 0;
+}
+
+CBotFieldExpr::~CBotFieldExpr()
+{
+}
+
+void CBotFieldExpr::SetUniqNum(int num)
+{
+    m_nIdent = num;
+}
+
+
+// find a field from the instance at compile
+
+bool CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
+{
+    if (pVar->GivType(1) != CBotTypPointer)
+        ASM_TRAP();
+
+    pVar = pVar->GivItemRef(m_nIdent);
+    if (pVar == NULL)
+    {
+        pile->SetError(TX_NOITEM, &m_token);
+        return false;
+    }
+
+    if ( m_next3 != NULL &&
+         !m_next3->ExecuteVar(pVar, pile) ) return false;
+
+    return true;
+}
+
+bool CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend)
+{
+    CBotStack*    pj = pile;
+    pile = pile->AddStack(this);    // changes in output stack
+    if (pile == EOX) return true;
+
+
+    if (pVar->GivType(1) != CBotTypPointer)
+        ASM_TRAP();
+
+    CBotVarClass* pItem = pVar->GivPointer();
+    if (pItem == NULL)
+    {
+        pile->SetError(TX_NULLPT, prevToken);
+        return pj->Return(pile);
+    }
+    if (pItem->GivUserPtr() == OBJECTDELETED)
+    {
+        pile->SetError(TX_DELETEDPT, prevToken);
+        return pj->Return(pile);
+    }
+
+    if (bStep && pile->IfStep()) return false;
+
+    pVar = pVar->GivItemRef(m_nIdent);
+    if (pVar == NULL)
+    {
+        pile->SetError(TX_NOITEM, &m_token);
+        return pj->Return(pile);
+    }
+
+    if (pVar->IsStatic())
+    {
+        // for a static variable, takes it in the class itself
+        CBotClass* pClass = pItem->GivClass();
+        pVar = pClass->GivItem(m_token.GivString());
+    }
+
+    // request the update of the element, if applicable
+    pVar->Maj(pile->GivPUser(), true);
+
+    if ( m_next3 != NULL && 
+         !m_next3->ExecuteVar(pVar, pile, &m_token, bStep, bExtend) ) return false;
+
+    // does not release the stack
+    // to maintain the state SetState () corresponding to step
+
+    return true;
+}
+
+void CBotFieldExpr::RestoreStateVar(CBotStack* &pj, bool bMain)
+{
+    pj = pj->RestoreStack(this);
+    if (pj == NULL) return;
+
+    if (m_next3 != NULL) 
+         m_next3->RestoreStateVar(pj, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a left operand for an assignment
+CBotLeftExpr::CBotLeftExpr()
+{
+    name    = "CBotLeftExpr";
+    m_nIdent = 0;
+}
+
+CBotLeftExpr::~CBotLeftExpr()
+{
+}
+
+// compiles an expression for a left-operand (left of an assignment)
+// this can be
+// toto
+// toto[ 3 ]
+// toto.x
+// toto.pos.x
+// toto[2].pos.x
+// toto[1].pos[2].x
+// toto[1][2][3]
+
+CBotLeftExpr* CBotLeftExpr::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->TokenStack();
+
+    pStk->SetStartError(p->GivStart());
+
+    // is it a variable name?
+    if (p->GivType() == TokenTypVar)
+    {
+        CBotLeftExpr* inst = new CBotLeftExpr();    // creates the object
+
+        inst->SetToken(p);
+
+        CBotVar*     var;
+
+        if (NULL != (var = pStk->FindVar(p)))   // seek if known variable
+        {
+            inst->m_nIdent = var->GivUniqNum();
+            if (inst->m_nIdent > 0 && inst->m_nIdent < 9000)
+            {
+                if ( var->IsPrivate(PR_READ) &&
+                     !pStk->GivBotCall()->m_bCompileClass)
+                {
+                    pStk->SetError(TX_PRIVATE, p);
+                    goto err;
+                }
+                // this is an element of the current class
+                // adds the equivalent of this. before
+                CBotToken pthis("this");
+                inst->SetToken(&pthis);
+                inst->m_nIdent = -2;    // indent for this
+
+                CBotFieldExpr* i = new CBotFieldExpr();     // new element
+                i->SetToken(p);     // keeps the name of the token
+                inst->AddNext3(i);  // add after
+
+                var = pStk->FindVar(pthis);
+                var = var->GivItem(p->GivString());
+                i->SetUniqNum(var->GivUniqNum());
+            }
+            p = p->GivNext();   // next token
+
+            while (true)
+            {
+                if (var->GivType() == CBotTypArrayPointer)
+                {
+                    if (IsOfType( p, ID_OPBRK ))
+                    {
+                        CBotIndexExpr* i = new CBotIndexExpr();
+                        i->m_expr = CBotExpression::Compile(p, pStk);
+                        inst->AddNext3(i);  // add to the chain
+
+                        var = ((CBotVarArray*)var)->GivItem(0,true);    // gets the component [0]
+
+                        if (i->m_expr == NULL)
+                        {
+                            pStk->SetError(TX_BADINDEX, p->GivStart());
+                            goto err;
+                        }
+
+                        if (!pStk->IsOk() || !IsOfType( p, ID_CLBRK ))
+                        {
+                            pStk->SetError(TX_CLBRK, p->GivStart());
+                            goto err;
+                        }
+                        continue;
+                    }
+                }
+
+                if (var->GivType(1) == CBotTypPointer)                // for classes
+                {
+                    if (IsOfType(p, ID_DOT))
+                    {
+                        CBotToken* pp = p;
+
+                        CBotFieldExpr* i = new CBotFieldExpr();            // new element
+                        i->SetToken(pp);                                // keeps the name of the token
+                        inst->AddNext3(i);                                // adds after
+
+                        if (p->GivType() == TokenTypVar)                // must be a name
+                        {
+                            var = var->GivItem(p->GivString());            // get item correspondent
+                            if (var != NULL)
+                            {
+                                if ( var->IsPrivate(PR_READ) &&
+                                     !pStk->GivBotCall()->m_bCompileClass)
+                                {
+                                    pStk->SetError(TX_PRIVATE, pp);
+                                    goto err;
+                                }
+
+                                i->SetUniqNum(var->GivUniqNum());
+                                p = p->GivNext();                        // skips the name
+                                continue;
+                            }
+                            pStk->SetError(TX_NOITEM, p);
+                        }
+                        pStk->SetError(TX_DOT, p->GivStart());
+                        goto err;
+                    }
+                }
+                break;
+            }
+
+
+            if (pStk->IsOk()) return (CBotLeftExpr*) pStack->Return(inst, pStk);
+        }
+        pStk->SetError(TX_UNDEFVAR, p);
+err:
+        delete inst;
+        return (CBotLeftExpr*) pStack->Return(NULL, pStk);
+    }
+
+    return (CBotLeftExpr*) pStack->Return(NULL, pStk);
+}
+
+// runs, is a variable and assigns the result to the stack
+bool CBotLeftExpr::Execute(CBotStack* &pj, CBotStack* array)
+{
+    CBotStack*    pile = pj->AddStack();
+
+    CBotVar*     var1 = NULL;
+    CBotVar*     var2 = NULL;
+    // fetch a variable (not copy)
+    if (!ExecuteVar(var1, array, NULL, false)) return false;
+
+    if (pile->IfStep()) return false;
+
+    if (var1)
+    {
+        var2 = pj->GivVar();    // result on the input stack
+        if (var2)
+        {
+            CBotTypResult t1 = var1->GivTypResult();
+            CBotTypResult t2 = var2->GivTypResult();
+            if (t2.Eq(CBotTypPointer))
+            {
+                CBotClass*    c1 = t1.GivClass();
+                CBotClass*    c2 = t2.GivClass();
+                if ( !c2->IsChildOf(c1))
+                {
+                    CBotToken* pt = &m_token;
+                    pile->SetError(TX_BADTYPE, pt);
+                    return pj->Return(pile);    // operation performed
+                }
+            }
+            var1->SetVal(var2);     // do assignment
+        }
+        pile->SetCopyVar(var1);     // replace the stack with the copy of the variable
+                                    // (for name)
+    }
+
+    return pj->Return(pile);    // operation performed
+}
+
+// fetch a variable during compilation
+
+bool CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotCStack* &pile)
+{
+    pVar = pile->FindVar(m_token);
+    if (pVar == NULL) return false;
+
+    if ( m_next3 != NULL &&
+         !m_next3->ExecuteVar(pVar, pile) ) return false;
+
+    return true;
+}
+
+// fetch the variable at runtume
+
+bool CBotLeftExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep)
+{
+    pile = pile->AddStack(this);
+
+    pVar = pile->FindVar(m_nIdent);
+    if (pVar == NULL)
+    {
+#ifdef    _DEBUG
+        ASM_TRAP();
+#endif
+        pile->SetError(2, &m_token);
+        return false;
+    }
+
+    if (bStep && m_next3 == NULL && pile->IfStep()) return false;
+
+    if ( m_next3 != NULL && 
+         !m_next3->ExecuteVar(pVar, pile, &m_token, bStep, true) ) return false;
+
+    return true;
+}
+
+void CBotLeftExpr::RestoreStateVar(CBotStack* &pile, bool bMain)
+{
+    pile = pile->RestoreStack(this);
+    if (pile == NULL) return;
+
+    if (m_next3 != NULL) 
+         m_next3->RestoreStateVar(pile, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// converts a string into integer
+// may be of the form 0xabc123
+
+long GivNumInt(const char* p)
+{
+    long    num = 0;
+    while (*p >= '0' && *p <= '9')
+    {
+        num = num * 10 + *p - '0';
+        p++;
+    }
+    if (*p == 'x' || *p == 'X')
+    {
+        while (*++p != 0)
+        {
+            if (*p >= '0' && *p <= '9')
+            {
+                num = num * 16 + *p - '0';
+                continue;
+            }
+            if (*p >= 'A' && *p <= 'F')
+            {
+                num = num * 16 + *p - 'A' + 10;
+                continue;
+            }
+            if (*p >= 'a' && *p <= 'f')
+            {
+                num = num * 16 + *p - 'a' + 10;
+                continue;
+            }
+            break;
+        }
+    }
+    return num;
+}
+
+// converts a string into a float number
+extern float GivNumFloat(const char* p)
+{
+    double    num = 0;
+    double    div    = 10;
+    bool    bNeg = false;
+
+    if (*p == '-')
+    {
+        bNeg = true;
+        p++;
+    }
+    while (*p >= '0' && *p <= '9')
+    {
+        num = num * 10. + (*p - '0');
+        p++;
+    }
+
+    if (*p == '.')
+    {
+        p++;
+        while (*p >= '0' && *p <= '9')
+        {
+            num = num + (*p - '0') / div;
+            div = div * 10;
+            p++;
+        }
+    }
+
+    int    exp = 0;
+    if (*p == 'e' || *p == 'E')
+    {
+        char neg = 0;
+        p++;
+        if (*p == '-' || *p == '+') neg = *p++;
+
+        while (*p >= '0' && *p <= '9')
+        {
+            exp = exp * 10 + (*p - '0');
+            p++;
+        }
+        if (neg == '-') exp = -exp;
+    }
+
+    while (exp > 0)
+    {
+        num *= 10.0;
+        exp--;
+    }
+
+    while (exp < 0)
+    {
+        num /= 10.0;
+        exp++;
+    }
+
+    if (bNeg) num = -num;
+    return (float)num;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compiles a token representing a number
+CBotExprNum::CBotExprNum()
+{
+    name    = "CBotExprNum";
+}
+
+CBotExprNum::~CBotExprNum()
+{
+}
+
+CBotInstr* CBotExprNum::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->TokenStack();
+
+    CBotExprNum* inst = new CBotExprNum();
+
+    inst->SetToken(p);
+    CBotString    s = p->GivString();
+
+    inst->m_numtype = CBotTypInt;
+    if (p->GivType() == TokenTypDef)
+    {
+        inst->m_valint = p->GivIdKey();
+    }
+    else
+    {
+        if (s.Find('.') >= 0 || ( s.Find('x') < 0 && ( s.Find('e') >= 0 || s.Find('E') >= 0 ) ))
+        {
+            inst->m_numtype = CBotTypFloat;
+            inst->m_valfloat = GivNumFloat(s);
+        }
+        else
+        {
+            inst->m_valint = GivNumInt(s);
+        }
+    }
+
+    if (pStk->NextToken(p))
+    {
+        CBotVar*    var = CBotVar::Create((CBotToken*)NULL, inst->m_numtype);
+        pStk->SetVar(var);
+
+        return pStack->Return(inst, pStk);
+    }
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// execute, returns the corresponding number
+
+bool CBotExprNum::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, m_numtype);
+
+    CBotString    nombre ;
+    if (m_token.GivType() == TokenTypDef)
+    {
+        nombre = m_token.GivString();
+    }
+
+    switch (m_numtype)
+    {
+    case CBotTypShort:
+    case CBotTypInt:
+        var->SetValInt(m_valint, nombre);
+        break;
+    case CBotTypFloat:
+        var->SetValFloat(m_valfloat);
+        break;
+    }
+    pile->SetVar(var);                            // place on the stack
+
+    return pj->Return(pile);                        // it's ok
+}
+
+void CBotExprNum::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain) pj->RestoreStack(this);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a token representing a string
+
+CBotExprAlpha::CBotExprAlpha()
+{
+    name    = "CBotExprAlpha";
+}
+
+CBotExprAlpha::~CBotExprAlpha()
+{
+}
+
+CBotInstr* CBotExprAlpha::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->TokenStack();
+
+    CBotExprAlpha* inst = new CBotExprAlpha();
+
+    inst->SetToken(p);
+    p = p->GivNext();
+
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypString);
+    pStk->SetVar(var);
+
+    return pStack->Return(inst, pStk);
+}
+
+// execute, returns the corresponding string
+
+bool CBotExprAlpha::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypString);
+
+    CBotString    chaine = m_token.GivString();
+    chaine = chaine.Mid(1, chaine.GivLength()-2);    // removes the quotes
+
+    var->SetValString(chaine);                    // value of the number
+
+    pile->SetVar(var);                            // put on the stack
+
+    return pj->Return(pile);
+}
+
+void CBotExprAlpha::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain) pj->RestoreStack(this);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a token representing true or false
+
+CBotExprBool::CBotExprBool()
+{
+    name = "CBotExprBool";
+}
+
+CBotExprBool::~CBotExprBool()
+{
+}
+
+CBotInstr* CBotExprBool::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->TokenStack();
+    CBotExprBool* inst = NULL;
+
+    if ( p->GivType() == ID_TRUE ||
+         p->GivType() == ID_FALSE )
+    {
+        inst = new CBotExprBool();
+        inst->SetToken(p);  // stores the operation false or true
+        p = p->GivNext();
+
+        CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
+        pStk->SetVar(var);
+    }
+
+    return pStack->Return(inst, pStk);
+}
+
+// executes, returns true or false
+
+bool CBotExprBool::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
+
+    if (GivTokenType() == ID_TRUE)      var->SetValInt(1);
+    else                              var->SetValInt(0);
+
+    pile->SetVar(var);  // put on the stack
+    return pj->Return(pile);    // forwards below
+}
+
+void CBotExprBool::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain) pj->RestoreStack(this);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// management of the operand "null"
+
+CBotExprNull::CBotExprNull()
+{
+    name = "CBotExprNull";
+}
+
+CBotExprNull::~CBotExprNull()
+{
+}
+
+// executes, returns an empty pointer
+
+bool CBotExprNull::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypNullPointer);
+
+    var->SetInit(true);         // null pointer valid
+    pile->SetVar(var);          // place on the stack
+    return pj->Return(pile);    // forwards below
+}
+
+void CBotExprNull::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain) pj->RestoreStack(this);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// management of the operand "nan"
+
+CBotExprNan::CBotExprNan()
+{
+    name = "CBotExprNan";
+}
+
+CBotExprNan::~CBotExprNan()
+{
+}
+
+// executes, returns null pointer
+
+bool CBotExprNan::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);
+
+    if (pile->IfStep()) return false;
+    CBotVar*    var = CBotVar::Create((CBotToken*)NULL, CBotTypInt);
+
+    var->SetInit(IS_NAN);       // nan
+    pile->SetVar(var);          // put on the stack
+    return pj->Return(pile);    // forward below
+}
+
+void CBotExprNan::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (bMain) pj->RestoreStack(this);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a variable name
+// check that it is known on the stack
+// and it has been initialized
+
+CBotExprVar::CBotExprVar()
+{
+    name    = "CBotExprVar";
+    m_nIdent = 0;
+}
+
+CBotExprVar::~CBotExprVar()
+{
+}
+
+CBotInstr* CBotExprVar::Compile(CBotToken* &p, CBotCStack* pStack, int privat)
+{
+    CBotToken*    pDebut = p;
+    CBotCStack* pStk = pStack->TokenStack();
+
+    pStk->SetStartError(p->GivStart());
+
+    // is it a variable?
+    if (p->GivType() == TokenTypVar)
+    {
+        CBotInstr* inst = new CBotExprVar();    // create the object
+
+        inst->SetToken(p);
+
+        CBotVar*     var;
+
+        if (NULL != (var = pStk->FindVar(p)))   // seek if known variable
+        {
+            int        ident = var->GivUniqNum();
+            ((CBotExprVar*)inst)->m_nIdent = ident;     // identifies variable by its number
+
+            if (ident > 0 && ident < 9000)
+            {
+                if ( var->IsPrivate(privat) &&
+                     !pStk->GivBotCall()->m_bCompileClass)
+                {
+                    pStk->SetError(TX_PRIVATE, p);
+                    goto err;
+                }
+
+                // This is an element of the current class
+                // ads the equivalent of this. before
+                /// \TODO need to be fixed revised and fixed after adding unit
+                ///tests
+                CBotToken token("this");
+                inst->SetToken(&token);
+                ((CBotExprVar*)inst)->m_nIdent = -2;    // identificator for this
+
+                CBotFieldExpr* i = new CBotFieldExpr();     // new element
+                i->SetToken(p);     // keeps the name of the token
+                i->SetUniqNum(ident);
+                inst->AddNext3(i);  // added after
+            }
+
+            p = p->GivNext();   // next token
+
+            while (true)
+            {
+                if (var->GivType() == CBotTypArrayPointer)
+                {
+                    if (IsOfType( p, ID_OPBRK ))    // check if there is an aindex 
+                    {
+                        CBotIndexExpr* i = new CBotIndexExpr();
+                        i->m_expr = CBotExpression::Compile(p, pStk);   // compile the formula
+                        inst->AddNext3(i);  // add to the chain
+
+                        var = ((CBotVarArray*)var)->GivItem(0,true);    // gets the component [0]
+
+                        if (i->m_expr == NULL)
+                        {
+                            pStk->SetError(TX_BADINDEX, p->GivStart());
+                            goto err;
+                        }
+                        if (!pStk->IsOk() || !IsOfType( p, ID_CLBRK ))
+                        {
+                            pStk->SetError(TX_CLBRK, p->GivStart());
+                            goto err;
+                        }
+                        continue;
+                    }
+                }
+                if (var->GivType(1) == CBotTypPointer)  // for classes
+                {
+                    if (IsOfType(p, ID_DOT))
+                    {
+                        CBotToken* pp = p;
+
+                        if (p->GivType() == TokenTypVar)    // must be a name
+                        {
+                            if (p->GivNext()->GivType() == ID_OPENPAR)  // a method call?
+                            {
+                                CBotInstr* i = CBotInstrMethode::Compile(p, pStk, var);
+                                if (!pStk->IsOk()) goto err;
+                                inst->AddNext3(i);  // added after
+                                return pStack->Return(inst, pStk);
+                            }
+                            else
+                            {
+                                CBotFieldExpr* i = new CBotFieldExpr();     // new element
+                                i->SetToken(pp);                            // keeps the name of the token
+                                inst->AddNext3(i);                          // add after
+                                var = var->GivItem(p->GivString());         // get item correspondent
+                                if (var != NULL)
+                                {
+                                    i->SetUniqNum(var->GivUniqNum());
+                                    if ( var->IsPrivate() &&
+                                     !pStk->GivBotCall()->m_bCompileClass)
+                                    {
+                                        pStk->SetError(TX_PRIVATE, pp);
+                                        goto err;
+                                    }
+                                }
+                            }
+
+
+                            if (var != NULL)
+                            {
+                                p = p->GivNext();   // skips the name
+                                continue;
+                            }
+                            pStk->SetError(TX_NOITEM, p);
+                            goto err;
+                        }
+                        pStk->SetError(TX_DOT, p->GivStart());
+                        goto err;
+                    }
+                }
+
+                break;
+            }
+
+            pStk->SetCopyVar(var);  // place the copy of the variable on the stack (for type)
+            if (pStk->IsOk()) return pStack->Return(inst, pStk);
+        }
+        pStk->SetError(TX_UNDEFVAR, p);
+err:
+        delete inst;
+        return pStack->Return(NULL, pStk);
+    }
+
+    return pStack->Return(NULL, pStk);
+}
+
+CBotInstr* CBotExprVar::CompileMethode(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*    pp = p;
+    CBotCStack* pStk = pStack->TokenStack();
+
+    pStk->SetStartError(pp->GivStart());
+
+    // is it a variable ?
+    if (pp->GivType() == TokenTypVar)
+    {
+        CBotToken pthis("this");
+        CBotVar*     var = pStk->FindVar(pthis);
+        if (var == 0) return pStack->Return(NULL, pStk);
+
+        CBotInstr* inst = new CBotExprVar();
+
+        // this is an element of the current class
+        // adds the equivalent of this. before
+
+        inst->SetToken(&pthis);
+        ((CBotExprVar*)inst)->m_nIdent = -2;    // ident for this
+
+        CBotToken* pp = p;
+
+        if (pp->GivType() == TokenTypVar)
+        {
+            if (pp->GivNext()->GivType() == ID_OPENPAR)        // a method call?
+            {
+                CBotInstr* i = CBotInstrMethode::Compile(pp, pStk, var);
+                if (pStk->IsOk())
+                {
+                    inst->AddNext3(i);                            // add after
+                    p = pp;                                        // previous instruction
+                    return pStack->Return(inst, pStk);
+                }
+                pStk->SetError(0,0);                            // the error is not adressed here
+            }
+        }
+        delete inst;
+    }
+    return pStack->Return(NULL, pStk);
+}
+
+
+// execute, making the value of a variable
+
+bool CBotExprVar::Execute(CBotStack* &pj)
+{
+    CBotVar*     pVar = NULL;
+    CBotStack*     pile  = pj->AddStack(this);
+
+    CBotStack*     pile1 = pile;
+
+    if (pile1->GivState() == 0)
+    {
+        if (!ExecuteVar(pVar, pile, NULL, true)) return false;        // Get the variable fields and indexes according
+
+        if (pVar) pile1->SetCopyVar(pVar);                            // place a copy on the stack
+        else
+        {
+            return pj->Return(pile1);
+        }
+        pile1->IncState();
+    }
+
+    pVar = pile1->GivVar();
+
+    if (pVar == NULL)
+    {
+        return pj->Return(pile1);
+    }
+
+    if (pVar->GivInit() == IS_UNDEF)
+    {
+        CBotToken* pt = &m_token;
+        while (pt->GivNext() != NULL) pt = pt->GivNext();
+        pile1->SetError(TX_NOTINIT, pt);
+        return pj->Return(pile1);
+    }
+    return pj->Return(pile1);   // operation completed
+}
+
+void CBotExprVar::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*     pile  = pj->RestoreStack(this);
+    if (pile == NULL) return;
+
+    CBotStack*     pile1 = pile;
+
+    if (pile1->GivState() == 0)
+    {
+        RestoreStateVar(pile, bMain);   // retrieves the variable fields and indexes according
+        return;
+    }
+}
+
+// fetch a variable at runtime
+
+bool CBotExprVar::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, bool bStep)
+{
+    CBotStack*    pile = pj;
+    pj = pj->AddStack(this);
+
+    if (bStep && m_nIdent>0 && pj->IfStep()) return false;
+
+    pVar = pj->FindVar(m_nIdent, true);     // tries with the variable update if necessary
+    if (pVar == NULL)
+    {
+#ifdef    _DEBUG
+        ASM_TRAP();
+#endif
+        pj->SetError(1, &m_token);
+        return false;
+    }
+    if ( m_next3 != NULL &&
+         !m_next3->ExecuteVar(pVar, pj, &m_token, bStep, false) )
+            return false;   // field of an instance, table, methode
+
+    return pile->ReturnKeep(pj);    // does not put on stack but get the result if a method was called
+}
+
+
+// fetch variable at runtime
+
+void CBotExprVar::RestoreStateVar(CBotStack* &pj, bool bMain)
+{
+    pj = pj->RestoreStack(this);
+    if (pj == NULL) return;
+
+    if (m_next3 != NULL)
+         m_next3->RestoreStateVar(pj, bMain);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+// compile a list of parameters
+
+CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars)
+{
+    bool        first = true;
+    CBotInstr*    ret = NULL;   // to return to the list
+
+    CBotCStack*    pile = pStack;
+    int            i = 0;
+
+    if (IsOfType(p, ID_OPENPAR))
+    {
+        int    start, end;
+        if (!IsOfType(p, ID_CLOSEPAR)) while (true)
+        {
+            start = p->GivStart();
+            pile = pile->TokenStack();  // keeps the result on the stack
+
+            if (first) pStack->SetStartError(start);
+            first = false;
+
+            CBotInstr*    param = CBotExpression::Compile(p, pile);
+            end      = p->GivStart();
+
+            if (!pile->IsOk())
+            {
+                return pStack->Return(NULL, pile);
+            }
+
+            if (ret == NULL) ret = param;
+            else ret->AddNext(param);   // construct the list
+
+            if (param != NULL)
+            {
+                if (pile->GivTypResult().Eq(99))
+                {
+                    delete pStack->TokenStack();
+                    pStack->SetError(TX_VOID, p->GivStart());
+                    return NULL;
+                }
+                ppVars[i] = pile->GivVar();
+                ppVars[i]->GivToken()->SetPos(start, end);
+                i++;
+
+                if (IsOfType(p, ID_COMMA)) continue;    // skips the comma
+                if (IsOfType(p, ID_CLOSEPAR)) break;
+            }
+
+            pStack->SetError(TX_CLOSEPAR, p->GivStart());
+            delete pStack->TokenStack();
+            return NULL;
+        }
+    }
+    ppVars[i] = NULL;
+    return    ret;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compile a method call
+
+CBotInstrMethode::CBotInstrMethode()
+{
+    m_Parameters    = NULL;
+    m_MethodeIdent  = 0;
+    name = "CBotInstrMethode";
+}
+
+CBotInstrMethode::~CBotInstrMethode()
+{
+    delete    m_Parameters;
+}
+
+CBotInstr* CBotInstrMethode::Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* var)
+{
+    CBotInstrMethode* inst = new CBotInstrMethode();
+    inst->SetToken(p);  // corresponding token
+
+    if (NULL != var)
+    {
+        CBotToken*    pp = p;
+        p = p->GivNext();
+
+        if (p->GivType() == ID_OPENPAR)
+        {
+            inst->m_NomMethod = pp->GivString();
+
+            // compiles the list of parameters
+            CBotVar*    ppVars[1000];
+            inst->m_Parameters = CompileParams(p, pStack, ppVars);
+
+            if (pStack->IsOk())
+            {
+                CBotClass* pClass = var->GivClass();    // pointer to the class
+                inst->m_ClassName = pClass->GivName();  // name of the class
+                CBotTypResult r = pClass->CompileMethode(inst->m_NomMethod, var, ppVars, 
+                                                         pStack, inst->m_MethodeIdent);
+                delete pStack->TokenStack();    // release parameters on the stack
+                inst->m_typRes = r;
+
+                if (inst->m_typRes.GivType() > 20)
+                {
+                    pStack->SetError(inst->m_typRes.GivType(), pp);
+                    delete    inst;
+                    return    NULL;
+                }
+                // put the result on the stack to have something
+                if (inst->m_typRes.GivType() > 0)
+                {
+                    CBotVar*    pResult = CBotVar::Create("", inst->m_typRes);
+                    if (inst->m_typRes.Eq(CBotTypClass))
+                    {
+                        pResult->SetClass(inst->m_typRes.GivClass());
+                    }
+                    pStack->SetVar(pResult);
+                }
+                return inst;
+            }
+            delete inst;
+            return NULL;
+        }
+    }
+    pStack->SetError(1234, p);
+    delete inst;
+    return NULL;
+}
+
+// execute the method call
+
+bool CBotInstrMethode::ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, bool bStep, bool bExtend)
+{
+    CBotVar*    ppVars[1000];
+    CBotStack*    pile1 = pj->AddStack(this, true);     // a place for the copy of This
+
+    if (pVar->GivPointer() == NULL)
+    {
+        pj->SetError(TX_NULLPT, prevToken);
+    }
+
+    if (pile1->IfStep()) return false;
+
+    CBotStack*    pile2 = pile1->AddStack();    // for the next parameters
+
+    if ( pile1->GivState() == 0)
+    {
+        CBotVar*    pThis = CBotVar::Create(pVar);
+        pThis->Copy(pVar);
+        // this value should be taken before the evaluation parameters
+        // Test.Action (Test = Other);
+        // action must act on the value before test = Other!
+
+        pThis->SetName("this");
+        pThis->SetUniqNum(-2);
+        pile1->AddVar(pThis);
+        pile1->IncState();
+    }
+    int        i = 0;
+
+    CBotInstr*    p = m_Parameters;
+    // evaluate the parameters
+    // and places the values on the stack
+    // to be interrupted at any time
+
+    if (p != NULL) while ( true)
+    {
+        if (pile2->GivState() == 0)
+        {
+            if (!p->Execute(pile2)) return false;   // interrupted here?
+            if (!pile2->SetState(1)) return false;  // special mark to recognize parameters
+        }
+        ppVars[i++] = pile2->GivVar();              // construct the list of pointers
+        pile2 = pile2->AddStack();                  // space on the stack for the result
+        p = p->GivNext();
+        if ( p == NULL) break;
+    }
+    ppVars[i] = NULL;
+
+    CBotClass*    pClass = CBotClass::Find(m_ClassName);
+    CBotVar*    pThis  = pile1->FindVar(-2);
+    CBotVar*    pResult = NULL;
+    if (m_typRes.GivType() > 0) pResult = CBotVar::Create("", m_typRes);
+    if (m_typRes.Eq(CBotTypClass))
+    {
+        pResult->SetClass(m_typRes.GivClass());
+    }
+    CBotVar*    pRes = pResult;
+
+    if ( !pClass->ExecuteMethode(m_MethodeIdent, m_NomMethod, 
+                                 pThis, ppVars, 
+                                 pResult, pile2, GivToken())) return false;
+    if (pRes != pResult) delete pRes;
+
+    pVar = NULL;                // does not return value for this
+    return pj->Return(pile2);   // release the entire stack
+}
+
+void CBotInstrMethode::RestoreStateVar(CBotStack* &pile, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotVar*    ppVars[1000];
+    CBotStack*    pile1 = pile->RestoreStack(this);     // place for the copy of This
+    if (pile1 == NULL) return;
+
+    CBotStack*    pile2 = pile1->RestoreStack();        // and for the parameters coming
+    if (pile2 == NULL) return;
+
+    CBotVar*    pThis  = pile1->FindVar("this");
+    pThis->SetUniqNum(-2);
+
+    int        i = 0;
+
+    CBotInstr*    p = m_Parameters;
+    // evaluate the parameters
+    // and places the values on the stack
+    // to be interrupted at any time
+
+    if (p != NULL) while ( true)
+    {
+        if (pile2->GivState() == 0)
+        {
+            p->RestoreState(pile2, true);   // interrupted here!
+            return;
+        }
+        ppVars[i++] = pile2->GivVar();      // construct the list of pointers
+        pile2 = pile2->RestoreStack();
+        if (pile2 == NULL) return;
+
+        p = p->GivNext();
+        if ( p == NULL) break;
+    }
+    ppVars[i] = NULL;
+
+    CBotClass*    pClass = CBotClass::Find(m_ClassName);
+    CBotVar*    pResult = NULL;
+
+    CBotVar*    pRes = pResult;
+
+    pClass->RestoreMethode(m_MethodeIdent, m_NomMethod, 
+                                 pThis, ppVars, pile2);
+}
+
+
+bool CBotInstrMethode::Execute(CBotStack* &pj)
+{
+    CBotVar*    ppVars[1000];
+    CBotStack*    pile1 = pj->AddStack(this, true);        // place for the copy of This
+
+    if (pile1->IfStep()) return false;
+
+    CBotStack*    pile2 = pile1->AddStack();                // and for the parameters coming
+
+    if ( pile1->GivState() == 0)
+    {
+        CBotVar*    pThis = pile1->CopyVar(m_token);
+        // this value should be taken before the evaluation parameters
+        // Test.Action (Test = Other);
+        // Action must act on the value before test = Other!
+        pThis->SetName("this");
+        pile1->AddVar(pThis);
+        pile1->IncState();
+    }
+    int        i = 0;
+
+    CBotInstr*    p = m_Parameters;
+    // evaluate the parameters
+    // and places the values on the stack
+    // to be interrupted at any time
+    if (p != NULL) while ( true)
+    {
+        if (pile2->GivState() == 0)
+        {
+            if (!p->Execute(pile2)) return false;   // interrupted here?
+            if (!pile2->SetState(1)) return false;  // special mark to recognize parameters
+        }
+        ppVars[i++] = pile2->GivVar();              // construct the list of pointers
+        pile2 = pile2->AddStack();                  // space on the stack for the results
+        p = p->GivNext();
+        if ( p == NULL) break;
+    }
+    ppVars[i] = NULL;
+
+    CBotClass*    pClass = CBotClass::Find(m_ClassName);
+    CBotVar*    pThis  = pile1->FindVar("this");
+    CBotVar*    pResult = NULL;
+    if (m_typRes.GivType()>0) pResult = CBotVar::Create("", m_typRes);
+    if (m_typRes.Eq(CBotTypClass))
+    {
+        pResult->SetClass(m_typRes.GivClass());
+    }
+    CBotVar*    pRes = pResult;
+
+    if ( !pClass->ExecuteMethode(m_MethodeIdent, m_NomMethod, 
+                                 pThis, ppVars, 
+                                 pResult, pile2, GivToken())) return false;    // interupted
+
+    // set the new value of this in place of the old variable
+    CBotVar*    old = pile1->FindVar(m_token);
+    old->Copy(pThis, false);
+
+    if (pRes != pResult) delete pRes;
+
+    return pj->Return(pile2);    // release the entire stack
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compile an instruction "new" 
+
+CBotNew::CBotNew()
+{
+    name            = "CBotNew";
+    m_Parameters    = NULL;
+    m_nMethodeIdent = 0;
+}
+
+CBotNew::~CBotNew()
+{
+}
+
+CBotInstr* CBotNew::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken* pp = p;
+    if (!IsOfType(p, ID_NEW)) return NULL;
+
+    // verifies that the token is a class name
+    if (p->GivType() != TokenTypVar) return NULL;
+
+    CBotClass* pClass = CBotClass::Find(p);
+    if (pClass == NULL)
+    {
+        pStack->SetError(TX_BADNEW, p);
+        return NULL;
+    }
+
+    CBotNew* inst = new CBotNew();
+    inst->SetToken(pp);
+
+    inst->m_vartoken = p;
+    p = p->GivNext();
+
+    // creates the object on the "job"
+    // with a pointer to the object
+    CBotVar*    pVar = CBotVar::Create("", pClass);
+
+    // do the call of the creator
+    CBotCStack* pStk = pStack->TokenStack();
+    {
+        // check if there are parameters
+        CBotVar*    ppVars[1000];
+        inst->m_Parameters = CompileParams(p, pStk, ppVars);
+        if (!pStk->IsOk()) goto error;
+
+        // constructor exist?
+        CBotTypResult r = pClass->CompileMethode(pClass->GivName(), pVar, ppVars, pStk, inst->m_nMethodeIdent);
+        delete pStk->TokenStack();  // release extra stack
+        int typ = r.GivType();
+
+        // if there is no constructor, and no parameters either, it's ok
+        if (typ == TX_UNDEFCALL && inst->m_Parameters == NULL) typ = 0;
+        pVar->SetInit(true);    // mark the instance as init
+
+        if (typ>20)
+        {
+            pStk->SetError(typ, inst->m_vartoken.GivEnd());
+            goto error;
+        }
+
+        // if the constructor does not exist, but there are parameters
+        if (typ<0 && inst->m_Parameters != NULL)
+        {
+            pStk->SetError(TX_NOCONST, &inst->m_vartoken);
+            goto error;
+        }
+
+        // makes pointer to the object on the stack
+        pStk->SetVar(pVar);
+        return pStack->Return(inst, pStk);
+    }
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// executes instruction "new"
+
+bool CBotNew::Execute(CBotStack* &pj)
+{
+    CBotStack*    pile = pj->AddStack(this);    //main stack
+
+    if (pile->IfStep()) return false;
+
+    CBotStack*    pile1 = pj->AddStack2();  //secondary stack
+
+    CBotVar*    pThis = NULL;
+
+    CBotToken*    pt = &m_vartoken;
+    CBotClass*    pClass = CBotClass::Find(pt);
+
+    // create the variable "this" pointer type to the stack
+
+    if ( pile->GivState()==0)
+    {
+        // create an instance of the requested class
+        // and initialize the pointer to that object
+
+
+        pThis = CBotVar::Create("this", pClass);
+        pThis->SetUniqNum(-2) ;
+
+        pile1->SetVar(pThis);   // place on stack1
+        pile->IncState();
+    }
+
+    // fetch the this pointer if it was interrupted
+    if ( pThis == NULL)
+    {
+        pThis = pile1->GivVar();    // find the pointer
+    }
+
+    // is there an assignment or parameters (constructor)
+    if ( pile->GivState()==1)
+    {
+        // evaluates the constructor of the instance
+
+        CBotVar*    ppVars[1000];
+        CBotStack*    pile2 = pile;
+
+        int        i = 0;
+
+        CBotInstr*    p = m_Parameters;
+        // evaluate the parameters
+        // and places the values on the stack
+        // to be interrupted at any time
+
+        if (p != NULL) while ( true)
+        {
+            pile2 = pile2->AddStack();  // space on the stack for the result
+            if (pile2->GivState() == 0)
+            {
+                if (!p->Execute(pile2)) return false;   // interrupted here?
+                pile2->SetState(1);
+            }
+            ppVars[i++] = pile2->GivVar();
+            p = p->GivNext();
+            if ( p == NULL) break;
+        }
+        ppVars[i] = NULL;
+
+        // create a variable for the result
+        CBotVar*    pResult = NULL;     // constructos still void
+
+        if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(), 
+                                     pThis, ppVars, 
+                                     pResult, pile2, GivToken())) return false;    // interrupt
+
+        pThis->ConstructorSet();    // indicates that the constructor has been called
+    }
+
+    return pj->Return(pile1);   // passes below
+}
+
+void CBotNew::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if (!bMain) return;
+
+    CBotStack*    pile = pj->RestoreStack(this);    //primary stack
+    if (pile == NULL) return;
+
+    CBotStack*    pile1 = pj->AddStack2();  //secondary stack
+
+    CBotToken*    pt = &m_vartoken;
+    CBotClass*    pClass = CBotClass::Find(pt);
+
+    // create the variable "this" pointer type to the object
+
+    if ( pile->GivState()==0)
+    {
+        return;
+    }
+
+    CBotVar* pThis = pile1->GivVar();   // find the pointer
+    pThis->SetUniqNum(-2);
+
+    // is ther an assignment or parameters (constructor)
+    if ( pile->GivState()==1)
+    {
+        // evaluates the constructor of the instance
+
+        CBotVar*    ppVars[1000];
+        CBotStack*    pile2 = pile;
+
+        int        i = 0;
+
+        CBotInstr*    p = m_Parameters;
+        // evaluate the parameters
+        // and places the values on the stack
+        // to be interrupted at any time
+
+        if (p != NULL) while ( true)
+        {
+            pile2 = pile2->RestoreStack();  // space on the stack for the result
+            if (pile2 == NULL) return;
+
+            if (pile2->GivState() == 0)
+            {
+                p->RestoreState(pile2, bMain);  // interrupt here!
+                return;
+            }
+            ppVars[i++] = pile2->GivVar();
+            p = p->GivNext();
+            if ( p == NULL) break;
+        }
+        ppVars[i] = NULL;
+
+        pClass->RestoreMethode(m_nMethodeIdent, m_vartoken.GivString(), pThis,
+                               ppVars, pile2)    ;        // interrupt here!
+    }
+}
+
+/////////////////////////////////////////////////////////////
+// check if two results are consistent to make an operation
+
+bool TypeCompatible(CBotTypResult& type1, CBotTypResult& type2, int op)
+{
+    int    t1 = type1.GivType();
+    int    t2 = type2.GivType();
+
+    int max = (t1 > t2) ? t1 : t2;
+
+    if (max == 99) return false;    // result is void?
+
+    // special case for strin concatenation
+    if (op == ID_ADD && max >= CBotTypString) return true;
+    if (op == ID_ASSADD && max >= CBotTypString) return true;
+    if (op == ID_ASS && t1 == CBotTypString) return true;
+
+    if (max >= CBotTypBoolean)
+    {
+        if ( (op == ID_EQ || op == ID_NE) && 
+             (t1 == CBotTypPointer && t2 == CBotTypNullPointer)) return true;
+        if ( (op == ID_EQ || op == ID_NE || op == ID_ASS) && 
+             (t2 == CBotTypPointer && t1 == CBotTypNullPointer)) return true;
+        if ( (op == ID_EQ || op == ID_NE) && 
+             (t1 == CBotTypArrayPointer && t2 == CBotTypNullPointer)) return true;
+        if ( (op == ID_EQ || op == ID_NE || op == ID_ASS) && 
+             (t2 == CBotTypArrayPointer && t1 == CBotTypNullPointer)) return true;
+        if (t2 != t1) return false;
+        if (t1 == CBotTypArrayPointer) return type1.Compare(type2);
+        if (t1 == CBotTypPointer ||
+            t1 == CBotTypClass   ||
+            t1 == CBotTypIntrinsic )
+        {
+            CBotClass*    c1 = type1.GivClass();
+            CBotClass*    c2 = type2.GivClass();
+
+            return c1->IsChildOf(c2) || c2->IsChildOf(c1);
+            // accept the case in reverse
+            // the transaction will be denied at runtime if the pointer is not
+            // compatible
+        }
+
+        return true;
+    }
+
+    type1.SetType(max);
+    type2.SetType(max);
+    return true;
+}
+
+// check if two variables are compatible for parameter passing
+
+bool TypesCompatibles(const CBotTypResult& type1, const CBotTypResult& type2)
+{
+    int    t1 = type1.GivType();
+    int    t2 = type2.GivType();
+
+    if (t1 == CBotTypIntrinsic) t1 = CBotTypClass;
+    if (t2 == CBotTypIntrinsic) t2 = CBotTypClass;
+
+    int max = (t1 > t2) ? t1 : t2;
+
+    if (max == 99) return false;                    // result is void?
+
+    if (max >= CBotTypBoolean)
+    {
+        if (t2 != t1) return false;
+
+        if (max == CBotTypArrayPointer)
+            return TypesCompatibles(type1.GivTypElem(), type2.GivTypElem());
+
+        if (max == CBotTypClass || max == CBotTypPointer)
+            return type1.GivClass() == type2.GivClass() ;
+
+        return true ;
+    }
+    return true;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////
+// file management
+
+// necessary because it is not possible to do the fopen in the main program
+// fwrite and fread in a dll or using the FILE * returned.
+
+
+FILE* fOpen(const char* name, const char* mode)
+{
+    return fopen(name, mode);
+}
+
+int fClose(FILE* filehandle)
+{
+    return fclose(filehandle);
+}
+
+size_t fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle)
+{
+    return fwrite(buffer, elemsize, length, filehandle);
+}
+
+size_t fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle)
+{
+    return fread(buffer, elemsize, length, filehandle);
+}
+
+size_t fWrite(const void *buffer, size_t length, FILE* filehandle)
+{
+    return fwrite(buffer, 1, length, filehandle);
+}
+
+size_t fRead(void *buffer, size_t length, FILE* filehandle)
+{
+    return fread(buffer, 1, length, filehandle);
+}
+
+
+////////////////////////////////////////
+
diff --git a/src/CBot/CBot.h b/src/CBot/CBot.h
index e28bbee..ebc8e52 100644
--- a/src/CBot/CBot.h
+++ b/src/CBot/CBot.h
@@ -1,1633 +1,1732 @@
-// * 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  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////

-// interpréteur pour le language CBot du jeu COLOBOT

-

-// dernière révision : 03/10/2002	DD

-

-#define	EXTENDS	TRUE

-

-

-#include "resource.h"

-#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	EOX			(CBotStack*)-1	// marqueur condition spéciale

-

-

-// fix for MSVC instruction __asm int 3 (setting a trap)

-#ifdef __MINGW32__

-#define ASM_TRAP()	asm("int $3");

-#else

-#define ASM_TRAP()	__asm int 3;

-#endif

-

-/////////////////////////////////////////////////////////////////////

-// 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

-					// Toto.truc

-					// 12.5

-					// "chaine"

-					// ( expression )

-class CBotExprVar;	// un nom de variable tel que

-					// Toto

-					// chose.truc.machin

-class CBotWhile;	// while (...) {...};

-class CBotIf;		// if (...) {...} else {...}

-class CBotDefParam;	// liste de paramètres d'une fonction

-class CBotRepeat;	// repeat (nb) {...}

-

-

-

-////////////////////////////////////////////////////////////////////////

-// 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 

-// pour l'utiliser pour la routine CBotProgram::Execute(CBotStack)

-

-class CBotStack

-{

-private:

-    CBotStack*		m_next;

-	CBotStack*		m_next2;

-	CBotStack*		m_prev;

-	friend class CBotInstArray;

-

-#ifdef	_DEBUG 

-	int				m_index;

-#endif

-	int				m_state;

-	int				m_step;

-	static int		m_error;

-	static int		m_start;

-	static int		m_end;

-	static

-	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

-

-	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

-

-	static

-	int				m_initimer;

-	static

-	int				m_timer;

-	static

-	CBotString		m_labelBreak;

-	static

-	void*			m_pUser;

-

-	CBotInstr*		m_instr;					// l'instruction correspondante

-	BOOL			m_bFunc;					// une entrée d'une fonction ?

-	CBotCall*		m_call;						// point de reprise dans un call extern

-	friend class	CBotTry;

-

-public:

-#if	STACKMEM

-	static

-	CBotStack*		FirstStack();

-	void			Delete();

-#endif

-					CBotStack(CBotStack* ppapa);

-					~CBotStack();

-	BOOL			StackOver();

-

-	int				GivError(int& start, int& end);

-	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

-	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

-

-//	void			AddVar(CBotVar* p, BOOL bDontDelete=FALSE);			// ajoute une variable locale

-	void			AddVar(CBotVar* p);									// ajoute une variable locale

-//	void			RestoreVar(CBotVar* pVar);

-

-	CBotVar*		FindVar(CBotToken* &p, BOOL bUpdate = FALSE,

-										   BOOL bModif  = FALSE);		// trouve une variable

-	CBotVar*		FindVar(CBotToken& Token, BOOL bUpdate = FALSE,

-											  BOOL bModif  = FALSE);

-	CBotVar*		FindVar(const char* name);

-	CBotVar*		FindVar(long ident, BOOL bUpdate = FALSE,

-										BOOL bModif  = FALSE);

-

-	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*		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

-	BOOL			BreakReturn(CBotStack* pfils, const char* name = NULL);

-																		// 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			Execute(); 

-

-	void			SetVar( CBotVar* var );

-	void			SetCopyVar( CBotVar* var );

-	CBotVar*		GivVar();

-	CBotVar*		GivCopyVar();

-	CBotVar*		GivPtVar();

-	BOOL			GivRetVar(BOOL bRet);

-	long			GivVal();

-

-	void			SetStartError(int pos);

-	void			SetError(int n, CBotToken* token = NULL);

-	void			SetPosError(CBotToken* token);

-	void			ResetError(int n, int start, int end);

-	void			SetBreak(int val, const char* name);

-

-	void			SetBotCall(CBotProgram* p);

-	CBotProgram*	GivBotCall(BOOL bFirst = FALSE);

-	void*			GivPUser();

-	BOOL			GivBlock();

-

-

-//	BOOL			ExecuteCall(CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);

-	BOOL			ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);

-	void			RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar);

-

-	BOOL			SaveState(FILE* pf);

-	BOOL			RestoreState(FILE* pf, CBotStack* &pStack);

-

-	static

-	void			SetTimer(int n);

-

-	void			GetRunPos(const char* &FunctionName, int &start, int &end);

-	CBotVar*		GivStackVars(const char* &FunctionName, int level);

-

-	int				m_temp;

-};

-

-// les routines inline doivent être déclarées dans le fichier .h

-

-inline BOOL CBotStack::IsOk()

-{

-    return (m_error == 0);

-}

-

-inline int CBotStack::GivState()

-{

-    return m_state;

-}

-

-inline int CBotStack::GivError()

-{

-	return m_error;

-}

-

-////////////////////////////////////////////////////////////////////////

-// Gestion de la pile de compilation

-////////////////////////////////////////////////////////////////////////

-

-

-class CBotCStack

-{

-private:

-    CBotCStack*		m_next;

-	CBotCStack*		m_prev;

-

-	static

-	int				m_error;

-	static

-	int				m_end;

-	int				m_start;

-

-	CBotVar*		m_var;						// résultat des opérations

-

-	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

-	static

-	CBotTypResult	m_retTyp;

-//	static

-//	CBotToken*		m_retClass;

-

-public:

-					CBotCStack(CBotCStack* ppapa);

-					~CBotCStack();

-

-	BOOL			IsOk();

-	int				GivError();

-	int				GivError(int& start, int& end);

-												// rend le numéro d'erreur retourné

-

-	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

-

-	void			AddVar(CBotVar* p);			// ajoute une variable locale

-	CBotVar*		FindVar(CBotToken* &p);		// trouve une variable

-	CBotVar*		FindVar(CBotToken& Token);

-	BOOL			CheckVarLocal(CBotToken* &pToken);

-	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

-	

-	void			SetVar( CBotVar* var );

-	void			SetCopyVar( CBotVar* var );

-	CBotVar*		GivVar();

-

-	void			SetStartError(int pos);

-	void			SetError(int n, int pos);

-	void			SetError(int n, CBotToken* p);

-	void			ResetError(int n, int start, int end);

-

-	void			SetRetType(CBotTypResult& type);

-	CBotTypResult	GivRetType();

-

-//	void			SetBotCall(CBotFunction* &pFunc);

-	void			SetBotCall(CBotProgram* p);

-	CBotProgram*	GivBotCall();

-	CBotTypResult	CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent);

-	BOOL			CheckCall(CBotToken* &pToken, CBotDefParam* pParam);

-

-	BOOL			NextToken(CBotToken* &p);

-};

-

-

-extern BOOL SaveVar(FILE* pf, CBotVar* pVar);

-

-

-/////////////////////////////////////////////////////////////////////

-// classes définissant une instruction

-class CBotInstr

-{

-private:

-	static

-	CBotStringArray

-				m_labelLvl;

-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

-/*

-	par exemple, le programme suivant

-	int		x[]; x[1] = 4;

-	int		y[x[1]][10], z;

-    va généré

-	CBotInstrArray

-	m_next3b-> CBotEmpty

-	m_next->

-	CBotExpression ....

-	m_next->

-	CBotInstrArray

-	m_next3b-> CBotExpression ('x') ( m_next3-> CBotIndexExpr ('1') )

-	m_next3b-> CBotExpression ('10')

-	m_next2-> 'z'

-	m_next->...

-

-*/

-

-	static

-	int				m_LoopLvl;

-	friend class	CBotClassInst;

-	friend class	CBotInt;

-	friend class	CBotListArray;

-

-public:

-				CBotInstr();

-				virtual

-				~CBotInstr();

-

-	DllExport//debug

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	static

-	CBotInstr*	CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypResult type, BOOL first = TRUE);

-

-	virtual

-	BOOL		Execute(CBotStack* &pj);

-	virtual

-	BOOL		Execute(CBotStack* &pj, CBotVar* pVar);

-	virtual

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-

-	virtual

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);

-	virtual

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);

-	virtual

-	void		RestoreStateVar(CBotStack* &pile, BOOL bMain);

-

-	virtual

-	BOOL		CompCase(CBotStack* &pj, int val);

-

-	void		SetToken(CBotToken* p);

-	void		SetToken(CBotString* name, int start=0, int end=0);

-	int			GivTokenType();

-	CBotToken*	GivToken();

-

-	void		AddNext(CBotInstr* n);

-	CBotInstr*	GivNext();

-	void		AddNext3(CBotInstr* n);

-	CBotInstr*	GivNext3();

-	void		AddNext3b(CBotInstr* n);

-	CBotInstr*	GivNext3b();

-

-	static

-	void		IncLvl(CBotString& label);

-	static

-	void		IncLvl();

-	static

-	void		DecLvl();

-	static

-	BOOL		ChkLvl(const CBotString& label, int type);

-

-	BOOL		IsOfClass(CBotString name);

-};

-

-class CBotWhile : public CBotInstr

-{

-private:

-	CBotInstr*	m_Condition;		// la condition

-	CBotInstr*	m_Block;			// les instructions

-	CBotString	m_label;			// une étiquette s'il y a

-

-public:

-				CBotWhile();

-				~CBotWhile();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotRepeat : public CBotInstr

-{

-private:

-	CBotInstr*	m_NbIter;			// le nombre d'itération

-	CBotInstr*	m_Block;			// les instructions

-	CBotString	m_label;			// une étiquette s'il y a

-

-public:

-				CBotRepeat();

-				~CBotRepeat();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotDo : public CBotInstr

-{

-private:

-	CBotInstr*	m_Block;			// les instructions

-	CBotInstr*	m_Condition;		// la condition

-	CBotString	m_label;			// une étiquette s'il y a

-

-public:

-				CBotDo();

-				~CBotDo();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-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_Block;			// les instructions

-	CBotString	m_label;			// une étiquette s'il y a

-

-public:

-				CBotFor();

-				~CBotFor();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotBreak : public CBotInstr

-{

-private:

-	CBotString	m_label;			// une étiquette s'il y a

-

-public:

-				CBotBreak();

-				~CBotBreak();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotReturn : public CBotInstr

-{

-private:

-	CBotInstr*	m_Instr;			// le paramètre à retourner

-

-public:

-				CBotReturn();

-				~CBotReturn();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotSwitch : public CBotInstr

-{

-private:

-	CBotInstr*	m_Value;			// value à chercher

-	CBotInstr*	m_Block;			// les instructions

-

-public:

-				CBotSwitch();

-				~CBotSwitch();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotCase : public CBotInstr

-{

-private:

-	CBotInstr*	m_Value;			// valeur à comparer

-

-public:

-				CBotCase();

-				~CBotCase();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-	BOOL		CompCase(CBotStack* &pj, int val);

-};

-

-class CBotCatch : public CBotInstr

-{

-private:

-	CBotInstr*	m_Block;			// les instructions

-	CBotInstr*	m_Cond;				// la condition

-	CBotCatch*	m_next;				// le catch suivant

-	friend class CBotTry;

-

-public:

-				CBotCatch();

-				~CBotCatch();

-	static

-	CBotCatch*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		TestCatch(CBotStack* &pj, int val);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-	void		RestoreCondState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotTry : public CBotInstr

-{

-private:

-	CBotInstr*	m_Block;			// les instructions

-	CBotCatch*	m_ListCatch;		// les catches

-	CBotInstr*	m_FinalInst;		// instruction finale

-

-public:

-				CBotTry();

-				~CBotTry();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotThrow : public CBotInstr

-{

-private:

-	CBotInstr*	m_Value;			// la valeur à envoyer

-

-public:

-				CBotThrow();

-				~CBotThrow();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotStartDebugDD : public CBotInstr

-{

-private:

-

-public:

-				CBotStartDebugDD();

-				~CBotStartDebugDD();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-};

-

-

-class CBotIf : public CBotInstr

-{

-private:

-	CBotInstr*	m_Condition;		// la condition

-	CBotInstr*	m_Block;			// les instructions

-	CBotInstr*	m_BlockElse;		// les instructions

-

-public:

-				CBotIf();

-				~CBotIf();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-// 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

-

-public:

-				CBotInt();

-				~CBotInt();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip = FALSE);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// définition d'un tableau

-

-class CBotInstArray : public CBotInstr

-{

-private:

-	CBotInstr*	m_var;				// la variable à initialiser

-	CBotInstr*	m_listass;			// liste d'assignations pour le tableau

-	CBotTypResult

-				m_typevar;			// type d'éléments

-//	CBotString	m_ClassName;

-

-public:

-				CBotInstArray();

-				~CBotInstArray();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-// 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;

-public:

-				CBotListArray();

-				~CBotListArray();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);

-	BOOL		Execute(CBotStack* &pj, CBotVar* pVar);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotEmpty : public CBotInstr

-{

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// 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

-

-public:

-				CBotBoolean();

-				~CBotBoolean();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-// 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

-

-public:

-				CBotFloat();

-				~CBotFloat();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// 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

-

-public:

-				CBotIString();

-				~CBotIString();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// 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 ?

-	long		m_nMethodeIdent;

-

-public:

-				CBotClassInst();

-				~CBotClassInst();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass = NULL);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotCondition : public CBotInstr

-{

-private:

-

-public:

-

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-};

-

-

-// left opérande

-// n'accepte que les expressions pouvant être à gauche d'une assignation

-

-class CBotLeftExpr : public CBotInstr

-{

-private:

-	long		m_nIdent;

-

-public:

-				CBotLeftExpr();

-				~CBotLeftExpr();

-	static

-	CBotLeftExpr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pStack, CBotStack* array);

-

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep);

-	void		RestoreStateVar(CBotStack* &pile, BOOL bMain);

-};

-

-

-// gestion des champs d'une instance

-

-class CBotFieldExpr : public CBotInstr

-{

-private:

-	friend class CBotExpression;

-	int			m_nIdent;

-

-public:

-				CBotFieldExpr();

-				~CBotFieldExpr();

-	void		SetUniqNum(int num);

-//	static

-//	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);

-	void		RestoreStateVar(CBotStack* &pj, BOOL bMain);

-};

-

-// gestion des index dans les tableaux

-

-class CBotIndexExpr : public CBotInstr

-{

-private:

-	CBotInstr*	 m_expr;					// expression pour le calcul de l'index

-	friend class CBotLeftExpr;

-	friend class CBotExprVar;

-

-public:

-				CBotIndexExpr();

-				~CBotIndexExpr();

-//	static

-//	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);

-	void		RestoreStateVar(CBotStack* &pj, BOOL bMain);

-};

-

-// une expression du genre

-// x = a;

-// x * y + 3;

-

-class CBotExpression : public CBotInstr

-{

-private:

-	CBotLeftExpr*	m_leftop;			// élément de gauche

-	CBotInstr*		m_rightop;			// élément de droite

-

-public:

-				CBotExpression();

-				~CBotExpression();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pStack);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotListExpression : public CBotInstr

-{

-private:

-	CBotInstr*	m_Expr;				// la 1ère expression à évaluer

-

-public:

-				CBotListExpression();

-				~CBotListExpression();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pStack);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotLogicExpr : public CBotInstr

-{

-private:

-	CBotInstr*	m_condition;		// test à évaluer

-	CBotInstr*	m_op1;				// élément de gauche

-	CBotInstr*	m_op2;				// élément de droite

-	friend class CBotTwoOpExpr;

-

-public:

-				CBotLogicExpr();

-				~CBotLogicExpr();

-//	static

-//	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pStack);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-

-class CBotBoolExpr : public CBotInstr

-{

-private:

-

-public:

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-};

-

-

-

-// 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

-class CBotParExpr : public CBotInstr

-{

-private:

-

-public:

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-};

-

-// expression unaire 

-class CBotExprUnaire : public CBotInstr

-{

-private:

-	CBotInstr*	m_Expr;				// l'expression à évaluer

-public:

-				CBotExprUnaire();

-				~CBotExprUnaire();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pStack);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// 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

-public:

-				CBotTwoOpExpr();

-				~CBotTwoOpExpr();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations = NULL);

-	BOOL		Execute(CBotStack* &pStack);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-

-

-// un bloc d'instructions { .... }

-class CBotBlock : public CBotInstr

-{

-private:

-

-public:

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = TRUE);

-	static

-	CBotInstr*	CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = FALSE);

-};

-

-

-// le contenu d'un bloc d'instructions ... ; ... ; ... ; ... ;

-class CBotListInstr : public CBotInstr

-{

-private:

-	CBotInstr*	m_Instr;			// les instructions à faire

-

-public:

-				CBotListInstr();

-				~CBotListInstr();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = TRUE);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-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

-	CBotTypResult

-				m_typRes;			// type complet du résultat

-	long		m_nFuncIdent;		// id de la fonction

-

-public:

-				CBotInstrCall();

-				~CBotInstrCall();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// 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

-	CBotTypResult

-				m_typRes;			// type complet du résultat

-

-	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

-

-public:

-				CBotInstrMethode();

-				~CBotInstrMethode();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* pVar);

-	BOOL		Execute(CBotStack* &pj);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep, BOOL bExtend);

-	void		RestoreStateVar(CBotStack* &pj, BOOL bMain);

-};

-

-// expression donnant un nom de variable

-

-class CBotExprVar : public CBotInstr

-{

-private:

-	long		m_nIdent;

-	friend class CBotPostIncExpr;

-	friend class CBotPreIncExpr;

-

-public:

-				CBotExprVar();

-				~CBotExprVar();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack, int privat=PR_PROTECT);

-	static

-	CBotInstr*	CompileMethode(CBotToken* &p, CBotCStack* pStack);

-

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-	BOOL		ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep);

-	BOOL		Execute2Var(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep);

-	void		RestoreStateVar(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotPostIncExpr : public CBotInstr

-{

-private:

-	CBotInstr*	m_Instr;

-	friend class CBotParExpr;

-

-public:

-				CBotPostIncExpr();

-				~CBotPostIncExpr();

-//	static

-//	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotPreIncExpr : public CBotInstr

-{

-private:

-	CBotInstr*	m_Instr;

-	friend class CBotParExpr;

-

-public:

-				CBotPreIncExpr();

-				~CBotPreIncExpr();

-//	static

-//	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotLeftExprVar : public CBotInstr

-{

-private:

-public:

-	CBotTypResult

-				m_typevar;			// type de variable déclarée

-	long		m_nIdent;			// identificateur unique pour cette variable

-

-public:

-				CBotLeftExprVar();

-				~CBotLeftExprVar();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotExprBool : public CBotInstr

-{

-private:

-

-public:

-				CBotExprBool();

-				~CBotExprBool();

-

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-class CBotExprNull : public CBotInstr

-{

-private:

-

-public:

-				CBotExprNull();

-				~CBotExprNull();

-

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotExprNan : public CBotInstr

-{

-private:

-

-public:

-				CBotExprNan();

-				~CBotExprNan();

-

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-class CBotNew : public CBotInstr

-{

-private:

-	CBotInstr*	m_Parameters;		// les paramètres à évaluer

-	long		m_nMethodeIdent;

-//	long		m_nThisIdent;

-	CBotToken	m_vartoken;

-

-public:

-				CBotNew();

-				~CBotNew();

-

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-// expression représentant un nombre

-

-class CBotExprNum : public CBotInstr

-{

-private:

-	int			m_numtype;					// et le type de nombre

-	long		m_valint;					// valeur pour un int

-	float		m_valfloat;					// valeur pour un float

-

-public:

-				CBotExprNum();

-				~CBotExprNum();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-

-// expression représentant une chaine de caractères

-

-class CBotExprAlpha : public CBotInstr

-{

-private:

-

-public:

-				CBotExprAlpha();

-				~CBotExprAlpha();

-	static

-	CBotInstr*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL		Execute(CBotStack* &pj);

-	void		RestoreState(CBotStack* &pj, BOOL bMain);

-};

-

-

-#define	MAX(a,b)	((a>b) ? a : b)

-

-

-// classe pour la gestion des nombres entier (int)

-class CBotVarInt : public CBotVar

-{

-private:

-	int			m_val;			// la valeur

-	CBotString	m_defnum;		// le nom si donné par DefineNum

-	friend class CBotVar;

-

-public:

-				CBotVarInt( const CBotToken* name );

-//				~CBotVarInt();

-

-	void		SetValInt(int val, const char* s = NULL);

-	void		SetValFloat(float val);

-	int			GivValInt();

-	float		GivValFloat();

-	CBotString	GivValString();

-

-	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);

-

-

-	void		Add(CBotVar* left, CBotVar* right);	// addition

-	void		Sub(CBotVar* left, CBotVar* right);	// soustraction

-	void		Mul(CBotVar* left, CBotVar* right);	// multiplication

-	int			Div(CBotVar* left, CBotVar* right);	// division

-	int			Modulo(CBotVar* left, CBotVar* right);	// reste de division

-	void		Power(CBotVar* left, CBotVar* right);	// puissance

-

-	BOOL		Lo(CBotVar* left, CBotVar* right);

-	BOOL		Hi(CBotVar* left, CBotVar* right);

-	BOOL		Ls(CBotVar* left, CBotVar* right);

-	BOOL		Hs(CBotVar* left, CBotVar* right);

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-

-	void		XOr(CBotVar* left, CBotVar* right);

-	void		Or(CBotVar* left, CBotVar* right);

-	void		And(CBotVar* left, CBotVar* right);

-

-	void		SL(CBotVar* left, CBotVar* right);

-	void		SR(CBotVar* left, CBotVar* right);

-	void		ASR(CBotVar* left, CBotVar* right);

-

-	void		Neg();

-	void		Not();

-	void		Inc();

-	void		Dec();

-

-	BOOL		Save0State(FILE* pf);

-	BOOL		Save1State(FILE* pf);

-

-};

-

-// classe pour la gestion des nombres réels (float)

-class CBotVarFloat : public CBotVar

-{

-private:

-	float		m_val;		// la valeur

-

-public:

-				CBotVarFloat( const CBotToken* name );

-//				~CBotVarFloat();

-

-	void		SetValInt(int val, const char* s = NULL);

-	void		SetValFloat(float val);

-	int			GivValInt();

-	float		GivValFloat();

-	CBotString	GivValString();

-

-	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);

-

-

-	void		Add(CBotVar* left, CBotVar* right);	// addition

-	void		Sub(CBotVar* left, CBotVar* right);	// soustraction

-	void		Mul(CBotVar* left, CBotVar* right);	// multiplication

-	int 		Div(CBotVar* left, CBotVar* right);	// division

-	int			Modulo(CBotVar* left, CBotVar* right);	// reste de division

-	void		Power(CBotVar* left, CBotVar* right);	// puissance

-

-	BOOL		Lo(CBotVar* left, CBotVar* right);

-	BOOL		Hi(CBotVar* left, CBotVar* right);

-	BOOL		Ls(CBotVar* left, CBotVar* right);

-	BOOL		Hs(CBotVar* left, CBotVar* right);

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-

-	void		Neg();

-	void		Inc();

-	void		Dec();

-

-	BOOL		Save1State(FILE* pf);

-};

-

-

-// classe pour la gestion des chaînes (String)

-class CBotVarString : public CBotVar

-{

-private:

-	CBotString	m_val;		// la valeur

-

-public:

-				CBotVarString( const CBotToken* name );

-//				~CBotVarString();

-

-	void		SetValString(const char* p);

-	CBotString	GivValString();

-

-	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);

-

-	void		Add(CBotVar* left, CBotVar* right);	// addition

-

-	BOOL		Lo(CBotVar* left, CBotVar* right);

-	BOOL		Hi(CBotVar* left, CBotVar* right);

-	BOOL		Ls(CBotVar* left, CBotVar* right);

-	BOOL		Hs(CBotVar* left, CBotVar* right);

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-

-	BOOL		Save1State(FILE* pf);

-};

-

-// classe pour la gestion des boolean

-class CBotVarBoolean : public CBotVar

-{

-private:

-	BOOL		m_val;		// la valeur

-

-public:

-				CBotVarBoolean( const CBotToken* name );

-//				~CBotVarBoolean();

-

-	void		SetValInt(int val, const char* s = NULL);

-	void		SetValFloat(float val);

-	int			GivValInt();

-	float		GivValFloat();

-	CBotString	GivValString();

-

-	void		Copy(CBotVar* pSrc, BOOL bName=TRUE);

-

-	void		And(CBotVar* left, CBotVar* right);

-	void		Or(CBotVar* left, CBotVar* right);

-	void		XOr(CBotVar* left, CBotVar* right);

-	void		Not();

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-

-	BOOL		Save1State(FILE* pf);

-};

-

-

-// classe pour la gestion des instances de classe

-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

-

-private:

-	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é

-

-public:

-				CBotVarClass( const CBotToken* name, const CBotTypResult& type );

-//				CBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );

-				~CBotVarClass();

-//	void		InitCBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );

-

-	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*	GivItemRef(int nIdent);

-

-	CBotVar*	GivItem(int n, BOOL bExtend);

-	CBotVar*	GivItemList();

-

-	CBotString	GivValString();

-

-	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

-

-	CBotVarClass* 

-				GivPointer();

-	void		SetItemList(CBotVar* pVar);

-

-	void		SetIdent(long n);

-	

-	static

-	CBotVarClass*

-				CBotVarClass::Find(long id);

-

-

-//	CBotVar*	GivMyThis();

-

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-

-	void		ConstructorSet();

-};

-

-

-// 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

-	friend class CBotVar;			// mon papa est un copain

-

-public:

-				CBotVarPointer( const CBotToken* name, CBotTypResult& type );

-				~CBotVarPointer();

-

-	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*	GivItemRef(int nIdent);

-	CBotVar*	GivItemList();

-

-	CBotString	GivValString();

-	void		SetPointer(CBotVar* p);

-	CBotVarClass*

-				GivPointer();

-

-	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);

-	void		Maj(void* pUser, BOOL bContinue);

-

-	BOOL		Eq(CBotVar* left, CBotVar* right);

-	BOOL		Ne(CBotVar* left, CBotVar* right);

-};

-

-

-// classe pour les tableaux

-

-#define	MAXARRAYSIZE	9999

-

-class CBotVarArray : public CBotVar

-{

-private:

-	CBotVarClass*

-				m_pInstance;				// instance gérant le tableau

-

-	friend class CBotVar;					// papa est un copain

-

-public:

-				CBotVarArray( const CBotToken* name, CBotTypResult& type );

-				~CBotVarArray();

-

-	void		SetPointer(CBotVar* p);

-	CBotVarClass*

-				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

-

-	CBotString	GivValString();					// donne le contenu du tableau dans une chaîne

-

-	BOOL		Save1State(FILE* pf);

-};

-

-

-extern CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars);

-

-extern BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op = 0 );

-extern BOOL TypesCompatibles( const CBotTypResult& type1, const CBotTypResult& type2 );

-

-extern BOOL WriteWord(FILE* pf, WORD w);

-extern BOOL ReadWord(FILE* pf, WORD& w);

-extern BOOL ReadLong(FILE* pf, long& w);

-extern BOOL WriteFloat(FILE* pf, float w);

-extern BOOL WriteLong(FILE* pf, long w);

-extern BOOL ReadFloat(FILE* pf, float& w);

-extern BOOL WriteString(FILE* pf, CBotString s);

-extern BOOL ReadString(FILE* pf, CBotString& s);

-extern BOOL WriteType(FILE* pf, CBotTypResult type);

-extern BOOL ReadType(FILE* pf, CBotTypResult& type);

-

-extern float GivNumFloat( const char* p );

-

-#if	FALSE

-extern void DEBUG( const char* text, int val, CBotStack* pile );

-#endif

-

-///////////////////////////////////////////

-// classe pour les appels de routines (externes)

-

-class CBotCall

-{

-private:

-	static

-	CBotCall*	m_ListCalls;

-	static

-	void*		m_pUser;

-	long		m_nFuncIdent;

-

-private:

-	CBotString	m_name;

-	BOOL		(*m_rExec) (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser) ;

-	CBotTypResult

-				(*m_rComp) (CBotVar* &pVar, void* pUser)	;

-	CBotCall*	m_next;

-

-public:

-				CBotCall(const char* name, 

-						 BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-						 CBotTypResult rCompile (CBotVar* &pVar, void* pUser));

-				~CBotCall();

-

-	static

-	BOOL		AddFunction(const char* name, 

-							BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-							CBotTypResult rCompile (CBotVar* &pVar, void* pUser));

-

-	static

-	CBotTypResult

-				CompileCall(CBotToken* &p, CBotVar** ppVars, CBotCStack* pStack, long& nIdent);

-	static

-	BOOL		CheckCall(const char* name);

-

-//	static

-//	int			DoCall(CBotToken* &p, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);

-	static

-	int			DoCall(long& nIdent, CBotToken* token, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);

-#if	STACKRUN

-	BOOL		Run(CBotStack* pStack);

-	static

-	BOOL		RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack);

-#endif

-

-	CBotString	GivName();

-	CBotCall*	Next();

-	

-	static void	SetPUser(void* pUser);

-	static void	Free();

-};

-

-// classe gérant les méthodes déclarées par AddFunction sur une classe

-

-class CBotCallMethode

-{

-private:

-	CBotString	m_name;

-	BOOL		(*m_rExec) (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception);

-	CBotTypResult

-				(*m_rComp) (CBotVar* pThis, CBotVar* &pVar);

-	CBotCallMethode*	m_next;

-	friend class CBotClass;

-	long		m_nFuncIdent;

-

-public:

-				CBotCallMethode(const char* name, 

-						 BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 

-						 CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));

-				~CBotCallMethode();

-

-	CBotTypResult

-				CompileCall(const char* name, CBotVar* pThis, 

-							CBotVar** ppVars, CBotCStack* pStack,

-							long& nIdent);

-

-	int			DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pFunc);

-

-	CBotString	GivName();

-	CBotCallMethode*	Next();

-	void		AddNext(CBotCallMethode* p);

-	

-};

-

-// une liste de paramètres

-

-class CBotDefParam

-{

-private:

-	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

-	long			m_nIdent;

-

-public:

-					CBotDefParam();

-					~CBotDefParam();

-	static

-	CBotDefParam*	Compile(CBotToken* &p, CBotCStack* pStack);

-	BOOL			Execute(CBotVar** ppVars, CBotStack* &pj);

-	void			RestoreState(CBotStack* &pj, BOOL bMain);

-

-	void			AddNext(CBotDefParam* p);

-	int				GivType();

-	CBotTypResult	GivTypResult();

-	CBotDefParam*	GivNext();

-

-	CBotString		GivParamString();

-};

-

-

-// une déclaration de fonction

-

-class CBotFunction : CBotInstr

-{

-private:

-	// gestion d'une liste (static) de fonctions publiques

-	static

-	CBotFunction*	m_listPublic;

-	CBotFunction*	m_nextpublic;

-	CBotFunction*	m_prevpublic;

-	friend class	CBotCStack;

-//	long			m_nThisIdent;

-	long			m_nFuncIdent;

-	BOOL			m_bSynchro;		// méthode synchronisée ?

-

-private:

-	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

-

-	BOOL			m_bPublic;		// fonction publique

-	BOOL			m_bExtern;		// fonction extern

-	CBotString		m_MasterClass;	// nom de la classe qu'on dérive

-	CBotProgram*	m_pProg;

-	friend class CBotProgram;

-	friend class CBotClass;

-

-	CBotToken		m_extern;		// pour la position du mot "extern"

-	CBotToken		m_openpar;

-	CBotToken		m_closepar;

-	CBotToken		m_openblk;

-	CBotToken		m_closeblk;

-public:

-					CBotFunction::CBotFunction();

-					CBotFunction::~CBotFunction();

-	static

-	CBotFunction*	Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* pFunc, BOOL bLocal = TRUE);

-	static

-	CBotFunction*	Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass*	pClass);

-	BOOL			Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);

-	void			RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);

-

-	void			AddNext(CBotFunction* p);

-	CBotTypResult	CompileCall(const char* name, CBotVar** ppVars, long& nIdent);

-	CBotFunction*	FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, BOOL bPublic = TRUE);

-

-	int				DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken);

-	void			RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack);

-	int				DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass);

-	void			RestoreCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass);

-	BOOL			CheckParam(CBotDefParam* pParam);

-

-	static

-	void			AddPublic(CBotFunction* pfunc);

-

-	CBotString		GivName();

-	CBotString		GivParams();

-	BOOL			IsPublic();

-	BOOL			IsExtern();

-	CBotFunction*	Next();

-

-	BOOL			GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop);

-};

-

-

+// * 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  http://www.gnu.org/licenses/.
+////////////////////////////////////////////////////////////////////
+/**
+ * \file CBot.h
+ * \brief Interpreter of the language CBot for COLOBOT game
+ */
+
+#pragma once
+
+#include "resource.h"
+#include "CBotDll.h"                    // public definitions
+#include "CBotToken.h"                  // token management
+
+#define    STACKRUN    true             /// \def return execution directly on a suspended routine
+#define    STACKMEM    true             /// \def preserve memory for the execution stack
+#define    MAXSTACK    990              /// \def stack size reserved
+
+#define    EOX         (CBotStack*)-1   /// \def tag special condition
+
+
+// fix for MSVC instruction __asm int 3 (setting a trap)
+#if defined(__MINGW32__) || defined(__GNUC__)
+#define ASM_TRAP()    asm("int $3");
+#else
+#define ASM_TRAP()    __asm int 3;
+#endif
+
+/////////////////////////////////////////////////////////////////////
+// forward declaration
+
+class CBotCompExpr; // an expression like
+                    // () <= ()
+class CBotAddExpr;  // an expression like
+                    // () + ()
+class CBotParExpr;  // basic type or instruction in parenthesis
+                    // Toto.truc
+                    // 12.5
+                    // "string"
+                    // ( expression )
+class CBotExprVar;  // a variable name as
+                    // Toto
+                    // chose.truc.machin
+class CBotWhile;    // while (...) {...};
+class CBotIf;       // if (...) {...} else {...}
+class CBotDefParam; // paramerer list of a function
+class CBotRepeat;   // repeat (nb) {...}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Management of the execution stack
+////////////////////////////////////////////////////////////////////////
+
+// actually, externally, the only thing it can do
+// is to create an instance of a stack
+// to use for routine CBotProgram :: Execute (CBotStack)
+
+
+/**\class CBotStack 
+ * \brief Management of the execution stack.
+ * \brief Actually the only thing it can do is to create an instance of a stack
+ * \brief to use for routine CBotProgram :: Execute(CBotStack)*/
+class CBotStack
+{
+public:
+#if    STACKMEM
+    /**
+     * \brief FirstStack Allocate first stack
+     * \return pointer to created stack
+     */
+    static CBotStack * FirstStack();
+
+    /** \brief Delete Remove current stack */
+    void Delete();
+#endif
+
+    /**
+     * \brief CBotStack Constructor of the stack
+     * \param ppapa Not used.
+     */
+    CBotStack(CBotStack* ppapa);
+
+
+    /** \brief ~CBotStack Destructor */
+    ~CBotStack();
+
+    /**
+     * \brief StackOver Check if end of stack is reached
+     * \return true if end of stack
+     */
+    bool StackOver();
+
+    /**
+     * \brief GivError Get error number of the stack
+     * \param [out] start beginning of the stack
+     * \param [out] end end of stack
+     * \return error number
+     */
+    int GivError(int& start, int& end);
+
+    /**
+     * \brief GivError Get error number
+     * \return eror number
+     */
+    int GivError();// rend le numéro d'erreur retourné
+
+    /**
+     * \brief Reset Reset error at and set user
+     * \param [in] pUser User of stack
+     */
+    void Reset(void* pUser);
+
+    /**
+     * \brief SetType Determines the type.
+     * \param type Type of instruction on the stack.
+     */
+    void SetType(CBotTypResult& type);
+
+    /**
+     * \brief GivType Get the type of value on the stack.
+     * \param [in] mode Used when getting class type (1 gives pointer, 2 gives intrinsic).
+     * \return Type number.
+     */
+    int GivType(int mode = 0);
+
+    /**
+     * \brief Gives the type of complete value on the stack.
+     * \param [in] mode Used when getting class type (1 gives pointer, 2 gives intrinsic).
+     * \return  Type of an element.
+     */
+    CBotTypResult GivTypResult(int mode = 0);
+
+    /**
+     * \brief Adds a local variable.
+     * \param [in] p Variable to be added.
+     */
+    void AddVar(CBotVar* p);
+
+    /**
+     * \brief Fetch a variable by its token.
+     * \brief This may be a composite variable
+     * \param [in] pToken Token upon which search is performed
+     * \param [in] bUpdate Not used. Probably need to be removed
+     * \param [in] bModif Not used. Probably need to be removed
+     * \return Found variable
+     */
+    CBotVar* FindVar(CBotToken* &pToken, bool bUpdate = false,
+                                           bool bModif  = false);
+
+    /**
+     * \brief Fetch a variable by its token.
+     * \brief This may be a composite variable
+     * \param [in] pToken Token upon which search is performed
+     * \param [in] bUpdate Not used. Probably need to be removed
+     * \param [in] bModif Not used. Probably need to be removed
+     * \return Found variable
+     */
+    CBotVar* FindVar(CBotToken& Token, bool bUpdate = false,
+                                              bool bModif  = false);
+
+    /**
+     * \brief Fetch variable by its name
+     * \param [in] name Name of variable to find
+     * \return Found variable
+     */
+    CBotVar* FindVar(const char* name);
+
+    /**
+     * \brief Fetch a variable on the stack according to its identification number
+     * \brief This is faster than comparing names
+     * \param [in] ident Identifier of a variable
+     * \param [in] bUpdate Not used. Probably need to be removed
+     * \param [in] bModif Not used. Probably need to be removed
+     * \return Found variable
+     */
+    CBotVar* FindVar(long ident, bool bUpdate = false,
+                                        bool bModif  = false);
+
+    /**
+     * \brief Find variable by its token and returns a copy of it.
+     * \param Token Token upon which search is performed
+     * \param bUpdate Not used.
+     * \return Found variable, NULL if not found
+     */
+    CBotVar*        CopyVar(CBotToken& Token, bool bUpdate = false);
+
+
+    CBotStack*        AddStack(CBotInstr* instr = NULL, bool bBlock = false);    // extends the stack
+    CBotStack*        AddStackEOX(CBotCall* instr = NULL, bool bBlock = false);    // extends the stack
+    CBotStack*        RestoreStack(CBotInstr* instr = NULL);
+    CBotStack*        RestoreStackEOX(CBotCall* instr = NULL);
+
+    CBotStack*        AddStack2(bool bBlock = false);                        // extends the stack
+    bool            Return(CBotStack* pFils);                            // transmits the result over
+    bool            ReturnKeep(CBotStack* pFils);                        // transmits the result without reducing the stack
+    bool            BreakReturn(CBotStack* pfils, const char* name = NULL);
+                                                                        // in case of eventual break
+    bool            IfContinue(int state, const char* name);
+                                                                        // or "continue"
+    
+    bool            IsOk();
+
+    bool            SetState(int n, int lim = -10);                        // select a state
+    int                GivState();                                            // in what state am I?
+    bool            IncState(int lim = -10);                            // passes to the next state
+    bool            IfStep();                                            // do step by step
+    bool            Execute(); 
+
+    void            SetVar( CBotVar* var );
+    void            SetCopyVar( CBotVar* var );
+    CBotVar*        GivVar();
+    CBotVar*        GivCopyVar();
+    CBotVar*        GivPtVar();
+    bool            GivRetVar(bool bRet);
+    long            GivVal();
+
+    void            SetStartError(int pos);
+    void            SetError(int n, CBotToken* token = NULL);
+    void            SetPosError(CBotToken* token);
+    void            ResetError(int n, int start, int end);
+    void            SetBreak(int val, const char* name);
+
+    void            SetBotCall(CBotProgram* p);
+    CBotProgram*    GivBotCall(bool bFirst = false);
+    void*            GivPUser();
+    bool            GivBlock();
+
+
+    bool            ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);
+    void            RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar);
+
+    bool            SaveState(FILE* pf);
+    bool            RestoreState(FILE* pf, CBotStack* &pStack);
+
+    static
+    void            SetTimer(int n);
+
+    void            GetRunPos(const char* &FunctionName, int &start, int &end);
+    CBotVar*        GivStackVars(const char* &FunctionName, int level);
+
+    int                m_temp;
+
+private:
+    CBotStack*        m_next;
+    CBotStack*        m_next2;
+    CBotStack*        m_prev;
+    friend class CBotInstArray;
+
+#ifdef    _DEBUG 
+    int                m_index;
+#endif
+    int                m_state;
+    int                m_step;
+    static int        m_error;
+    static int        m_start;
+    static int        m_end;
+    static
+    CBotVar*        m_retvar;                    // result of a return
+
+    CBotVar*        m_var;                        // result of the operations
+    CBotVar*        m_listVar;                    // variables declared at this level
+
+    bool            m_bBlock;                    // is part of a block (variables are local to this block)
+    bool            m_bOver;                    // stack limits?
+//    bool            m_bDontDelete;                // special, not to destroy the variable during delete
+    CBotProgram*    m_prog;                        // user-defined functions
+
+    static
+    int                m_initimer;
+    static
+    int                m_timer;
+    static
+    CBotString        m_labelBreak;
+    static
+    void*            m_pUser;
+
+    CBotInstr*        m_instr;                    // the corresponding instruction
+    bool            m_bFunc;                    // an input of a function?
+    CBotCall*        m_call;                        // recovery point in a extern call
+    friend class    CBotTry;
+};
+
+// inline routinees must be declared in file.h
+
+inline bool CBotStack::IsOk()
+{
+    return (m_error == 0);
+}
+
+inline int CBotStack::GivState()
+{
+    return m_state;
+}
+
+inline int CBotStack::GivError()
+{
+    return m_error;
+}
+
+////////////////////////////////////////////////////////////////////////
+// Management of the stack of compilation
+////////////////////////////////////////////////////////////////////////
+
+
+class CBotCStack
+{
+private:
+    CBotCStack*        m_next;
+    CBotCStack*        m_prev;
+
+    static int      m_error;
+    static int      m_end;
+    int              m_start;
+
+    CBotVar*        m_var;                        // result of the operations
+
+    bool            m_bBlock;                    // is part of a block (variables are local to this block)
+    CBotVar*        m_listVar;
+
+    static
+    CBotProgram*    m_prog;                        // list of compiled functions
+    static
+    CBotTypResult    m_retTyp;
+//    static
+//    CBotToken*        m_retClass;
+
+public:
+                    CBotCStack(CBotCStack* ppapa);
+                    ~CBotCStack();
+
+    bool            IsOk();
+    int                GivError();
+    int                GivError(int& start, int& end);
+                                                // gives error number
+
+    void            SetType(CBotTypResult& type);// determines the type
+    CBotTypResult    GivTypResult(int mode = 0);    // gives the type of value on the stack
+    int                GivType(int mode = 0);        // gives the type of value on the stack
+    CBotClass*        GivClass();                    // gives the class of the value on the stack
+
+    void            AddVar(CBotVar* p);            // adds a local variable
+    CBotVar*        FindVar(CBotToken* &p);        // finds a variable
+    CBotVar*        FindVar(CBotToken& Token);
+    bool            CheckVarLocal(CBotToken* &pToken);
+    CBotVar*        CopyVar(CBotToken& Token);    // finds and makes a copy
+
+    CBotCStack*        TokenStack(CBotToken* pToken = NULL, bool bBlock = false);
+    CBotInstr*        Return(CBotInstr* p, CBotCStack* pParent);    // transmits the result upper
+    CBotFunction*    ReturnFunc(CBotFunction* p, CBotCStack* pParent);    // transmits the result upper
+    
+    void            SetVar( CBotVar* var );
+    void            SetCopyVar( CBotVar* var );
+    CBotVar*        GivVar();
+
+    void            SetStartError(int pos);
+    void            SetError(int n, int pos);
+    void            SetError(int n, CBotToken* p);
+    void            ResetError(int n, int start, int end);
+
+    void            SetRetType(CBotTypResult& type);
+    CBotTypResult    GivRetType();
+
+//    void            SetBotCall(CBotFunction* &pFunc);
+    void            SetBotCall(CBotProgram* p);
+    CBotProgram*    GivBotCall();
+    CBotTypResult    CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent);
+    bool            CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
+
+    bool            NextToken(CBotToken* &p);
+};
+
+
+extern bool SaveVar(FILE* pf, CBotVar* pVar);
+
+
+/////////////////////////////////////////////////////////////////////
+// class defining an instruction
+class CBotInstr
+{
+private:
+    static
+    CBotStringArray
+                m_labelLvl;
+protected:
+    CBotToken    m_token;                // keeps the token
+    CBotString    name;                    // debug
+    CBotInstr*    m_next;                    // linked command
+    CBotInstr*    m_next2b;                // second list definition chain
+    CBotInstr*    m_next3;                // third list for indices and fields
+    CBotInstr*    m_next3b;                // necessary for reporting tables
+/*
+    for example, the following program
+    int        x[]; x[1] = 4;
+    int        y[x[1]][10], z;
+    is generated
+    CBotInstrArray
+    m_next3b-> CBotEmpty
+    m_next->
+    CBotExpression ....
+    m_next->
+    CBotInstrArray
+    m_next3b-> CBotExpression ('x') ( m_next3-> CBotIndexExpr ('1') )
+    m_next3b-> CBotExpression ('10')
+    m_next2-> 'z'
+    m_next->...
+
+*/
+
+    static
+    int                m_LoopLvl;
+    friend class    CBotClassInst;
+    friend class    CBotInt;
+    friend class    CBotListArray;
+
+public:
+                CBotInstr();
+                virtual
+                ~CBotInstr();
+
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    static
+    CBotInstr*    CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypResult type, bool first = true);
+
+    virtual
+    bool        Execute(CBotStack* &pj);
+    virtual
+    bool        Execute(CBotStack* &pj, CBotVar* pVar);
+    virtual
+    void        RestoreState(CBotStack* &pj, bool bMain);
+
+    virtual
+    bool        ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
+    virtual
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend);
+    virtual
+    void        RestoreStateVar(CBotStack* &pile, bool bMain);
+
+    virtual
+    bool        CompCase(CBotStack* &pj, int val);
+
+    void        SetToken(CBotToken* p);
+    int            GivTokenType();
+    CBotToken*    GivToken();
+
+    void        AddNext(CBotInstr* n);
+    CBotInstr*    GivNext();
+    void        AddNext3(CBotInstr* n);
+    CBotInstr*    GivNext3();
+    void        AddNext3b(CBotInstr* n);
+    CBotInstr*    GivNext3b();
+
+    static
+    void        IncLvl(CBotString& label);
+    static
+    void        IncLvl();
+    static
+    void        DecLvl();
+    static
+    bool        ChkLvl(const CBotString& label, int type);
+
+    bool        IsOfClass(CBotString name);
+};
+
+class CBotWhile : public CBotInstr
+{
+private:
+    CBotInstr*    m_Condition;        // condition
+    CBotInstr*    m_Block;            // instructions
+    CBotString    m_label;            // a label if there is 
+
+public:
+                CBotWhile();
+                ~CBotWhile();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotRepeat : public CBotInstr
+{
+private:
+    /// Number of iterations
+    CBotInstr*    m_NbIter;
+
+    /// Instructions
+    CBotInstr*    m_Block;
+
+    /// Label
+    CBotString    m_label;            // a label if there is 
+
+public:
+    CBotRepeat();
+    ~CBotRepeat();
+
+    /// Static method used for compilation
+    static CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+
+    /// Execute
+    bool Execute(CBotStack* &pj);
+
+    /// Restore state
+    void RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotDo : public CBotInstr
+{
+private:
+    CBotInstr*    m_Block;            // instruction
+    CBotInstr*    m_Condition;        // conditions
+    CBotString    m_label;            // a label if there is 
+
+public:
+                CBotDo();
+                ~CBotDo();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotFor : public CBotInstr
+{
+private:
+    CBotInstr*    m_Init;                // initial intruction
+    CBotInstr*    m_Test;                // test condition
+    CBotInstr*    m_Incr;                // instruction for increment
+    CBotInstr*    m_Block;            // instructions
+    CBotString    m_label;            // a label if there is 
+
+public:
+                CBotFor();
+                ~CBotFor();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotBreak : public CBotInstr
+{
+private:
+    CBotString    m_label;            // a label if there is 
+
+public:
+                CBotBreak();
+                ~CBotBreak();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotReturn : public CBotInstr
+{
+private:
+    CBotInstr*    m_Instr;            // paramter of return 
+
+public:
+                CBotReturn();
+                ~CBotReturn();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotSwitch : public CBotInstr
+{
+private:
+    CBotInstr*    m_Value;            // value to seek 
+    CBotInstr*    m_Block;            // instructions
+
+public:
+                CBotSwitch();
+                ~CBotSwitch();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotCase : public CBotInstr
+{
+private:
+    CBotInstr*    m_Value;            // value to compare
+
+public:
+                CBotCase();
+                ~CBotCase();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+    bool        CompCase(CBotStack* &pj, int val);
+};
+
+class CBotCatch : public CBotInstr
+{
+private:
+    CBotInstr*    m_Block;            // instructions
+    CBotInstr*    m_Cond;                //condition
+    CBotCatch*    m_next;                //following catch
+    friend class CBotTry;
+
+public:
+                CBotCatch();
+                ~CBotCatch();
+    static
+    CBotCatch*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        TestCatch(CBotStack* &pj, int val);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+    void        RestoreCondState(CBotStack* &pj, bool bMain);
+};
+
+class CBotTry : public CBotInstr
+{
+private:
+    CBotInstr*    m_Block;            // instructions
+    CBotCatch*    m_ListCatch;        // catches
+    CBotInstr*    m_FinalInst;        // final instruction
+
+public:
+                CBotTry();
+                ~CBotTry();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotThrow : public CBotInstr
+{
+private:
+    CBotInstr*    m_Value;            // the value to send
+
+public:
+                CBotThrow();
+                ~CBotThrow();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotStartDebugDD : public CBotInstr
+{
+private:
+
+public:
+                CBotStartDebugDD();
+                ~CBotStartDebugDD();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+};
+
+
+class CBotIf : public CBotInstr
+{
+private:
+    CBotInstr*    m_Condition;        // condition
+    CBotInstr*    m_Block;            // instructions
+    CBotInstr*    m_BlockElse;        // instructions
+
+public:
+                CBotIf();
+                ~CBotIf();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+// definition of an integer
+
+class CBotInt : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // the variable to initialize
+    CBotInstr*    m_expr;                // a value to put, if there is
+///    CBotInstr*    m_next;                // several definitions chained
+
+public:
+                CBotInt();
+                ~CBotInt();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool cont = false, bool noskip = false);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// definition of an array
+
+class CBotInstArray : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // the variables to initialize
+    CBotInstr*    m_listass;            // list of assignments for array
+    CBotTypResult
+                m_typevar;            // type of elements
+//    CBotString    m_ClassName;
+
+public:
+                CBotInstArray();
+                ~CBotInstArray();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+// definition of a assignment list for a table 
+// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
+
+class CBotListArray : public CBotInstr
+{
+private:
+    CBotInstr*    m_expr;                // an expression for an element
+                                    // others are linked with CBotInstr :: m_next3;
+public:
+                CBotListArray();
+                ~CBotListArray();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);
+    bool        Execute(CBotStack* &pj, CBotVar* pVar);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotEmpty : public CBotInstr
+{
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// defininition of a boolean
+
+class CBotBoolean : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // variable to initialise
+    CBotInstr*    m_expr;                // a value to put, if there is
+
+public:
+                CBotBoolean();
+                ~CBotBoolean();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool cont = false, bool noskip=false);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+// definition of a real number
+
+class CBotFloat : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // variable to initialise
+    CBotInstr*    m_expr;                // a value to put, if there is
+
+public:
+                CBotFloat();
+                ~CBotFloat();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool cont = false, bool noskip=false);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// definition of an element string
+
+class CBotIString : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // variable to initialise
+    CBotInstr*    m_expr;                // a value to put, if there is
+
+public:
+                CBotIString();
+                ~CBotIString();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool cont = false, bool noskip=false);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// definition of an element of any class
+
+class CBotClassInst : public CBotInstr
+{
+private:
+    CBotInstr*    m_var;                // variable to initialise
+    CBotClass*    m_pClass;            // reference to the class
+    CBotInstr*    m_Parameters;        // parameters to be evaluated for the contructor
+    CBotInstr*    m_expr;                // a value to put, if there is
+    bool        m_hasParams;        // has it parameters?
+    long        m_nMethodeIdent;
+
+public:
+                CBotClassInst();
+                ~CBotClassInst();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass = NULL);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotCondition : public CBotInstr
+{
+private:
+
+public:
+
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+};
+
+
+// left operand
+// accept the expressions that be to the left of assignment
+
+class CBotLeftExpr : public CBotInstr
+{
+private:
+    long        m_nIdent;
+
+public:
+                CBotLeftExpr();
+                ~CBotLeftExpr();
+    static
+    CBotLeftExpr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pStack, CBotStack* array);
+
+    bool        ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep);
+    void        RestoreStateVar(CBotStack* &pile, bool bMain);
+};
+
+
+// management of the fields of an instance
+
+class CBotFieldExpr : public CBotInstr
+{
+private:
+    friend class CBotExpression;
+    int            m_nIdent;
+
+public:
+                CBotFieldExpr();
+                ~CBotFieldExpr();
+    void        SetUniqNum(int num);
+//    static
+//    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend);
+    void        RestoreStateVar(CBotStack* &pj, bool bMain);
+};
+
+// management of indices of the tables
+
+class CBotIndexExpr : public CBotInstr
+{
+private:
+    CBotInstr*     m_expr;                    // expression for calculating the index
+    friend class CBotLeftExpr;
+    friend class CBotExprVar;
+
+public:
+                CBotIndexExpr();
+                ~CBotIndexExpr();
+//    static
+//    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep, bool bExtend);
+    void        RestoreStateVar(CBotStack* &pj, bool bMain);
+};
+
+// expressions like
+// x = a;
+// x * y + 3;
+
+class CBotExpression : public CBotInstr
+{
+private:
+    CBotLeftExpr*    m_leftop;            // left operand
+    CBotInstr*        m_rightop;            // right operant
+
+public:
+                CBotExpression();
+                ~CBotExpression();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pStack);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotListExpression : public CBotInstr
+{
+private:
+    CBotInstr*    m_Expr;                // the first expression to be evaluated
+
+public:
+                CBotListExpression();
+                ~CBotListExpression();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pStack);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotLogicExpr : public CBotInstr
+{
+private:
+    CBotInstr*    m_condition;        // test to evaluate
+    CBotInstr*    m_op1;                // left element
+    CBotInstr*    m_op2;                // right element
+    friend class CBotTwoOpExpr;
+
+public:
+                CBotLogicExpr();
+                ~CBotLogicExpr();
+//    static
+//    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pStack);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+
+class CBotBoolExpr : public CBotInstr
+{
+private:
+
+public:
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+};
+
+
+
+// possibly an expression in parentheses ( ... )
+// there is never an instance of this class
+// being the object returned inside the parenthesis
+class CBotParExpr : public CBotInstr
+{
+private:
+
+public:
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+};
+
+// unary expression
+class CBotExprUnaire : public CBotInstr
+{
+private:
+    CBotInstr*    m_Expr;                // expression to be evaluated
+public:
+                CBotExprUnaire();
+                ~CBotExprUnaire();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pStack);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// all operations with two operands
+
+class CBotTwoOpExpr : public CBotInstr
+{
+private:
+    CBotInstr*    m_leftop;            // left element
+    CBotInstr*    m_rightop;            // right element
+public:
+                CBotTwoOpExpr();
+                ~CBotTwoOpExpr();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations = NULL);
+    bool        Execute(CBotStack* &pStack);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+
+
+// an instruction block { .... }
+class CBotBlock : public CBotInstr
+{
+private:
+
+public:
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool bLocal = true);
+    static
+    CBotInstr*    CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, bool bLocal = false);
+};
+
+
+// the content of a block of instructions ... ; ... ; ... ; ... ;
+class CBotListInstr : public CBotInstr
+{
+private:
+    CBotInstr*    m_Instr;            // instructions to do
+
+public:
+                CBotListInstr();
+                ~CBotListInstr();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, bool bLocal = true);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotInstrCall : public CBotInstr
+{
+private:
+    CBotInstr*    m_Parameters;        // the parameters to be evaluated
+//    int            m_typeRes;            // type of the result
+//    CBotString    m_RetClassName;        // class of the result
+    CBotTypResult
+                m_typRes;            // complete type of the result
+    long        m_nFuncIdent;        // id of a function
+
+public:
+                CBotInstrCall();
+                ~CBotInstrCall();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// a call of method
+
+class CBotInstrMethode : public CBotInstr
+{
+private:
+    CBotInstr*    m_Parameters;        // the parameters to be evaluated
+//    int            m_typeRes;            // type of the result
+//    CBotString    m_RetClassName;        // class of the result
+    CBotTypResult
+                m_typRes;            // complete type of the result
+
+    CBotString    m_NomMethod;        // name of the method
+    long        m_MethodeIdent;        // identifier of the method
+//    long        m_nThisIdent;        // identifier for "this"
+    CBotString    m_ClassName;        // name of the class
+
+public:
+                CBotInstrMethode();
+                ~CBotInstrMethode();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* pVar);
+    bool        Execute(CBotStack* &pj);
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, bool bStep, bool bExtend);
+    void        RestoreStateVar(CBotStack* &pj, bool bMain);
+};
+
+// expression for the variable name
+
+class CBotExprVar : public CBotInstr
+{
+private:
+    long        m_nIdent;
+    friend class CBotPostIncExpr;
+    friend class CBotPreIncExpr;
+
+public:
+                CBotExprVar();
+                ~CBotExprVar();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack, int privat=PR_PROTECT);
+    static
+    CBotInstr*    CompileMethode(CBotToken* &p, CBotCStack* pStack);
+
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+    bool        ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, bool bStep);
+    bool        Execute2Var(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, bool bStep);
+    void        RestoreStateVar(CBotStack* &pj, bool bMain);
+};
+
+class CBotPostIncExpr : public CBotInstr
+{
+private:
+    CBotInstr*    m_Instr;
+    friend class CBotParExpr;
+
+public:
+                CBotPostIncExpr();
+                ~CBotPostIncExpr();
+//    static
+//    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotPreIncExpr : public CBotInstr
+{
+private:
+    CBotInstr*    m_Instr;
+    friend class CBotParExpr;
+
+public:
+                CBotPreIncExpr();
+                ~CBotPreIncExpr();
+//    static
+//    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotLeftExprVar : public CBotInstr
+{
+private:
+public:
+    CBotTypResult
+                m_typevar;            // type of variable declared
+    long        m_nIdent;            // unique identifier for that variable
+
+public:
+                CBotLeftExprVar();
+                ~CBotLeftExprVar();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotExprBool : public CBotInstr
+{
+private:
+
+public:
+                CBotExprBool();
+                ~CBotExprBool();
+
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+class CBotExprNull : public CBotInstr
+{
+private:
+
+public:
+                CBotExprNull();
+                ~CBotExprNull();
+
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotExprNan : public CBotInstr
+{
+private:
+
+public:
+                CBotExprNan();
+                ~CBotExprNan();
+
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+class CBotNew : public CBotInstr
+{
+private:
+    CBotInstr*    m_Parameters;        // the parameters to be evaluated
+    long        m_nMethodeIdent;
+//    long        m_nThisIdent;
+    CBotToken    m_vartoken;
+
+public:
+                CBotNew();
+                ~CBotNew();
+
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+// expression representing a number
+
+class CBotExprNum : public CBotInstr
+{
+private:
+    int            m_numtype;                    // et the type of number
+    long        m_valint;                    // value for an int
+    float        m_valfloat;                    // value for a float
+
+public:
+                CBotExprNum();
+                ~CBotExprNum();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+
+// expression representing a string
+
+class CBotExprAlpha : public CBotInstr
+{
+private:
+
+public:
+                CBotExprAlpha();
+                ~CBotExprAlpha();
+    static
+    CBotInstr*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool        Execute(CBotStack* &pj);
+    void        RestoreState(CBotStack* &pj, bool bMain);
+};
+
+
+#define    MAX(a,b)    ((a>b) ? a : b)
+
+
+// class for the management of integer numbers (int)
+class CBotVarInt : public CBotVar
+{
+private:
+    int            m_val;            // the value
+    CBotString    m_defnum;        // the name if given by DefineNum
+    friend class CBotVar;
+
+public:
+                CBotVarInt( const CBotToken* name );
+//                ~CBotVarInt();
+
+    void        SetValInt(int val, const char* s = NULL);
+    void        SetValFloat(float val);
+    int            GivValInt();
+    float        GivValFloat();
+    CBotString    GivValString();
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+
+
+    void        Add(CBotVar* left, CBotVar* right);    // addition
+    void        Sub(CBotVar* left, CBotVar* right);    // substraction
+    void        Mul(CBotVar* left, CBotVar* right);    // multiplication
+    int            Div(CBotVar* left, CBotVar* right);    // division
+    int            Modulo(CBotVar* left, CBotVar* right);    // remainder of division
+    void        Power(CBotVar* left, CBotVar* right);    // power
+
+    bool        Lo(CBotVar* left, CBotVar* right);
+    bool        Hi(CBotVar* left, CBotVar* right);
+    bool        Ls(CBotVar* left, CBotVar* right);
+    bool        Hs(CBotVar* left, CBotVar* right);
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+
+    void        XOr(CBotVar* left, CBotVar* right);
+    void        Or(CBotVar* left, CBotVar* right);
+    void        And(CBotVar* left, CBotVar* right);
+
+    void        SL(CBotVar* left, CBotVar* right);
+    void        SR(CBotVar* left, CBotVar* right);
+    void        ASR(CBotVar* left, CBotVar* right);
+
+    void        Neg();
+    void        Not();
+    void        Inc();
+    void        Dec();
+
+    bool        Save0State(FILE* pf);
+    bool        Save1State(FILE* pf);
+
+};
+
+// Class for managing real numbers (float)
+class CBotVarFloat : public CBotVar
+{
+private:
+    float        m_val;        // the value
+
+public:
+                CBotVarFloat( const CBotToken* name );
+//                ~CBotVarFloat();
+
+    void        SetValInt(int val, const char* s = NULL);
+    void        SetValFloat(float val);
+    int            GivValInt();
+    float        GivValFloat();
+    CBotString    GivValString();
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+
+
+    void        Add(CBotVar* left, CBotVar* right);    // addition
+    void        Sub(CBotVar* left, CBotVar* right);    // substraction
+    void        Mul(CBotVar* left, CBotVar* right);    // multiplication
+    int         Div(CBotVar* left, CBotVar* right);    // division
+    int            Modulo(CBotVar* left, CBotVar* right);    // remainder of division
+    void        Power(CBotVar* left, CBotVar* right);    // power
+
+    bool        Lo(CBotVar* left, CBotVar* right);
+    bool        Hi(CBotVar* left, CBotVar* right);
+    bool        Ls(CBotVar* left, CBotVar* right);
+    bool        Hs(CBotVar* left, CBotVar* right);
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+
+    void        Neg();
+    void        Inc();
+    void        Dec();
+
+    bool        Save1State(FILE* pf);
+};
+
+
+// class for management of strings (String)
+class CBotVarString : public CBotVar
+{
+private:
+    CBotString    m_val;        // the value
+
+public:
+                CBotVarString( const CBotToken* name );
+//                ~CBotVarString();
+
+    void        SetValString(const char* p);
+    CBotString    GivValString();
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+
+    void        Add(CBotVar* left, CBotVar* right);    // addition
+
+    bool        Lo(CBotVar* left, CBotVar* right);
+    bool        Hi(CBotVar* left, CBotVar* right);
+    bool        Ls(CBotVar* left, CBotVar* right);
+    bool        Hs(CBotVar* left, CBotVar* right);
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+
+    bool        Save1State(FILE* pf);
+};
+
+// class for the management of boolean
+class CBotVarBoolean : public CBotVar
+{
+private:
+    bool        m_val;        // the value
+
+public:
+                CBotVarBoolean( const CBotToken* name );
+//                ~CBotVarBoolean();
+
+    void        SetValInt(int val, const char* s = NULL);
+    void        SetValFloat(float val);
+    int            GivValInt();
+    float        GivValFloat();
+    CBotString    GivValString();
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+
+    void        And(CBotVar* left, CBotVar* right);
+    void        Or(CBotVar* left, CBotVar* right);
+    void        XOr(CBotVar* left, CBotVar* right);
+    void        Not();
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+
+    bool        Save1State(FILE* pf);
+};
+
+
+// class management class instances
+class CBotVarClass : public CBotVar
+{
+private:
+    static
+    CBotVarClass*    m_ExClass;        // list of existing instances at some point
+    CBotVarClass*    m_ExNext;        // for this general list
+    CBotVarClass*    m_ExPrev;        // for this general list
+
+private:
+    CBotClass*        m_pClass;        // the class definition
+    CBotVarClass*    m_pParent;        // the instance of a parent class
+    CBotVar*        m_pVar;            // contents
+    friend class    CBotVar;        // my daddy is a buddy WHAT? :D(\TODO mon papa est un copain )
+    friend class    CBotVarPointer;    // and also the pointer
+    int                m_CptUse;        // counter usage
+    long            m_ItemIdent;    // identifier (unique) of an instance
+    bool            m_bConstructor;    // set if a constructor has been called
+
+public:
+                CBotVarClass( const CBotToken* name, const CBotTypResult& type );
+//                CBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );
+                ~CBotVarClass();
+//    void        InitCBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+    void        SetClass(CBotClass* pClass); //, int &nIdent);
+    CBotClass*    GivClass();
+    CBotVar*    GivItem(const char* name);    // return an element of a class according to its name (*)
+    CBotVar*    GivItemRef(int nIdent);
+
+    CBotVar*    GivItem(int n, bool bExtend);
+    CBotVar*    GivItemList();
+
+    CBotString    GivValString();
+
+    bool        Save1State(FILE* pf);
+    void        Maj(void* pUser, bool bContinue);
+
+    void        IncrementUse();                // a reference to incrementation
+    void        DecrementUse();                // a reference to decrementation
+
+    CBotVarClass* 
+                GivPointer();
+    void        SetItemList(CBotVar* pVar);
+
+    void        SetIdent(long n);
+    
+    static CBotVarClass* Find(long id);
+
+
+//    CBotVar*    GivMyThis();
+
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+
+    void        ConstructorSet();
+};
+
+
+// class for the management of pointers to a class instances
+class CBotVarPointer : public CBotVar
+{
+private:
+    CBotVarClass*
+                m_pVarClass;        // contents
+    CBotClass*    m_pClass;            // class provided for this pointer
+    friend class CBotVar;            // my daddy is a buddy
+
+public:
+                CBotVarPointer( const CBotToken* name, CBotTypResult& type );
+                ~CBotVarPointer();
+
+    void        Copy(CBotVar* pSrc, bool bName=true);
+    void        SetClass(CBotClass* pClass);
+    CBotClass*    GivClass();
+    CBotVar*    GivItem(const char* name);    // return an element of a class according to its name (*)
+    CBotVar*    GivItemRef(int nIdent);
+    CBotVar*    GivItemList();
+
+    CBotString    GivValString();
+    void        SetPointer(CBotVar* p);
+    CBotVarClass*
+                GivPointer();
+
+    void        SetIdent(long n);            // associates an identification number (unique)
+    long        GivIdent();                    // gives the identification number associated with
+    void        ConstructorSet();
+
+    bool        Save1State(FILE* pf);
+    void        Maj(void* pUser, bool bContinue);
+
+    bool        Eq(CBotVar* left, CBotVar* right);
+    bool        Ne(CBotVar* left, CBotVar* right);
+};
+
+
+// classe pour les tableaux
+
+#define    MAXARRAYSIZE    9999
+
+class CBotVarArray : public CBotVar
+{
+private:
+    CBotVarClass*
+                m_pInstance;                // instance manager of table
+
+    friend class CBotVar;                    // my daddy is a buddy
+
+public:
+                CBotVarArray( const CBotToken* name, CBotTypResult& type );
+                ~CBotVarArray();
+
+    void        SetPointer(CBotVar* p);
+    CBotVarClass*
+                GivPointer();
+    
+    void        Copy(CBotVar* pSrc, bool bName=true);
+    CBotVar*    GivItem(int n, bool bGrow=false);    // makes an element according to its numeric index
+                                                // enlarged the table if necessary if bExtend
+//    CBotVar*    GivItem(const char* name);        // makes a element by  literal index
+    CBotVar*    GivItemList();                    // gives the first item in the list
+
+    CBotString    GivValString();                    // gets the contents of the array into a string
+
+    bool        Save1State(FILE* pf);
+};
+
+
+extern CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars);
+
+extern bool TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op = 0 );
+extern bool TypesCompatibles( const CBotTypResult& type1, const CBotTypResult& type2 );
+
+extern bool WriteWord(FILE* pf, unsigned short w);
+extern bool ReadWord(FILE* pf, unsigned short& w);
+extern bool ReadLong(FILE* pf, long& w);
+extern bool WriteFloat(FILE* pf, float w);
+extern bool WriteLong(FILE* pf, long w);
+extern bool ReadFloat(FILE* pf, float& w);
+extern bool WriteString(FILE* pf, CBotString s);
+extern bool ReadString(FILE* pf, CBotString& s);
+extern bool WriteType(FILE* pf, CBotTypResult type);
+extern bool ReadType(FILE* pf, CBotTypResult& type);
+
+extern float GivNumFloat( const char* p );
+
+#if    false
+extern void DEBUG( const char* text, int val, CBotStack* pile );
+#endif
+
+///////////////////////////////////////////
+// class for routine calls (external)
+
+class CBotCall
+{
+private:
+    static
+    CBotCall*    m_ListCalls;
+    static
+    void*        m_pUser;
+    long        m_nFuncIdent;
+
+private:
+    CBotString    m_name;
+    bool        (*m_rExec) (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser) ;
+    CBotTypResult
+                (*m_rComp) (CBotVar* &pVar, void* pUser)    ;
+    CBotCall*    m_next;
+
+public:
+                CBotCall(const char* name, 
+                         bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                         CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
+                ~CBotCall();
+
+    static
+    bool        AddFunction(const char* name, 
+                            bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                            CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
+
+    static
+    CBotTypResult
+                CompileCall(CBotToken* &p, CBotVar** ppVars, CBotCStack* pStack, long& nIdent);
+    static
+    bool        CheckCall(const char* name);
+
+//    static
+//    int            DoCall(CBotToken* &p, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);
+    static
+    int            DoCall(long& nIdent, CBotToken* token, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);
+#if    STACKRUN
+    bool        Run(CBotStack* pStack);
+    static
+    bool        RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack);
+#endif
+
+    CBotString    GivName();
+    CBotCall*    Next();
+    
+    static void    SetPUser(void* pUser);
+    static void    Free();
+};
+
+// class managing the methods declared by AddFunction on a class
+
+class CBotCallMethode
+{
+private:
+    CBotString    m_name;
+    bool        (*m_rExec) (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception);
+    CBotTypResult
+                (*m_rComp) (CBotVar* pThis, CBotVar* &pVar);
+    CBotCallMethode*    m_next;
+    friend class CBotClass;
+    long        m_nFuncIdent;
+
+public:
+                CBotCallMethode(const char* name, 
+                         bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 
+                         CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
+                ~CBotCallMethode();
+
+    CBotTypResult
+                CompileCall(const char* name, CBotVar* pThis, 
+                            CBotVar** ppVars, CBotCStack* pStack,
+                            long& nIdent);
+
+    int            DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pFunc);
+
+    CBotString    GivName();
+    CBotCallMethode*    Next();
+    void        AddNext(CBotCallMethode* p);
+    
+};
+
+// a list of parameters
+
+class CBotDefParam
+{
+private:
+    CBotToken        m_token;        // name of the parameter
+    CBotString        m_typename;        // type name
+    CBotTypResult    m_type;            // type of paramteter
+    CBotDefParam*    m_next;            // next parameter
+    long            m_nIdent;
+
+public:
+                    CBotDefParam();
+                    ~CBotDefParam();
+    static
+    CBotDefParam*    Compile(CBotToken* &p, CBotCStack* pStack);
+    bool            Execute(CBotVar** ppVars, CBotStack* &pj);
+    void            RestoreState(CBotStack* &pj, bool bMain);
+
+    void            AddNext(CBotDefParam* p);
+    int                GivType();
+    CBotTypResult    GivTypResult();
+    CBotDefParam*    GivNext();
+
+    CBotString        GivParamString();
+};
+
+
+// a function declaration
+
+class CBotFunction : CBotInstr
+{
+private:
+    // management of list of (static) public functions
+    static
+    CBotFunction*    m_listPublic;
+    CBotFunction*    m_nextpublic;
+    CBotFunction*    m_prevpublic;
+    friend class    CBotCStack;
+//    long            m_nThisIdent;
+    long            m_nFuncIdent;
+    bool            m_bSynchro;        // synchronized method?
+
+private:
+    CBotDefParam*    m_Param;        // parameter list
+    CBotInstr*        m_Block;        // the instruction block
+    CBotFunction*    m_next;
+    CBotToken        m_retToken;        // if returns CBotTypClass
+    CBotTypResult    m_retTyp;        // complete type of the result
+
+    bool            m_bPublic;        // public function
+    bool            m_bExtern;        // extern function
+    CBotString        m_MasterClass;    // name of the class we derive
+    CBotProgram*    m_pProg;
+    friend class CBotProgram;
+    friend class CBotClass;
+
+    CBotToken        m_extern;        // for the position of the word "extern"
+    CBotToken        m_openpar;
+    CBotToken        m_closepar;
+    CBotToken        m_openblk;
+    CBotToken        m_closeblk;
+public:
+                    CBotFunction();
+                    ~CBotFunction();
+    static
+    CBotFunction*    Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* pFunc, bool bLocal = true);
+    static
+    CBotFunction*    Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass*    pClass);
+    bool            Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);
+    void            RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);
+
+    void            AddNext(CBotFunction* p);
+    CBotTypResult    CompileCall(const char* name, CBotVar** ppVars, long& nIdent);
+    CBotFunction*    FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, bool bPublic = true);
+
+    int                DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken);
+    void            RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack);
+    int                DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass);
+    void            RestoreCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass);
+    bool            CheckParam(CBotDefParam* pParam);
+
+    static
+    void            AddPublic(CBotFunction* pfunc);
+
+    CBotString        GivName();
+    CBotString        GivParams();
+    bool            IsPublic();
+    bool            IsExtern();
+    CBotFunction*    Next();
+
+    bool            GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop);
+};
+
+
diff --git a/src/CBot/CBot.rc b/src/CBot/CBot.rc
deleted file mode 100644
index d8b5b74..0000000
--- a/src/CBot/CBot.rc
+++ /dev/null
@@ -1,279 +0,0 @@
-//Microsoft Developer Studio generated resource script.

-//

-#include "resource.h"

-

-#define APSTUDIO_READONLY_SYMBOLS

-/////////////////////////////////////////////////////////////////////////////

-//

-// Generated from the TEXTINCLUDE 2 resource.

-//

-#include "afxres.h"

-

-/////////////////////////////////////////////////////////////////////////////

-#undef APSTUDIO_READONLY_SYMBOLS

-

-/////////////////////////////////////////////////////////////////////////////

-// French (France) resources

-

-#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)

-#ifdef _WIN32

-LANGUAGE LANG_FRENCH, SUBLANG_FRENCH

-#pragma code_page(1252)

-#endif //_WIN32

-

-#ifdef APSTUDIO_INVOKED

-/////////////////////////////////////////////////////////////////////////////

-//

-// TEXTINCLUDE

-//

-

-1 TEXTINCLUDE DISCARDABLE 

-BEGIN

-    "resource.h\0"

-END

-

-2 TEXTINCLUDE DISCARDABLE 

-BEGIN

-    "#include ""afxres.h""\r\n"

-    "\0"

-END

-

-3 TEXTINCLUDE DISCARDABLE 

-BEGIN

-    "\r\n"

-    "\0"

-END

-

-#endif    // APSTUDIO_INVOKED

-

-

-/////////////////////////////////////////////////////////////////////////////

-//

-// String Table

-//

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_IF                   "if"

-    ID_ELSE                 "else"

-    ID_WHILE                "while"

-    ID_DO                   "do"

-    ID_FOR                  "for"

-    ID_BREAK                "break"

-    ID_CONTINUE             "continue"

-    ID_SWITCH               "switch"

-    ID_CASE                 "case"

-    ID_DEFAULT              "default"

-    ID_TRY                  "try"

-    ID_THROW                "throw"

-    ID_CATCH                "catch"

-    ID_FINALLY              "finally"

-    ID_TXT_AND              "and"

-    ID_TXT_OR               "or"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_DEBUGDD              "STARTDEBUGDD"

-    ID_INT                  "int"

-    ID_FLOAT                "float"

-    ID_BOOLEAN              "boolean"

-    ID_STRING               "string"

-    ID_VOID                 "void"

-    ID_BOOL                 "bool"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_TXT_NOT              "not"

-    ID_RETURN               "return"

-    ID_CLASS                "class"

-    ID_EXTENDS              "extends"

-    ID_SYNCHO               "synchronized"

-    ID_NEW                  "new"

-    ID_PUBLIC               "public"

-    ID_EXTERN               "extern"

-    ID_FINAL                "final"

-    ID_STATIC               "static"

-    ID_PROTECTED            "protected"

-    ID_PRIVATE              "private"

-    ID_REPEAT               "repeat"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_OPENPAR              "Il manque une parenthèse ouvrante."

-    TX_CLOSEPAR             "Il manque une parenthèse fermante."

-    TX_NOTBOOL              "L'expression doit être un boolean."

-    TX_UNDEFVAR             "Variable non déclarée."

-    TX_BADLEFT              "Assignation impossible."

-    TX_ENDOF                "Terminateur point-virgule non trouvé."

-    TX_OUTCASE              "Instruction ""case"" hors d'un bloc ""switch""."

-    TX_NOTERM               "Instructions après la fin."

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_CLOSEBLK             "Il manque la fin du bloc."

-    TX_ELSEWITHOUTIF        "Instruction ""else"" sans ""if"" correspondant."

-    TX_OPENBLK              "Début d'un bloc attendu."

-    TX_BADTYPE              "Mauvais type de résultat pour l'assignation."

-    TX_REDEFVAR             "Redéfinition d'une variable."

-    TX_BAD2TYPE             "Les deux opérandes ne sont pas de types compatibles."

-    TX_UNDEFCALL            "Routine inconnue."

-    TX_MISDOTS              "Séparateur "" : "" attendu."

-    TX_WHILE                "Manque le mot ""while""."

-    TX_BREAK                "Instruction ""break"" en dehors d'une boucle."

-    TX_LABEL                "Un label ne peut se placer que devant un ""for"", un ""while"" ou un ""do""."

-    TX_NOLABEL              "Cette étiquette n'existe pas"

-    TX_NOCASE               "Manque une instruction ""case""."

-    TX_BADNUM               "Un nombre est attendu."

-    TX_VOID                 "Paramètre void."

-    TX_NOTYP                "Déclaration de type attendu."

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_DIVZERO              "Division par zéro."

-    TX_NOTINIT              "Variable non initialisée."

-    TX_BADTHROW             "Valeur négative refusée pour ""throw""."

-    TX_NORETVAL             "La fonction n'a pas retourné de résultat"

-    TX_NORUN                "Pas de fonction en exécution"

-    TX_NOCALL               "Appel d'une fonction inexistante"

-    TX_NOCLASS              "Cette classe n'existe pas"

-    TX_NULLPT               "Pointeur nul."

-    TX_OPNAN                "Opération sur un ""nan"""

-    TX_OUTARRAY             "Accès hors du tableau"

-    TX_STACKOVER            "Dépassement de la pile"

-    TX_DELETEDPT            "Pointeur à un objet détruit"

-    TX_FILEOPEN             "Ouverture du fichier impossible"

-    TX_NOTOPEN              "Fichier pas ouvert"

-    TX_ERRREAD              "Erreur de lecture"

-    TX_ERRWRITE             "Erreur d'écriture"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_NOVAR                "Nom d'une variable attendu."

-    TX_NOFONC               "Nom de la fonction attendu."

-    TX_OVERPARAM            "Trop de paramètres."

-    TX_REDEF                "Cette fonction existe déjà."

-    TX_LOWPARAM             "Pas assez de paramètres."

-    TX_BADPARAM             "Aucune fonction de ce nom n'accepte ce(s) type(s) de paramètre(s)."

-    TX_NUMPARAM             "Aucune fonction de ce nom n'accepte ce nombre de paramètres."

-    TX_NOITEM               "Cet élément n'existe pas dans cette classe."

-    TX_DOT                  "L'objet n'est pas une instance d'une classe."

-    TX_NOCONST              "Il n'y a pas de constructeur approprié."

-    TX_REDEFCLASS           "Cette classe existe déjà."

-    TX_CLBRK                """ ] "" attendu."

-    TX_RESERVED             "Ce mot est réservé."

-    TX_BADNEW               "Mauvais argument pour ""new""."

-    TX_OPBRK                """ [ "" attendu."

-    TX_BADSTRING            "Une chaîne de caractère est attendue."

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_BADINDEX             "Mauvais type d'index"

-    TX_PRIVATE              "Membre privé de la classe"

-    TX_NOPUBLIC             """public"" manque"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_OPENPAR              "("

-    ID_CLOSEPAR             ")"

-    ID_OPBLK                "{"

-    ID_CLBLK                "}"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_SEP                  ";"

-    ID_COMMA                ","

-    ID_DOTS                 ":"

-    ID_DOT                  "."

-    ID_OPBRK                "["

-    ID_CLBRK                "]"

-    ID_DBLDOTS              "::"

-    ID_LOGIC                "?"

-    ID_ADD                  "+"

-    ID_SUB                  "-"

-    ID_MUL                  "*"

-    ID_DIV                  "/"

-    ID_ASS                  "="

-    ID_ASSADD               "+="

-    ID_ASSSUB               "-="

-    ID_ASSMUL               "*="

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_TRUE                 "true"

-    ID_FALSE                "false"

-    ID_NULL                 "null"

-    ID_NAN                  "nan"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_ASSDIV               "/="

-    ID_ASSOR                "|="

-    ID_ASSAND               "&="

-    ID_ASSXOR               "^="

-    ID_ASSSL                "<<="

-    ID_ASSSR                ">>>="

-    ID_ASSASR               ">>="

-    ID_SL                   "<<"

-    ID_SR                   ">>>"

-    ID_ASR                  ">>"

-    ID_INC                  "++"

-    ID_DEC                  "--"

-    ID_LO                   "<"

-    ID_HI                   ">"

-    ID_LS                   "<="

-    ID_HS                   ">="

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_EQ                   "=="

-    ID_NE                   "!="

-    ID_AND                  "&"

-    ID_XOR                  "^"

-    ID_OR                   "|"

-    ID_LOG_AND              "&&"

-    ID_LOG_OR               "||"

-    ID_LOG_NOT              "!"

-    ID_NOT                  "~"

-    ID_MODULO               "%"

-    ID_POWER                "**"

-    ID_ASSMODULO            "%="

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    TX_UNDEF                "undefined"

-    TX_NAN                  "not a number"

-END

-

-STRINGTABLE DISCARDABLE 

-BEGIN

-    ID_SUPER                "super"

-END

-

-#endif    // French (France) resources

-/////////////////////////////////////////////////////////////////////////////

-

-

-

-#ifndef APSTUDIO_INVOKED

-/////////////////////////////////////////////////////////////////////////////

-//

-// Generated from the TEXTINCLUDE 3 resource.

-//

-

-

-/////////////////////////////////////////////////////////////////////////////

-#endif    // not APSTUDIO_INVOKED

-

diff --git a/src/CBot/CBotAddExpr.cpp b/src/CBot/CBotAddExpr.cpp
index ad87880..231f008 100644
--- a/src/CBot/CBotAddExpr.cpp
+++ b/src/CBot/CBotAddExpr.cpp
@@ -1,142 +1,144 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////

-// expression du genre Opérande1 + Opérande2

-//					   Opérande1 - Opérande2

-

-#include "CBot.h"

-

-// divers constructeurs

-

-CBotAddExpr::CBotAddExpr()

-{

-	m_leftop	=

-	m_rightop	= NULL;			// NULL pour pouvoir faire delete sans autre

-	name = "CBotAddExpr";		// debug

-}

-

-CBotAddExpr::~CBotAddExpr()

-{

-	delete	m_leftop;

-	delete	m_rightop;

-}

-

-

-// compile une instruction de type A + B

-

-CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack)

-{

-	CBotStack* pStk = pStack->TokenStack();					// un bout de pile svp

-

-	// cherche des instructions qui peuvent convenir à gauche de l'opération + ou -

-

-	CBotInstr*	left = CBotMulExpr::Compile( p, pStk );		// expression A * B à gauche

-	if (left == NULL) return pStack->Return(NULL, pStk);	// si erreur, la transmet

-

-	// est-ce qu'on a le token + ou - ensuite ?

-

-	if ( p->GetType() == ID_ADD ||

-		 p->GetType() == ID_SUB)							// plus ou moins

-	{

-		CBotAddExpr* inst = new CBotAddExpr();				// élément pour opération

-		inst->SetToken(p);									// mémorise l'opération

-

-		int			 type1, type2;

-		type1 = pStack->GetType();							// de quel type le premier opérande ?

-

-		p = p->Next();										// saute le token de l'opération 

-

-		// cherche des instructions qui peuvent convenir à droite

-

-		if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) )	// expression (...) à droite

-		{

-			// il y a un second opérande acceptable

-

-			type2 = pStack->GetType();						// de quel type le résultat ?

-

-			if ( type1 == type2 )							// les résultats sont-ils compatibles

-			{

-				// si ok, enregistre l'opérande dans l'objet

-				inst->m_leftop = left;

-				// et rend l'object à qui l'a demandé

-				return pStack->Return(inst, pStk);

-			}

-		}

-

-		// en cas d'erreur, libère les éléments

-		delete left;

-		delete inst;

-		// et transmet l'erreur qui se trouve sur la pile

-		return pStack->Return(NULL, pStk);

-	}

-

-	// si on n'a pas affaire à une opération + ou -

-	// rend à qui l'a demandé, l'opérande (de gauche) trouvé

-	// à la place de l'objet "addition"

-	return pStack->Return(left, pStk);

-}

-

-

-

-

-// fait l'opération d'addition ou de soustraction

-

-BOOL CBotAddExpr::Execute(CBotStack* &pStack)

-{

-	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-//	if ( pSk1 == EOX ) return TRUE;

-

-

-	// selon la reprise, on peut être dans l'un des 2 états

-

-	if ( pStk1->GetState() == 0 &&				// 1er état, évalue l'opérande de gauche

-		!m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?

-

-	// passe à l'étape suivante

-	pStk1->SetState(1);							// prêt pour la suite

-

-	// demande un peu plus de stack pour ne pas toucher le résultat de gauche

-	// qui se trouve sur la pile, justement.

-

-	CBotStack* pStk2 = pStk1->AddStack();		// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-

-	// 2e état, évalue l'opérande de droite

-	if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?

-

-	int		type1 = pStk1->GetType();			// de quels types les résultats ?

-	int		type2 = pStk2->GetType();

-

-	// crée une variable temporaire pour y mettre le résultat

-	CBotVar*	result = new CBotVar( NULL, MAX(type1, type2));

-

-	// fait l'opération selon la demande

-	switch (GetTokenType())

-	{

-	case ID_ADD:

-		result->Add(pStk1->GetVar(), pStk2->GetVar());		// additionne

-		break;

-	case ID_SUB:

-		result->Sub(pStk1->GetVar(), pStk2->GetVar());		// soustrait

-		break;

-	}

-	pStk2->SetVar(result);						// met le résultat sur la pile

-

-	pStk1->Return(pStk2);						// libère la pile

-	return pStack->Return(pStk1);				// transmet le résultat

-}

-

-

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////
+// expressions of type Operand1 + Operand2
+//                     Operand1 - Operand2
+
+#include "CBot.h"
+
+// various constructors
+
+CBotAddExpr::CBotAddExpr()
+{
+    m_leftop    =
+    m_rightop   = NULL;         // NULL to be able to delete without further
+    name = "CBotAddExpr";       // debug
+}
+
+CBotAddExpr::~CBotAddExpr()
+{
+    delete  m_leftop;
+    delete  m_rightop;
+}
+
+
+// compile une instruction de type A + B
+
+CBotInstr* CBotAddExpr::Compile(CBotToken* &p, CBotStack* pStack)
+{
+    CBotStack* pStk = pStack->TokenStack();                 // one end of stack please
+
+    // looking statements that may be suitable to the left of the operation + or -
+
+    CBotInstr*  left = CBotMulExpr::Compile( p, pStk );     // expression A * B left
+    if (left == NULL) return pStack->Return(NULL, pStk);    // if error, transmit
+
+    // do we have the token + or - next?
+
+    if ( p->GetType() == ID_ADD ||
+         p->GetType() == ID_SUB)                            // more or less
+    {
+        CBotAddExpr* inst = new CBotAddExpr();              // element for operation
+        inst->SetToken(p);                                  // stores the operation
+
+        int          type1, type2;
+        type1 = pStack->GetType();                          // what kind of the first operand?
+
+        p = p->Next();                                      // skip the token of the operation
+
+        // looking statements that may be suitable for right
+
+        if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) )  // expression (...) rigth
+        {
+            // there is an acceptable second operand
+
+            type2 = pStack->GetType();                      // what kind of results?
+
+            if ( type1 == type2 )                           // are the results consistent ?
+            {
+                // ok so, saves the operand in the object
+                inst->m_leftop = left;
+                // and makes the object on demand
+                return pStack->Return(inst, pStk);
+            }
+        }
+
+        // in case of error, free the elements
+        delete left;
+        delete inst;
+        // and transmits the error that is on the stack
+        return pStack->Return(NULL, pStk);
+    }
+
+    // if we are not dealing with an operation + or - 
+    // goes to that requested, the operand (left) found
+    // place the object "addition"
+    return pStack->Return(left, pStk);
+}
+
+
+
+
+// operation is addition or subtraction
+
+bool CBotAddExpr::Execute(CBotStack* &pStack)
+{
+    CBotStack* pStk1 = pStack->AddStack(this);  // adds an item to the stack
+                                                // or is found in case of recovery
+//  if ( pSk1 == EOX ) return TRUE;
+
+
+    // according to recovery, it may be in one of two states
+
+    if ( pStk1->GetState() == 0 &&              // first state, evaluates the left operand
+        !m_leftop->Execute(pStk1) ) return FALSE; // interrupted here?
+
+    // passes to the next step
+    pStk1->SetState(1);                         // ready for further
+
+    // requires a little more stack to not touch the result of the left
+    // which is on the stack, precisely.
+
+    CBotStack* pStk2 = pStk1->AddStack();       // adds an item to the stack
+                                                // or is found in case of recovery
+
+    // Second state, evaluates the right operand
+    if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrupted here?
+
+    int     type1 = pStk1->GetType();           // what kind of results?
+    int     type2 = pStk2->GetType();
+
+    // creates a temporary variable to put the result
+    CBotVar*    result = new CBotVar( NULL, MAX(type1, type2));
+
+    // is the operation as requested
+    switch (GetTokenType())
+    {
+    case ID_ADD:
+        result->Add(pStk1->GetVar(), pStk2->GetVar());      // addition
+        break;
+    case ID_SUB:
+        result->Sub(pStk1->GetVar(), pStk2->GetVar());      // subtraction
+        break;
+    }
+    pStk2->SetVar(result);                      // puts the result on the stack
+
+    pStk1->Return(pStk2);                       // frees the stack
+    return pStack->Return(pStk1);               // transmits the result
+}
+
+
diff --git a/src/CBot/CBotClass.cpp b/src/CBot/CBotClass.cpp
index 7c097af..a524a8e 100644
--- a/src/CBot/CBotClass.cpp
+++ b/src/CBot/CBotClass.cpp
@@ -1,881 +1,882 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////

-// Gestion des variables de type classe

-//

-

-#include "CBot.h"

-

-

-CBotClass* CBotClass::m_ExClass = NULL;

-

-CBotClass::CBotClass(const char* name, CBotClass* pPapa, BOOL bIntrinsic)

-{

-	m_pParent	= pPapa;

-	m_name		= name;

-	m_pVar		= NULL;

-	m_next		= NULL;

-	m_pCalls	= NULL;

-	m_pMethod	= NULL;

-	m_rMaj		= NULL;

-	m_IsDef		= TRUE;

-	m_bIntrinsic= bIntrinsic;

-	m_cptLock	= 0;

-	m_cptOne	= 0;

-	m_nbVar		= m_pParent == NULL ? 0 : m_pParent->m_nbVar;

-

-	for ( int j= 0; j< 5 ; j++ )

-	{

-		m_ProgInLock[j] = NULL;

-	}

-

-

-	// se place tout seul dans la liste

-	if (m_ExClass) m_ExClass->m_ExPrev = this;

-	m_ExNext  = m_ExClass;

-	m_ExPrev  = NULL;

-	m_ExClass = this;

-

-}

-

-CBotClass::~CBotClass()

-{

-	// retire la classe de la liste

-	if ( m_ExPrev ) m_ExPrev->m_ExNext = m_ExNext;

-	else m_ExClass = m_ExNext;

-

-	if ( m_ExNext ) m_ExNext->m_ExPrev = m_ExPrev;

-	m_ExPrev = NULL;

-	m_ExNext = NULL;

-

-	delete	m_pVar;

-	delete	m_pCalls;

-	delete	m_pMethod;

-

-	delete	m_next;			// libère toutes celle de ce niveau

-}

-

-

-void CBotClass::Free()

-{

-	while ( m_ExClass != NULL )

-	{

-		delete m_ExClass;

-	}

-}

-

-void CBotClass::Purge()

-{

-	if ( this == NULL ) return;

-

-	delete		m_pVar;

-	m_pVar		= NULL;

-	delete		m_pCalls;

-	m_pCalls	= NULL;

-	delete		m_pMethod;

-	m_pMethod	= NULL;

-	m_IsDef		= FALSE;

-

-	m_nbVar		= m_pParent == NULL ? 0 : m_pParent->m_nbVar;

-

-	m_next->Purge();

-	m_next = NULL;			// n'appartient plus à cette chaîne

-}

-

-BOOL CBotClass::Lock(CBotProgram* p)

-{

-	int	i = m_cptLock++;

-

-	if ( i == 0 )

-	{

-		m_cptOne = 1;

-		m_ProgInLock[0] = p;

-		return TRUE;

-	}

-	if ( p == m_ProgInLock[0] ) 

-	{

-		m_cptOne++;

-		m_cptLock--;								// a déjà été compté

-		return TRUE;

-	}

-

-	for ( int j = 1 ; j <= i ; j++)

-	{

-		if ( p == m_ProgInLock[j] )

-		{

-			m_cptLock--;

-			return FALSE;	// déjà en attente

-		}

-	}

-

-	if ( i < 5 )	// maxi 5 en attente

-	{

-		m_ProgInLock[i] = p;						// se place dans la queue

-	}

-	else

-		m_cptLock--;

-

-	return FALSE;

-}

-

-void CBotClass::Unlock()

-{

-	if ( --m_cptOne > 0 ) return ;

-

-	int i = --m_cptLock;

-	if ( i<0 )

-	{

-		m_cptLock = 0;

-		return;

-	}

-

-	for ( int j= 0; j< i ; j++ )

-	{

-		m_ProgInLock[j] = m_ProgInLock[j+1];

-	}

-	m_ProgInLock[i] = 0;

-}

-

-void CBotClass::FreeLock(CBotProgram* p)

-{

-	CBotClass* pClass = m_ExClass;

-

-	while ( pClass != NULL )

-	{

-		if ( p == pClass->m_ProgInLock[0] ) 

-		{

-			pClass->m_cptLock -= pClass->m_cptOne;

-			pClass->m_cptOne = 0;

-		}

-

-		for ( int j = 1; j < 5 ; j++ )

-			if ( p == pClass->m_ProgInLock[j] ) 

-				pClass->m_cptLock--;

-

-		pClass = pClass->m_ExNext;

-	}

-}

-

-

-

-BOOL CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)

-{

-	CBotToken	token(name, CBotString());

-	CBotClass*	pClass = type.GivClass();

-

-	CBotVar*	pVar = CBotVar::Create( name, type );

-///	pVar->SetUniqNum(CBotVar::NextUniqNum());

-	pVar->SetPrivate( mPrivate );

-

-	if ( pClass != NULL )

-	{

-//		pVar->SetClass(pClass);

-		if ( type.Eq(CBotTypClass) )

-		{

-			// ajoute une instruction new pour initialiser l'object

-			pVar->m_InitExpr = new CBotNew() ;

-			CBotToken nom( pClass->GivName() );

-			pVar->m_InitExpr->SetToken(&nom);

-		}

-	}

-	return AddItem( pVar );

-}

-

-

-BOOL CBotClass::AddItem(CBotVar* pVar)

-{

-	pVar->SetUniqNum(++m_nbVar);

-

-	if ( m_pVar == NULL ) m_pVar = pVar;

-	else m_pVar->AddNext(pVar);

-

-	return TRUE;

-}

-

-void CBotClass::AddNext(CBotClass* pClass)

-{

-	CBotClass*		p = this;

-	while (p->m_next != NULL) p = p->m_next;

-

-	p->m_next = pClass;

-}

-

-CBotString  CBotClass::GivName()

-{

-	return m_name;

-}

-

-CBotClass*  CBotClass::GivParent()

-{

-	if ( this == NULL ) return NULL;

-	return m_pParent;

-}

-

-BOOL  CBotClass::IsChildOf(CBotClass* pClass)

-{

-	CBotClass* p = this;

-	while ( p != NULL )

-	{

-		if ( p == pClass ) return TRUE;

-		p = p->m_pParent;

-	}

-	return FALSE;

-}

-

-

-CBotVar* CBotClass::GivVar()

-{

-	return	m_pVar;

-}

-

-CBotVar* CBotClass::GivItem(const char* name)

-{

-	CBotVar*	p = m_pVar;

-

-	while ( p != NULL )

-	{

-		if ( p->GivName() == name ) return p;

-		p = p->GivNext();

-	}

-	if ( m_pParent != NULL ) return m_pParent->GivItem(name);

-	return NULL;

-}

-

-CBotVar* CBotClass::GivItemRef(int nIdent)

-{

-	CBotVar*	p = m_pVar;

-

-	while ( p != NULL )

-	{

-		if ( p->GivUniqNum() == nIdent ) return p;

-		p = p->GivNext();

-	}

-	if ( m_pParent != NULL ) return m_pParent->GivItemRef(nIdent);

-	return NULL;

-}

-

-BOOL CBotClass::IsIntrinsic()

-{

-	return	m_bIntrinsic;

-}

-

-CBotClass* CBotClass::Find(CBotToken* &pToken)

-{

-	return Find(pToken->GivString());

-}

-

-CBotClass* CBotClass::Find(const char* name)

-{

-	CBotClass*	p = m_ExClass;

-

-	while ( p != NULL )

-	{

-		if ( p->GivName() == name ) return p;

-		p = p->m_ExNext;

-	}

-

-	return NULL;

-}

-

-BOOL CBotClass::AddFunction(const char* name, 

-								BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 

-								CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))

-{

-	// mémorise les pointeurs aux deux fonctions

-	CBotCallMethode*	p = m_pCalls;

-	CBotCallMethode*	pp = NULL;

-

-	while ( p != NULL )

-	{

-		if ( name == p->GivName() )

-		{

-			if ( pp == NULL ) m_pCalls = p->m_next;

-			else			  pp->m_next = p->m_next;

-			delete p;

-			break;

-		}

-		pp = p;

-		p = p->m_next;

-	}

-

-	p = new CBotCallMethode(name, rExec, rCompile);

-	

-	if (m_pCalls == NULL) m_pCalls = p;

-	else	m_pCalls->AddNext(p);				// ajoute à la liste

-

-	return TRUE;

-}

-

-BOOL CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) )

-{

-	m_rMaj = rMaj;

-	return TRUE;

-}

-

-// compile une méthode associée à une instance de classe

-// la méthode peut être déclarée par AddFunction ou par l'utilisateur

-

-CBotTypResult CBotClass::CompileMethode(const char* name, 

-										CBotVar* pThis, CBotVar** ppParams, 

-										CBotCStack* pStack, long& nIdent)

-{

-	nIdent = 0;	// oublie le précédent s'il y a lieu

-

-	// recherche dans les méthodes déclarées par AddFunction

-

-	CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);

-	if ( r.GivType() >= 0) return r;

-

-	// recherche dans les méthodes déclarées par l'utilisateur

-

-	r = m_pMethod->CompileCall(name, ppParams, nIdent);

-	if ( r.Eq(TX_UNDEFCALL) && m_pParent != NULL )

-		return m_pParent->m_pMethod->CompileCall(name, ppParams, nIdent);

-	return r;

-}

-

-// exécute une méthode

-

-BOOL CBotClass::ExecuteMethode(long& nIdent, const char* name, 

-							   CBotVar* pThis, CBotVar** ppParams, 

-							   CBotVar* &pResult, CBotStack* &pStack,

-							   CBotToken* pToken)

-{

-	int ret = m_pCalls->DoCall(nIdent, name, pThis, ppParams, pResult, pStack, pToken);

-	if (ret>=0) return ret;

-

-	ret = m_pMethod->DoCall(nIdent, name, pThis, ppParams, pStack, pToken, this);

-	return ret;

-}

-

-// rétabli la pile d'exécution

-

-void CBotClass::RestoreMethode(long& nIdent, const char* name, CBotVar* pThis,

-							   CBotVar** ppParams, CBotStack* &pStack)

-{

-	m_pMethod->RestoreCall(nIdent, name, pThis, ppParams, pStack, this);

-}

-

-

-

-

-BOOL CBotClass::SaveStaticState(FILE* pf)

-{

-	if (!WriteWord( pf, CBOTVERSION*2)) return FALSE;

-

-	// sauve l'état des variables statiques dans les classes

-	CBotClass*	p = m_ExClass;

-

-	while ( p != NULL )

-	{

-		if (!WriteWord( pf, 1)) return FALSE;

-		// enregistre le nom de la classe

-		if (!WriteString( pf, p->GivName() )) return FALSE;

-

-		CBotVar*	pv = p->GivVar();

-		while( pv != NULL )

-		{

-			if ( pv->IsStatic() )

-			{

-				if (!WriteWord( pf, 1)) return FALSE;

-				if (!WriteString( pf, pv->GivName() )) return FALSE;

-

-				if ( !pv->Save0State(pf)) return FALSE;				// entête commune

-				if ( !pv->Save1State(pf) ) return FALSE;				// sauve selon la classe fille

-				if ( !WriteWord( pf, 0)) return FALSE;

-			}

-			pv = pv->GivNext();

-		}

-

-		if (!WriteWord( pf, 0)) return FALSE;

-		p = p->m_ExNext;

-	}

-

-	if (!WriteWord( pf, 0)) return FALSE;

-	return TRUE;

-}

-

-BOOL CBotClass::RestoreStaticState(FILE* pf)

-{

-	CBotString		ClassName, VarName;

-	CBotClass*		pClass;

-	WORD			w;

-

-	if (!ReadWord( pf, w )) return FALSE;

-	if ( w != CBOTVERSION*2 ) return FALSE;

-

-	while (TRUE)

-	{

-		if (!ReadWord( pf, w )) return FALSE;

-		if ( w == 0 ) return TRUE;

-

-		if (!ReadString( pf, ClassName )) return FALSE;

-		pClass = Find(ClassName);

-

-		while (TRUE)

-		{

-			if (!ReadWord( pf, w )) return FALSE;

-			if ( w == 0 ) break;

-

-			CBotVar*	pVar = NULL;

-			CBotVar*	pv = NULL;

-

-			if (!ReadString( pf, VarName )) return FALSE;

-			if ( pClass != NULL ) pVar = pClass->GivItem(VarName);

-

-			if (!CBotVar::RestoreState(pf, pv)) return FALSE;	// la variable temp

-

-			if ( pVar != NULL ) pVar->Copy(pv);

-			delete pv;

-		}

-	}

-	return TRUE;

-}

-

-

-/////////////////////////////////////////////////////////////////////

-

-CBotClassInst::CBotClassInst()

-{

-	m_next			= NULL;

-	m_var			= NULL;

-	m_Parameters	= NULL;

-	m_expr			= NULL;

-	m_hasParams		= FALSE;

-	m_nMethodeIdent = 0;

-	name = "CBotClassInst";

-}

-

-CBotClassInst::~CBotClassInst()

-{

-	delete m_var;

-//	delete m_next;			// fait par le destructeur de la classe de base ~CBotInstr()

-}

-

-// définition de pointeur(s) à un objet

-// du style

-// CPoint A, B ;

-

-CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass)

-{

-	// cherche la classe correspondante

-	if ( pClass == NULL )

-	{

-		pStack->SetStartError(p->GivStart());

-		pClass = CBotClass::Find(p);

-		if ( pClass == NULL )

-		{

-			// pas trouvé ? c'est bizare

-			pStack->SetError(TX_NOCLASS, p);

-			return NULL;

-		}

-		p = p->GivNext();

-	}

-

-	BOOL		bIntrinsic = pClass->IsIntrinsic();

-	CBotTypResult

-				type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer,

-									  pClass );

-	CBotClassInst*	inst = (CBotClassInst*)CompileArray(p, pStack, type);

-	if ( inst != NULL || !pStack->IsOk() ) return inst;

-

-	CBotCStack* pStk = pStack->TokenStack();

-

-	inst = new CBotClassInst();

-

-	inst->SetToken(&pClass->GivName(), p->GivStart(), p->GivEnd());

-	CBotToken*	vartoken = p;

-

-	if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )

-	{

-		((CBotLeftExprVar*)inst->m_var)->m_typevar = type;

-		if (pStk->CheckVarLocal(vartoken))					// redéfinition de la variable

-		{

-			pStk->SetStartError(vartoken->GivStart());

-			pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());

-			goto error;

-		}

-

-		if (IsOfType(p,  ID_OPBRK))							// avec des indices ?

-		{

-			delete inst;									// n'est pas de type CBotInt

-			p = vartoken;									// revient sur le nom de la variable

-

-			// compile une déclaration de tableau

-

-			inst = (CBotClassInst*)CBotInstArray::Compile( p, pStk, type );

-

-			if (!pStk->IsOk() )

-			{

-				pStk->SetError(TX_CLBRK, p->GivStart());

-				goto error;

-			}

-			goto suite;			// pas d'assignation, variable déjà créée

-		}

-

-

-		CBotVar*	var;

-		var = CBotVar::Create(vartoken->GivString(), type);	// crée l'instance

-//		var->SetClass(pClass);

-		var->SetUniqNum(

-			((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());

-															// lui attribut un numéro unique

-		pStack->AddVar(var);								// la place sur la pile

-

-		// regarde s'il y a des paramètres

-		inst->m_hasParams = (p->GivType() == ID_OPENPAR);

-

-		CBotVar*	ppVars[1000];

-		inst->m_Parameters = CompileParams(p, pStk, ppVars);

-		if ( !pStk->IsOk() ) goto error;

-

-		// s'il y a des paramètres, fait l'équivalent de l'instruction new

-		// CPoint A ( 0, 0 ) est équivalent à

-		// CPoint A = new CPoint( 0, 0 )

-

-//		if ( NULL != inst->m_Parameters )

-		if ( inst->m_hasParams )

-		{

-			// le constructeur existe-il ?

-//			CBotString	noname;

-			CBotTypResult r = pClass->CompileMethode(pClass->GivName(), var, ppVars, pStk, inst->m_nMethodeIdent);

-			delete pStk->TokenStack();							// libère le supplément de pile

-			int typ = r.GivType();

-

-			if (typ == TX_UNDEFCALL)

-			{

-				// si le constructeur n'existe pas

-				if (inst->m_Parameters != NULL)					// avec des paramètres

-				{

-					pStk->SetError(TX_NOCONST, vartoken);

-					goto error;

-				}

-				typ = 0;

-			}

-

-			if (typ>20)

-			{

-				pStk->SetError(typ, vartoken->GivEnd());

-				goto error;

-			}

-

-		}

-

-		if (IsOfType(p,  ID_ASS))							// avec une assignation ?

-		{

-			if (inst->m_hasParams)

-			{

-				pStk->SetError(TX_ENDOF, p->GivStart());

-				goto error;

-			}

-

-			if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )

-			{

-				goto error;

-			}

-			CBotClass* result = pStk->GivClass();

-			if ( !pStk->GivTypResult(1).Eq(CBotTypNullPointer) &&

-			   ( !pStk->GivTypResult(1).Eq(CBotTypPointer) ||

-				 ( result != NULL && !pClass->IsChildOf(result) )))		// type compatible ?

-			{

-				pStk->SetError(TX_BADTYPE, p->GivStart());

-				goto error;

-			}

-//			if ( !bIntrinsic ) var->SetPointer(pStk->GivVar()->GivPointer());

-			if ( !bIntrinsic ) 

-			{

-				// n'utilise pas le résultat sur la pile, pour imposer la classe

-				CBotVar* pvar = CBotVar::Create("", pClass);

-				var->SetPointer( pvar );					// var déjà déclarée pointe l'instance

-				delete pvar;								// supprime le second pointeur

-			}

-			var->SetInit(TRUE);							// marque le pointeur comme init

-		}

-		else if (inst->m_hasParams)

-		{

-			// crée l'objet sur le "tas"

-			// avec un pointeur sur cet objet

-			if ( !bIntrinsic ) 

-			{

-				CBotVar* pvar = CBotVar::Create("", pClass);

-				var->SetPointer( pvar );					// var déjà déclarée pointe l'instance

-				delete pvar;								// supprime le second pointeur

-			}

-			var->SetInit(2);							// marque le pointeur comme init

-		}

-suite:

-		if (IsOfType(p,  ID_COMMA))							// plusieurs définitions enchaînées

-		{

-			if ( NULL != ( inst->m_next = CBotClassInst::Compile(p, pStk, pClass) ))	// compile la suivante

-			{

-				return pStack->Return(inst, pStk);

-			}

-		}

-		

-		if (IsOfType(p,  ID_SEP))							// instruction terminée

-		{

-			return pStack->Return(inst, pStk);

-		}

-

-		pStk->SetError(TX_ENDOF, p->GivStart());

-	}

-

-error:

-	delete inst;

-	return pStack->Return(NULL, pStk);

-}

-

-// déclaration de l'instance d'une classe, par exemple:

-//	CPoint A, B;

-

-BOOL CBotClassInst::Execute(CBotStack* &pj)

-{

-	CBotVar*	pThis = NULL;

-

- 	CBotStack*	pile = pj->AddStack(this);//indispensable pour SetState()

-//	if ( pile == EOX ) return TRUE;

-

-	CBotToken*	pt = &m_token;

-	CBotClass*	pClass = CBotClass::Find(pt);

-

-	BOOL bIntrincic = pClass->IsIntrinsic();

-

-	// crée la variable de type pointeur à l'objet

-

-	if ( pile->GivState()==0)

-	{

-		CBotString	name = m_var->m_token.GivString();

-		if ( bIntrincic )

-		{

-			pThis = CBotVar::Create(name, CBotTypResult( CBotTypIntrinsic, pClass ));

-		}

-		else

-		{

-			pThis = CBotVar::Create(name, CBotTypResult( CBotTypPointer, pClass ));

-		}

-

-		pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);	// lui attribut un numéro unique

-		pile->AddVar(pThis);									// la place sur la pile

-		pile->IncState();

-	}

-

-	if ( pThis == NULL ) pThis = pile->FindVar(((CBotLeftExprVar*)m_var)->m_nIdent);

-

-	if ( pile->GivState()<3)

-	{

-		// y a-t-il une assignation ou des paramètres (constructeur)

-

-//		CBotVarClass* pInstance = NULL;

-

-		if ( m_expr != NULL )

-		{

-			// évalue l'expression pour l'assignation

-			if (!m_expr->Execute(pile)) return FALSE;

-	

-			if ( bIntrincic )

-			{

-				CBotVar*	pv = pile->GivVar();

-				if ( pv == NULL || pv->GivPointer() == NULL )

-				{

-					pile->SetError(TX_NULLPT, &m_token);

-					return pj->Return(pile);

-				}

-				pThis->Copy(pile->GivVar(), FALSE);

-			}

-			else

-			{

-				CBotVarClass* pInstance;

-				pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer();	// valeur pour l'assignation

-				pThis->SetPointer(pInstance);

-			}

-			pThis->SetInit(TRUE);

-		}

-

-		else if ( m_hasParams )

-		{

-			// évalue le constructeur d'une instance

-

-			if ( !bIntrincic && pile->GivState() == 1)

-			{

-				CBotToken*	pt = &m_token;

-				CBotClass* pClass = CBotClass::Find(pt);

-

-				// crée une instance de la classe demandée

-

-				CBotVarClass* pInstance;

-				pInstance = (CBotVarClass*)CBotVar::Create("", pClass);

-				pThis->SetPointer(pInstance);

-				delete pInstance;

-

-				pile->IncState();

-			}

-

-			CBotVar*	ppVars[1000];

-			CBotStack*	pile2 = pile;

-

-			int		i = 0;

-

-			CBotInstr*	p = m_Parameters;

-			// évalue les paramètres

-			// et place les valeurs sur la pile

-			// pour pouvoir être interrompu n'importe quand

-

-			if ( p != NULL) while ( TRUE )

-			{

-				pile2 = pile2->AddStack();						// de la place sur la pile pour les résultats

-				if ( pile2->GivState() == 0 )

-				{

-					if (!p->Execute(pile2)) return FALSE;		// interrompu ici ?

-					pile2->SetState(1);

-				}

-				ppVars[i++] = pile2->GivVar();

-				p = p->GivNext();

-				if ( p == NULL) break;

-			}

-			ppVars[i] = NULL;

-

-			// crée une variable pour le résultat

-			CBotVar*	pResult = NULL;		// constructeurs toujours void

-

-			if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(), 

-										 pThis, ppVars, 

-										 pResult, pile2, GivToken())) return FALSE;	// interrompu

-

-			pThis->SetInit(TRUE);

-			pThis->ConstructorSet();		// signale que le constructeur a été appelé

-			pile->Return(pile2);								// libère un bout de pile

-

-//			pInstance = pThis->GivPointer();

-

-		}

-

-//		if ( !bIntrincic ) pThis->SetPointer(pInstance);		// le fait pointer l'instance

-

-		pile->SetState(3);									// fini cette partie

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( m_next2b != NULL &&

-		!m_next2b->Execute(pile)) return FALSE;				// autre(s) définition(s)

-

-	return pj->Return( pile );								// transmet en dessous

-}

-

-

-

-void CBotClassInst::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotVar*	pThis = NULL;

-

-	CBotStack*	pile = pj;

-	if ( bMain ) pile = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	// crée la variable de type pointeur à l'objet

-	{

-		CBotString	name = m_var->m_token.GivString();

-		pThis = pile->FindVar(name);

-		pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent);	// lui attribut un numéro unique

-	}

-

-	CBotToken*	pt = &m_token;

-	CBotClass*	pClass = CBotClass::Find(pt);

-	BOOL bIntrincic = pClass->IsIntrinsic();

-

-	if ( bMain && pile->GivState()<3)

-	{

-		// y a-t-il une assignation ou des paramètres (constructeur)

-

-//		CBotVarClass* pInstance = NULL;

-

-		if ( m_expr != NULL )

-		{

-			// évalue l'expression pour l'assignation

-			m_expr->RestoreState(pile, bMain);

-			return;

-		}

-

-		else if ( m_hasParams )

-		{

-			// évalue le constructeur d'une instance

-

-			if ( !bIntrincic && pile->GivState() == 1)

-			{

-				return;

-			}

-

-			CBotVar*	ppVars[1000];

-			CBotStack*	pile2 = pile;

-

-			int		i = 0;

-

-			CBotInstr*	p = m_Parameters;

-			// évalue les paramètres

-			// et place les valeurs sur la pile

-			// pour pouvoir être interrompu n'importe quand

-

-			if ( p != NULL) while ( TRUE )

-			{

-				pile2 = pile2->RestoreStack();						// de la place sur la pile pour les résultats

-				if ( pile2 == NULL ) return;

-

-				if ( pile2->GivState() == 0 )

-				{

-					p->RestoreState(pile2, bMain);		// interrompu ici ?

-					return;

-				}

-				ppVars[i++] = pile2->GivVar();

-				p = p->GivNext();

-				if ( p == NULL) break;

-			}

-			ppVars[i] = NULL;

-

-			// crée une variable pour le résultat

-			CBotVar*	pResult = NULL;		// constructeurs toujours void

-

-			pClass->RestoreMethode(m_nMethodeIdent, pClass->GivName(), pThis, ppVars, pile2);

-			return;

-		}

-	}

-

-	if ( m_next2b != NULL )

-		 m_next2b->RestoreState(pile, bMain);					// autre(s) définition(s)

-}

-

-

-// test si un nom de procédure est déjà défini quelque part

-

-BOOL CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)

-{

-	CBotString	name = pToken->GivString();

-

-	if ( CBotCall::CheckCall(name) ) return TRUE;

-

-	CBotFunction*	pp = m_pMethod;

-	while ( pp != NULL )

-	{

-		if ( pToken->GivString() == pp->GivName() )

-		{

-			// les paramètres sont-ils exactement les mêmes ?

-			if ( pp->CheckParam( pParam ) )

-				return TRUE;

-		}

-		pp = pp->Next();

-	}

-

-	return FALSE;

-}

-

+// * 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  http://www.gnu.org/licenses/.//
+
+/////////////////////////////////////////////////////////////////////
+// Management of variables of class type
+//
+
+#include "CBot.h"
+
+
+CBotClass* CBotClass::m_ExClass = NULL;
+
+CBotClass::CBotClass(const char* name, CBotClass* pPapa, bool bIntrinsic)
+{
+    m_pParent   = pPapa;
+    m_name      = name;
+    m_pVar      = NULL;
+    m_next      = NULL;
+    m_pCalls    = NULL;
+    m_pMethod   = NULL;
+    m_rMaj      = NULL;
+    m_IsDef     = true;
+    m_bIntrinsic= bIntrinsic;
+    m_cptLock   = 0;
+    m_cptOne    = 0;
+    m_nbVar     = m_pParent == NULL ? 0 : m_pParent->m_nbVar;
+
+    for ( int j= 0; j< 5 ; j++ )
+    {
+        m_ProgInLock[j] = NULL;
+    }
+
+
+    // is located alone in the list
+    if (m_ExClass) m_ExClass->m_ExPrev = this;
+    m_ExNext  = m_ExClass;
+    m_ExPrev  = NULL;
+    m_ExClass = this;
+
+}
+
+CBotClass::~CBotClass()
+{
+    // removes the list of class 
+    if ( m_ExPrev ) m_ExPrev->m_ExNext = m_ExNext;
+    else m_ExClass = m_ExNext;
+
+    if ( m_ExNext ) m_ExNext->m_ExPrev = m_ExPrev;
+    m_ExPrev = NULL;
+    m_ExNext = NULL;
+
+    delete  m_pVar;
+    delete  m_pCalls;
+    delete  m_pMethod;
+
+    delete  m_next;         // releases all of them on this level
+}
+
+
+void CBotClass::Free()
+{
+    while ( m_ExClass != NULL )
+    {
+        delete m_ExClass;
+    }
+}
+
+void CBotClass::Purge()
+{
+    if ( this == NULL ) return;
+
+    delete      m_pVar;
+    m_pVar      = NULL;
+    delete      m_pCalls;
+    m_pCalls    = NULL;
+    delete      m_pMethod;
+    m_pMethod   = NULL;
+    m_IsDef     = false;
+
+    m_nbVar     = m_pParent == NULL ? 0 : m_pParent->m_nbVar;
+
+    m_next->Purge();
+    m_next = NULL;          // no longer belongs to this chain
+}
+
+bool CBotClass::Lock(CBotProgram* p)
+{
+    int i = m_cptLock++;
+
+    if ( i == 0 )
+    {
+        m_cptOne = 1;
+        m_ProgInLock[0] = p;
+        return true;
+    }
+    if ( p == m_ProgInLock[0] ) 
+    {
+        m_cptOne++;
+        m_cptLock--;                                // has already been counted
+        return true;
+    }
+
+    for ( int j = 1 ; j <= i ; j++)
+    {
+        if ( p == m_ProgInLock[j] )
+        {
+            m_cptLock--;
+            return false;   // already pending
+        }
+    }
+
+    if ( i < 5 )    // max 5 in query
+    {
+        m_ProgInLock[i] = p;                        // located in a queue
+    }
+    else
+        m_cptLock--;
+
+    return false;
+}
+
+void CBotClass::Unlock()
+{
+    if ( --m_cptOne > 0 ) return ;
+
+    int i = --m_cptLock;
+    if ( i<0 )
+    {
+        m_cptLock = 0;
+        return;
+    }
+
+    for ( int j= 0; j< i ; j++ )
+    {
+        m_ProgInLock[j] = m_ProgInLock[j+1];
+    }
+    m_ProgInLock[i] = 0;
+}
+
+void CBotClass::FreeLock(CBotProgram* p)
+{
+    CBotClass* pClass = m_ExClass;
+
+    while ( pClass != NULL )
+    {
+        if ( p == pClass->m_ProgInLock[0] ) 
+        {
+            pClass->m_cptLock -= pClass->m_cptOne;
+            pClass->m_cptOne = 0;
+        }
+
+        for ( int j = 1; j < 5 ; j++ )
+            if ( p == pClass->m_ProgInLock[j] ) 
+                pClass->m_cptLock--;
+
+        pClass = pClass->m_ExNext;
+    }
+}
+
+
+
+bool CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
+{
+    CBotToken   token(name, CBotString());
+    CBotClass*  pClass = type.GivClass();
+
+    CBotVar*    pVar = CBotVar::Create( name, type );
+/// pVar->SetUniqNum(CBotVar::NextUniqNum());
+    pVar->SetPrivate( mPrivate );
+
+    if ( pClass != NULL )
+    {
+//      pVar->SetClass(pClass);
+        if ( type.Eq(CBotTypClass) )
+        {
+            // adds a new statement for the object initialization
+            pVar->m_InitExpr = new CBotNew() ;
+            CBotToken nom( pClass->GivName() );
+            pVar->m_InitExpr->SetToken(&nom);
+        }
+    }
+    return AddItem( pVar );
+}
+
+
+bool CBotClass::AddItem(CBotVar* pVar)
+{
+    pVar->SetUniqNum(++m_nbVar);
+
+    if ( m_pVar == NULL ) m_pVar = pVar;
+    else m_pVar->AddNext(pVar);
+
+    return true;
+}
+
+void CBotClass::AddNext(CBotClass* pClass)
+{
+    CBotClass*      p = this;
+    while (p->m_next != NULL) p = p->m_next;
+
+    p->m_next = pClass;
+}
+
+CBotString  CBotClass::GivName()
+{
+    return m_name;
+}
+
+CBotClass*  CBotClass::GivParent()
+{
+    if ( this == NULL ) return NULL;
+    return m_pParent;
+}
+
+bool  CBotClass::IsChildOf(CBotClass* pClass)
+{
+    CBotClass* p = this;
+    while ( p != NULL )
+    {
+        if ( p == pClass ) return true;
+        p = p->m_pParent;
+    }
+    return false;
+}
+
+
+CBotVar* CBotClass::GivVar()
+{
+    return  m_pVar;
+}
+
+CBotVar* CBotClass::GivItem(const char* name)
+{
+    CBotVar*    p = m_pVar;
+
+    while ( p != NULL )
+    {
+        if ( p->GivName() == name ) return p;
+        p = p->GivNext();
+    }
+    if ( m_pParent != NULL ) return m_pParent->GivItem(name);
+    return NULL;
+}
+
+CBotVar* CBotClass::GivItemRef(int nIdent)
+{
+    CBotVar*    p = m_pVar;
+
+    while ( p != NULL )
+    {
+        if ( p->GivUniqNum() == nIdent ) return p;
+        p = p->GivNext();
+    }
+    if ( m_pParent != NULL ) return m_pParent->GivItemRef(nIdent);
+    return NULL;
+}
+
+bool CBotClass::IsIntrinsic()
+{
+    return  m_bIntrinsic;
+}
+
+CBotClass* CBotClass::Find(CBotToken* &pToken)
+{
+    return Find(pToken->GivString());
+}
+
+CBotClass* CBotClass::Find(const char* name)
+{
+    CBotClass*  p = m_ExClass;
+
+    while ( p != NULL )
+    {
+        if ( p->GivName() == name ) return p;
+        p = p->m_ExNext;
+    }
+
+    return NULL;
+}
+
+bool CBotClass::AddFunction(const char* name, 
+                                bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 
+                                CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
+{
+    // stores pointers to the two functions
+    CBotCallMethode*    p = m_pCalls;
+    CBotCallMethode*    pp = NULL;
+
+    while ( p != NULL )
+    {
+        if ( name == p->GivName() )
+        {
+            if ( pp == NULL ) m_pCalls = p->m_next;
+            else              pp->m_next = p->m_next;
+            delete p;
+            break;
+        }
+        pp = p;
+        p = p->m_next;
+    }
+
+    p = new CBotCallMethode(name, rExec, rCompile);
+    
+    if (m_pCalls == NULL) m_pCalls = p;
+    else    m_pCalls->AddNext(p);               // added to the list
+
+    return true;
+}
+
+bool CBotClass::AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) )
+{
+    m_rMaj = rMaj;
+    return true;
+}
+
+// compiles a method associated with an instance of class
+// the method can be declared by the user or AddFunction
+
+CBotTypResult CBotClass::CompileMethode(const char* name, 
+                                        CBotVar* pThis, CBotVar** ppParams, 
+                                        CBotCStack* pStack, long& nIdent)
+{
+    nIdent = 0; // forget the previous one if necessary
+
+    // find the methods declared by AddFunction
+
+    CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);
+    if ( r.GivType() >= 0) return r;
+
+    // find the methods declared by user
+
+    r = m_pMethod->CompileCall(name, ppParams, nIdent);
+    if ( r.Eq(TX_UNDEFCALL) && m_pParent != NULL )
+        return m_pParent->m_pMethod->CompileCall(name, ppParams, nIdent);
+    return r;
+}
+
+// executes a method
+
+bool CBotClass::ExecuteMethode(long& nIdent, const char* name, 
+                               CBotVar* pThis, CBotVar** ppParams, 
+                               CBotVar* &pResult, CBotStack* &pStack,
+                               CBotToken* pToken)
+{
+    int ret = m_pCalls->DoCall(nIdent, name, pThis, ppParams, pResult, pStack, pToken);
+    if (ret>=0) return ret;
+
+    ret = m_pMethod->DoCall(nIdent, name, pThis, ppParams, pStack, pToken, this);
+    return ret;
+}
+
+// restored the execution stack
+
+void CBotClass::RestoreMethode(long& nIdent, const char* name, CBotVar* pThis,
+                               CBotVar** ppParams, CBotStack* &pStack)
+{
+    m_pMethod->RestoreCall(nIdent, name, pThis, ppParams, pStack, this);
+}
+
+
+
+
+bool CBotClass::SaveStaticState(FILE* pf)
+{
+    if (!WriteWord( pf, CBOTVERSION*2)) return false;
+
+    // saves the state of static variables in classes
+    CBotClass*  p = m_ExClass;
+
+    while ( p != NULL )
+    {
+        if (!WriteWord( pf, 1)) return false;
+        // save the name of the class
+        if (!WriteString( pf, p->GivName() )) return false;
+
+        CBotVar*    pv = p->GivVar();
+        while( pv != NULL )
+        {
+            if ( pv->IsStatic() )
+            {
+                if (!WriteWord( pf, 1)) return false;
+                if (!WriteString( pf, pv->GivName() )) return false;
+
+                if ( !pv->Save0State(pf)) return false;             // common header
+                if ( !pv->Save1State(pf) ) return false;                // saves as the child class
+                if ( !WriteWord( pf, 0)) return false;
+            }
+            pv = pv->GivNext();
+        }
+
+        if (!WriteWord( pf, 0)) return false;
+        p = p->m_ExNext;
+    }
+
+    if (!WriteWord( pf, 0)) return false;
+    return true;
+}
+
+bool CBotClass::RestoreStaticState(FILE* pf)
+{
+    CBotString      ClassName, VarName;
+    CBotClass*      pClass;
+    unsigned short  w;
+
+    if (!ReadWord( pf, w )) return false;
+    if ( w != CBOTVERSION*2 ) return false;
+
+    while (true)
+    {
+        if (!ReadWord( pf, w )) return false;
+        if ( w == 0 ) return true;
+
+        if (!ReadString( pf, ClassName )) return false;
+        pClass = Find(ClassName);
+
+        while (true)
+        {
+            if (!ReadWord( pf, w )) return false;
+            if ( w == 0 ) break;
+
+            CBotVar*    pVar = NULL;
+            CBotVar*    pv = NULL;
+
+            if (!ReadString( pf, VarName )) return false;
+            if ( pClass != NULL ) pVar = pClass->GivItem(VarName);
+
+            if (!CBotVar::RestoreState(pf, pv)) return false;   // the temp variable 
+
+            if ( pVar != NULL ) pVar->Copy(pv);
+            delete pv;
+        }
+    }
+    return true;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+
+CBotClassInst::CBotClassInst()
+{
+    m_next          = NULL;
+    m_var           = NULL;
+    m_Parameters    = NULL;
+    m_expr          = NULL;
+    m_hasParams     = false;
+    m_nMethodeIdent = 0;
+    name = "CBotClassInst";
+}
+
+CBotClassInst::~CBotClassInst()
+{
+    delete m_var;
+//  delete m_next;          // done by the destructor of the base class ~CBotInstr()
+}
+
+// definition of pointer (s) to an object
+// style
+// CPoint A, B ;
+
+CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass)
+{
+    // seeks the corresponding classes
+    if ( pClass == NULL )
+    {
+        pStack->SetStartError(p->GivStart());
+        pClass = CBotClass::Find(p);
+        if ( pClass == NULL )
+        {
+            // not found? is bizare
+            pStack->SetError(TX_NOCLASS, p);
+            return NULL;
+        }
+        p = p->GivNext();
+    }
+
+    bool        bIntrinsic = pClass->IsIntrinsic();
+    CBotTypResult type = CBotTypResult( bIntrinsic ? CBotTypIntrinsic : CBotTypPointer, pClass );
+    CBotClassInst*  inst = (CBotClassInst*)CompileArray(p, pStack, type);
+    if ( inst != NULL || !pStack->IsOk() ) return inst;
+
+    CBotCStack* pStk = pStack->TokenStack();
+
+    inst = new CBotClassInst();
+    /// \TODO Need to be revised and fixed after adding unit tests
+    CBotToken token(pClass->GivName(), CBotString(), p->GivStart(), p->GivEnd());
+    inst->SetToken(&token);
+    CBotToken*  vartoken = p;
+
+    if ( NULL != (inst->m_var = CBotLeftExprVar::Compile( p, pStk )) )
+    {
+        ((CBotLeftExprVar*)inst->m_var)->m_typevar = type;
+        if (pStk->CheckVarLocal(vartoken))                  // redefinition of the variable
+        {
+            pStk->SetStartError(vartoken->GivStart());
+            pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
+            goto error;
+        }
+
+        if (IsOfType(p,  ID_OPBRK))                         // with any clues?
+        {
+            delete inst;                                    // is not type CBotInt
+            p = vartoken;                                   // returns to the variable name
+
+            // compiles declaration an array 
+
+            inst = (CBotClassInst*)CBotInstArray::Compile( p, pStk, type );
+
+            if (!pStk->IsOk() )
+            {
+                pStk->SetError(TX_CLBRK, p->GivStart());
+                goto error;
+            }
+            goto suite;         // no assignment, variable already created
+        }
+
+
+        CBotVar*    var;
+        var = CBotVar::Create(vartoken->GivString(), type); // creates the instance
+//      var->SetClass(pClass);
+        var->SetUniqNum(
+            ((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
+                                                            // its attribute a unique number
+        pStack->AddVar(var);                                // placed on the stack
+
+        // look if there are parameters
+        inst->m_hasParams = (p->GivType() == ID_OPENPAR);
+
+        CBotVar*    ppVars[1000];
+        inst->m_Parameters = CompileParams(p, pStk, ppVars);
+        if ( !pStk->IsOk() ) goto error;
+
+        // if there are parameters, is the equivalent to the stament "new"
+        // CPoint A ( 0, 0 ) is equivalent to
+        // CPoint A = new CPoint( 0, 0 )
+
+//      if ( NULL != inst->m_Parameters )
+        if ( inst->m_hasParams )
+        {
+            // the constructor is there?
+//          CBotString  noname;
+            CBotTypResult r = pClass->CompileMethode(pClass->GivName(), var, ppVars, pStk, inst->m_nMethodeIdent);
+            delete pStk->TokenStack();                          // releases the supplement stack
+            int typ = r.GivType();
+
+            if (typ == TX_UNDEFCALL)
+            {
+                // si le constructeur n'existe pas
+                if (inst->m_Parameters != NULL)                 // with parameters
+                {
+                    pStk->SetError(TX_NOCONST, vartoken);
+                    goto error;
+                }
+                typ = 0;
+            }
+
+            if (typ>20)
+            {
+                pStk->SetError(typ, vartoken->GivEnd());
+                goto error;
+            }
+
+        }
+
+        if (IsOfType(p,  ID_ASS))                           // with a assignment?
+        {
+            if (inst->m_hasParams)
+            {
+                pStk->SetError(TX_ENDOF, p->GivStart());
+                goto error;
+            }
+
+            if ( NULL == ( inst->m_expr = CBotTwoOpExpr::Compile( p, pStk )) )
+            {
+                goto error;
+            }
+            CBotClass* result = pStk->GivClass();
+            if ( !pStk->GivTypResult(1).Eq(CBotTypNullPointer) &&
+               ( !pStk->GivTypResult(1).Eq(CBotTypPointer) ||
+                 ( result != NULL && !pClass->IsChildOf(result) )))     // type compatible ?
+            {
+                pStk->SetError(TX_BADTYPE, p->GivStart());
+                goto error;
+            }
+//          if ( !bIntrinsic ) var->SetPointer(pStk->GivVar()->GivPointer());
+            if ( !bIntrinsic ) 
+            {
+                // does not use the result on the stack, to impose the class
+                CBotVar* pvar = CBotVar::Create("", pClass);
+                var->SetPointer( pvar );                    // variable already declared instance pointer
+                delete pvar;                                // removes the second pointer
+            }
+            var->SetInit(true);                         // marks the pointer as init
+        }
+        else if (inst->m_hasParams)
+        {
+            // creates the object on the "job" (\TODO "tas")
+            // with a pointer to the object
+            if ( !bIntrinsic ) 
+            {
+                CBotVar* pvar = CBotVar::Create("", pClass);
+                var->SetPointer( pvar );                    // variable already declared instance pointer
+                delete pvar;                                // removes the second pointer
+            }
+            var->SetInit(2);                            // marks the pointer as init
+        }
+suite:
+        if (IsOfType(p,  ID_COMMA))                         // several chained definitions 
+        {
+            if ( NULL != ( inst->m_next = CBotClassInst::Compile(p, pStk, pClass) ))    // compiles the following
+            {
+                return pStack->Return(inst, pStk);
+            }
+        }
+        
+        if (IsOfType(p,  ID_SEP))                           // complete instruction
+        {
+            return pStack->Return(inst, pStk);
+        }
+
+        pStk->SetError(TX_ENDOF, p->GivStart());
+    }
+
+error:
+    delete inst;
+    return pStack->Return(NULL, pStk);
+}
+
+// declaration of the instance of a class, for example:
+//  CPoint A, B;
+
+bool CBotClassInst::Execute(CBotStack* &pj)
+{
+    CBotVar*    pThis = NULL;
+
+    CBotStack*  pile = pj->AddStack(this);//essential for SetState()
+//  if ( pile == EOX ) return true;
+
+    CBotToken*  pt = &m_token;
+    CBotClass*  pClass = CBotClass::Find(pt);
+
+    bool bIntrincic = pClass->IsIntrinsic();
+
+    // creates the variable of type pointer to the object
+
+    if ( pile->GivState()==0)
+    {
+        CBotString  name = m_var->m_token.GivString();
+        if ( bIntrincic )
+        {
+            pThis = CBotVar::Create(name, CBotTypResult( CBotTypIntrinsic, pClass ));
+        }
+        else
+        {
+            pThis = CBotVar::Create(name, CBotTypResult( CBotTypPointer, pClass ));
+        }
+
+        pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // its attribute as unique number
+        pile->AddVar(pThis);                                    // place on the stack
+        pile->IncState();
+    }
+
+    if ( pThis == NULL ) pThis = pile->FindVar(((CBotLeftExprVar*)m_var)->m_nIdent);
+
+    if ( pile->GivState()<3)
+    {
+        // ss there an assignment or parameters (contructor)
+
+//      CBotVarClass* pInstance = NULL;
+
+        if ( m_expr != NULL )
+        {
+            // evaluates the expression for the assignment
+            if (!m_expr->Execute(pile)) return false;
+    
+            if ( bIntrincic )
+            {
+                CBotVar*    pv = pile->GivVar();
+                if ( pv == NULL || pv->GivPointer() == NULL )
+                {
+                    pile->SetError(TX_NULLPT, &m_token);
+                    return pj->Return(pile);
+                }
+                pThis->Copy(pile->GivVar(), false);
+            }
+            else
+            {
+                CBotVarClass* pInstance;
+                pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer();    // value for the assignment
+                pThis->SetPointer(pInstance);
+            }
+            pThis->SetInit(true);
+        }
+
+        else if ( m_hasParams )
+        {
+            // evaluates the constructor of an instance
+
+            if ( !bIntrincic && pile->GivState() == 1)
+            {
+                CBotToken*  pt = &m_token;
+                CBotClass* pClass = CBotClass::Find(pt);
+
+                // creates an instance of the requested class
+
+                CBotVarClass* pInstance;
+                pInstance = (CBotVarClass*)CBotVar::Create("", pClass);
+                pThis->SetPointer(pInstance);
+                delete pInstance;
+
+                pile->IncState();
+            }
+
+            CBotVar*    ppVars[1000];
+            CBotStack*  pile2 = pile;
+
+            int     i = 0;
+
+            CBotInstr*  p = m_Parameters;
+            // evaluates the parameters
+            // and places the values ​​on the stack
+            // to (can) be interrupted (broken) at any time
+
+            if ( p != NULL) while ( true )
+            {
+                pile2 = pile2->AddStack();                      // place on the stack for the results
+                if ( pile2->GivState() == 0 )
+                {
+                    if (!p->Execute(pile2)) return false;       // interrupted here?
+                    pile2->SetState(1);
+                }
+                ppVars[i++] = pile2->GivVar();
+                p = p->GivNext();
+                if ( p == NULL) break;
+            }
+            ppVars[i] = NULL;
+
+            // creates a variable for the result
+            CBotVar*    pResult = NULL;     // constructor still void
+
+            if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(), 
+                                         pThis, ppVars, 
+                                         pResult, pile2, GivToken())) return false; // interrupt
+
+            pThis->SetInit(true);
+            pThis->ConstructorSet();        // indicates that the constructor has been called
+            pile->Return(pile2);                                // releases a piece of stack
+
+//          pInstance = pThis->GivPointer();
+
+        }
+
+//      if ( !bIntrincic ) pThis->SetPointer(pInstance);        // a pointer to the instance
+
+        pile->SetState(3);                                  // finished this part
+    }
+
+    if ( pile->IfStep() ) return false;
+
+    if ( m_next2b != NULL &&
+        !m_next2b->Execute(pile)) return false;             // other (s) definition (s)
+
+    return pj->Return( pile );                              // transmits below (further)
+}
+
+
+
+void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotVar*    pThis = NULL;
+
+    CBotStack*  pile = pj;
+    if ( bMain ) pile = pj->RestoreStack(this);
+    if ( pile == NULL ) return;
+
+    // creates the variable of type pointer to the object
+    {
+        CBotString  name = m_var->m_token.GivString();
+        pThis = pile->FindVar(name);
+        pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // its attribute a unique number
+    }
+
+    CBotToken*  pt = &m_token;
+    CBotClass*  pClass = CBotClass::Find(pt);
+    bool bIntrincic = pClass->IsIntrinsic();
+
+    if ( bMain && pile->GivState()<3)
+    {
+        // is there an assignment or parameters (constructor)
+
+//      CBotVarClass* pInstance = NULL;
+
+        if ( m_expr != NULL )
+        {
+            // evaluates the expression for the assignment
+            m_expr->RestoreState(pile, bMain);
+            return;
+        }
+
+        else if ( m_hasParams )
+        {
+            // evaluates the constructor of an instance
+
+            if ( !bIntrincic && pile->GivState() == 1)
+            {
+                return;
+            }
+
+            CBotVar*    ppVars[1000];
+            CBotStack*  pile2 = pile;
+
+            int     i = 0;
+
+            CBotInstr*  p = m_Parameters;
+            // evaluates the parameters
+            // and the values an the stack
+            // for the ability to be interrupted at any time (\TODO pour pouvoir être interrompu n'importe quand)
+
+            if ( p != NULL) while ( true )
+            {
+                pile2 = pile2->RestoreStack();                      // place on the stack for the results
+                if ( pile2 == NULL ) return;
+
+                if ( pile2->GivState() == 0 )
+                {
+                    p->RestoreState(pile2, bMain);      // interrupted here?
+                    return;
+                }
+                ppVars[i++] = pile2->GivVar();
+                p = p->GivNext();
+                if ( p == NULL) break;
+            }
+            ppVars[i] = NULL;
+
+            // creates a variable for the result
+            CBotVar*    pResult = NULL;     // constructor still void
+
+            pClass->RestoreMethode(m_nMethodeIdent, pClass->GivName(), pThis, ppVars, pile2);
+            return;
+        }
+    }
+
+    if ( m_next2b != NULL )
+         m_next2b->RestoreState(pile, bMain);                   // other(s) definition(s)
+}
+
+
+// test if a procedure name is already defined somewhere
+
+bool CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
+{
+    CBotString  name = pToken->GivString();
+
+    if ( CBotCall::CheckCall(name) ) return true;
+
+    CBotFunction*   pp = m_pMethod;
+    while ( pp != NULL )
+    {
+        if ( pToken->GivString() == pp->GivName() )
+        {
+            // are their parameters exactly the same?
+            if ( pp->CheckParam( pParam ) )
+                return true;
+        }
+        pp = pp->Next();
+    }
+
+    return false;
+}
+
diff --git a/src/CBot/CBotCompExpr.cpp b/src/CBot/CBotCompExpr.cpp
index 41e7e05..2daf53f 100644
--- a/src/CBot/CBotCompExpr.cpp
+++ b/src/CBot/CBotCompExpr.cpp
@@ -1,131 +1,133 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////

-// expression du genre Opérande1 > Opérande2

-//					   Opérande1 != Opérande2

-// etc.

-

-#include "CBot.h"

-

-// divers constructeurs

-

-CBotCompExpr::CBotCompExpr()

-{

-	m_leftop	=

-	m_rightop	= NULL;

-	name = "CBotCompExpr";

-}

-

-CBotCompExpr::~CBotCompExpr()

-{

-	delete	m_leftop;

-	delete	m_rightop;

-}

-

-fichier plus utilise;

-

-// compile une instruction de type A < B

-

-CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCStack* pStk = pStack->AddStack();

-

-	CBotInstr*	left = CBotAddExpr::Compile( p, pStk );		// expression A + B à gauche

-	if (left == NULL) return pStack->Return(NULL, pStk);	// erreur

-

-	if ( p->GetType() == ID_HI ||

-		 p->GetType() == ID_LO ||

-		 p->GetType() == ID_HS ||

-		 p->GetType() == ID_LS ||

-		 p->GetType() == ID_EQ ||

-		 p->GetType() == ID_NE)								// les diverses comparaisons

-	{

-		CBotCompExpr* inst = new CBotCompExpr();			// élément pour opération

-		inst->SetToken(p);									// mémorise l'opération

-

-		int			 type1, type2;

-		type1 = pStack->GetType();

-

-		p = p->Next();

-		if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) )	// expression A + B à droite

-		{

-			type2 = pStack->GetType();

-			// les résultats sont-ils compatibles

-			if ( type1 == type2 )

-			{

-				inst->m_leftop = left;

-				pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));

-															// le résultat est un boolean

-				return pStack->Return(inst, pStk);

-			}

-		}

-

-		delete left;

-		delete inst;

-		return pStack->Return(NULL, pStk);

-	}

-

-	return pStack->Return(left, pStk);

-}

-

-

-// fait l'opération

-

-BOOL CBotCompExpr::Execute(CBotStack* &pStack)

-{

-	CBotStack* pStk1 = pStack->AddStack(this);

-//	if ( pStk1 == EOX ) return TRUE;

-

-	if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrompu ici ?

-

-	pStk1->SetState(1);		// opération terminée

-

-	// demande un peu plus de stack pour ne pas toucher le résultat de gauche

-	CBotStack* pStk2 = pStk1->AddStack();

-

-	if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrompu ici ?

-

-	int		type1 = pStk1->GetType();

-	int		type2 = pStk2->GetType();

-

-	CBotVar*	result = new CBotVar( NULL, CBotTypBoolean );

-

-	switch (GetTokenType())

-	{

-	case ID_LO:

-		result->Lo(pStk1->GetVar(), pStk2->GetVar());		// inférieur

-		break;

-	case ID_HI:

-		result->Hi(pStk1->GetVar(), pStk2->GetVar());		// supérieur

-		break;

-	case ID_LS:

-		result->Ls(pStk1->GetVar(), pStk2->GetVar());		// inférieur ou égal

-		break;

-	case ID_HS:

-		result->Hs(pStk1->GetVar(), pStk2->GetVar());		// supérieur ou égal

-		break;

-	case ID_EQ:

-		result->Eq(pStk1->GetVar(), pStk2->GetVar());		// égal

-		break;

-	case ID_NE:

-		result->Ne(pStk1->GetVar(), pStk2->GetVar());		// différent

-		break;

-	}

-	pStk2->SetVar(result);				// met le résultat sur la pile

-

-	pStk1->Return(pStk2);				// libère la pile

-	return pStack->Return(pStk1);		// transmet le résultat

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////
+// expression of type Opérande1 > Opérande2
+//                     Opérande1 != Opérande2
+// etc.
+
+#include "CBot.h"
+
+// various constructeurs
+
+CBotCompExpr::CBotCompExpr()
+{
+    m_leftop    =
+    m_rightop   = NULL;
+    name = "CBotCompExpr";
+}
+
+CBotCompExpr::~CBotCompExpr()
+{
+    delete  m_leftop;
+    delete  m_rightop;
+}
+
+fichier plus utilise;
+
+// compile instruction of type A < B
+
+CBotInstr* CBotCompExpr::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCStack* pStk = pStack->AddStack();
+
+    CBotInstr*  left = CBotAddExpr::Compile( p, pStk );     // expression A + B left
+    if (left == NULL) return pStack->Return(NULL, pStk);    // error
+
+    if ( p->GetType() == ID_HI ||
+         p->GetType() == ID_LO ||
+         p->GetType() == ID_HS ||
+         p->GetType() == ID_LS ||
+         p->GetType() == ID_EQ ||
+         p->GetType() == ID_NE)                             // the various comparisons
+    {
+        CBotCompExpr* inst = new CBotCompExpr();            // element for operation
+        inst->SetToken(p);                                  // stores the operation
+
+        int          type1, type2;
+        type1 = pStack->GetType();
+
+        p = p->Next();
+        if ( NULL != (inst->m_rightop = CBotAddExpr::Compile( p, pStk )) )  // expression A + B right
+        {
+            type2 = pStack->GetType();
+            // are the results compatible
+            if ( type1 == type2 )
+            {
+                inst->m_leftop = left;
+                pStk->SetVar(new CBotVar(NULL, CBotTypBoolean));
+                                                            // the result is a boolean
+                return pStack->Return(inst, pStk);
+            }
+        }
+
+        delete left;
+        delete inst;
+        return pStack->Return(NULL, pStk);
+    }
+
+    return pStack->Return(left, pStk);
+}
+
+
+// perform the operation 
+
+bool CBotCompExpr::Execute(CBotStack* &pStack)
+{
+    CBotStack* pStk1 = pStack->AddStack(this);
+//  if ( pStk1 == EOX ) return TRUE;
+
+    if ( pStk1->GetState() == 0 && !m_leftop->Execute(pStk1) ) return FALSE; // interrupted here ?
+
+    pStk1->SetState(1);     // finished
+
+    // requires a little more stack to not touch the result of the left
+    CBotStack* pStk2 = pStk1->AddStack();
+
+    if ( !m_rightop->Execute(pStk2) ) return FALSE; // interrupted here ?
+
+    int     type1 = pStk1->GetType();
+    int     type2 = pStk2->GetType();
+
+    CBotVar*    result = new CBotVar( NULL, CBotTypBoolean );
+
+    switch (GetTokenType())
+    {
+    case ID_LO:
+        result->Lo(pStk1->GetVar(), pStk2->GetVar());       // lower
+        break;
+    case ID_HI:
+        result->Hi(pStk1->GetVar(), pStk2->GetVar());       // higher
+        break;
+    case ID_LS:
+        result->Ls(pStk1->GetVar(), pStk2->GetVar());       // lower or equal
+        break;
+    case ID_HS:
+        result->Hs(pStk1->GetVar(), pStk2->GetVar());       // higher of equal
+        break;
+    case ID_EQ:
+        result->Eq(pStk1->GetVar(), pStk2->GetVar());       // equal
+        break;
+    case ID_NE:
+        result->Ne(pStk1->GetVar(), pStk2->GetVar());       // not equal
+        break;
+    }
+    pStk2->SetVar(result);              // puts the result on the stack
+
+    pStk1->Return(pStk2);               // frees the stack
+    return pStack->Return(pStk1);       // transmit the result
+}
+
diff --git a/src/CBot/CBotDll.h b/src/CBot/CBotDll.h
index 7fa9472..269ef94 100644
--- a/src/CBot/CBotDll.h
+++ b/src/CBot/CBotDll.h
@@ -1,1200 +1,1117 @@
-// * 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  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////////

-// Librairie pour l'interprétation du language CBOT

-// pour le jeu COLOBOT

-//

-

-//#include "stdafx.h"

-

-#include <windows.h>        

-#include <stdio.h>

-

-#define DllExport    __declspec( dllexport )

-

-#define	CBOTVERSION	104

-

-////////////////////////////////////////////////////////////////////////

-// quelques classes définies par ailleurs

-

-class CBotToken;		// programme transformé en "jetons"		

-class CBotStack;		// pile pour l'exécution

-class CBotClass;		// classe d'object

-class CBotInstr;		// instruction à exécuter

-class CBotFunction;		// les fonctions user

-class CBotVar;			// les variables

-class CBotVarClass;		// une instance de classe

-class CBotVarPointer;	// pointeur à une instance de classe

-class CBotCall;			// les fonctions

-class CBotCallMethode;	// les méthodes

-class CBotDefParam;		// liste de paramètres

-class CBotCStack;

-

-

-////////////////////////////////////////////////////////////////////////

-// Gestion des variables

-////////////////////////////////////////////////////////////////////////

-

-// ces types sont calqués sur les types Java

-// ne pas changer l'ordre de ces types

-

-enum CBotType

-{

-	CBotTypVoid			= 0,				// fonction retournant void

-	CBotTypByte			= 1,	//n			// nombre entier ( 8 bits)

-	CBotTypShort		= 2,	//n			// nombre entier (16 bits)

-	CBotTypChar			= 3,	//n			// caractère "unicode" (16 bits)

-	CBotTypInt			= 4,				// nombre entier (32 bits)

-	CBotTypLong			= 5,	//n			// nombre entier (64 bits)

-	CBotTypFloat		= 6,				// nombre décimal (32 bits)

-	CBotTypDouble		= 7,	//n			// nombre décimal (64 bits)

-	CBotTypBoolean		= 8,				// true ou false exclusivement

-	CBotTypString		= 9,				// chaine de caractère

-

-	CBotTypArrayPointer	= 10,				// un tableau de variables

-	CBotTypArrayBody	= 11,				// idem mais crée l'instance

-

-	CBotTypPointer		= 12,				// pointeur à une instance

-	CBotTypNullPointer  = 13,				// pointeur null est spécial

-

-	CBotTypClass		= 15,				// instance d'une classe

-	CBotTypIntrinsic	= 16				// instance d'une classe intrinsèque

-};

-			//n = non encore implémenté

-

-// pour SetUserPtr lors de la suppression d'un objet

-#define OBJECTDELETED ((void*)-1)

-// valeur mise avant initialisation

-#define OBJECTCREATED ((void*)-2)

-

-

-// classe permettant de définir le type complet d'un résultat

-class CBotTypResult

-{

-private:

-	int				m_type;

-	CBotTypResult*	m_pNext;	// pour les types de types

-	CBotClass*		m_pClass;	// pour les dérivés de classe

-	int				m_limite;	// limitation des tableaux 

-	friend class	CBotVarClass;

-	friend class	CBotVarPointer;	

-

-public:

-	// divers constructeurs selon les besoins

-	DllExport

-				CBotTypResult(int type);

-				// pour les types simples (CBotTypInt à CBotTypString)

-	DllExport

-				CBotTypResult(int type, const char* name);

-				// pour les types pointeur et classe intrinsic

-	DllExport

-				CBotTypResult(int type, CBotClass* pClass);

-				// idem à partir de l'instance d'une classe

-	DllExport

-				CBotTypResult(int type, CBotTypResult elem);

-				// pour les tableaux de variables

-

-	DllExport

-				CBotTypResult(const CBotTypResult& typ);

-				// pour les assignations

-	DllExport

-				CBotTypResult();

-				// pour par défaut

-	DllExport

-				~CBotTypResult();

-

-	DllExport

-	int			GivType(int mode = 0) const;

-				// rend le type CBotTyp* du résultat

-

-	void		SetType(int n);

-				// modifie le type

-

-	DllExport

-	CBotClass*	GivClass() const;

-				// rend le pointeur à la classe (pour les CBotTypClass, CBotTypPointer)

-

-	DllExport

-	int			GivLimite() const;

-				// rend la taille limite du tableau (CBotTypArray)

-

-	DllExport

-	void		SetLimite(int n);

-				// fixe une limite au tableau

-

-	void		SetArray(int* max );

-				// idem avec une liste de dimension (tableaux de tableaux)

-

-	DllExport

-	CBotTypResult& GivTypElem() const;

-				// rend le type des éléments du tableau (CBotTypArray)

-

-	DllExport

-	BOOL		Compare(const CBotTypResult& typ) const;

-				// compare si les types sont compatibles

-	DllExport

-	BOOL		Eq(int type) const;

-				// compare le type

-

-	DllExport

-	CBotTypResult&

-				operator=(const CBotTypResult& src);

-				// copie un type complet dans un autre

-};

-

-/*

-// pour définir un résultat en sortie, utiliser par exemple

-

-	// pour rendre un simple Float

-	return CBotTypResult( CBotTypFloat );

-

-

-	// pour rendre un tableau de string

-	return CBotTypResult( CBotTypArray, CBotTypResult( CBotTypString ) );

-

-	// pour rendre un tableau de tableau de "point"

-	CBotTypResult	typPoint( CBotTypIntrinsic, "point" );

-	CBotTypResult	arrPoint( CBotTypArray, typPoint );

-	return	CBotTypResult( CBotTypArray, arrPoint );

-*/

-

-

-////////////////////////////////////////////////////////////////////////

-// Gestion des erreurs compilation et exécution

-////////////////////////////////////////////////////////////////////////

-

-// voici la liste des erreurs pouvant être retournées par le module

-// pour la compilation

-

-#define	CBotErrOpenPar			5000	// manque la parenthèse ouvrante

-#define	CBotErrClosePar			5001	// manque la parenthèse fermante

-#define	CBotErrNotBoolean		5002	// l'expression doit être un boolean

-#define	CBotErrUndefVar			5003	// variable non déclarée

-#define	CBotErrBadLeft			5004	// assignation impossible ( 5 = ... )

-#define	CBotErrNoTerminator		5005	// point-virgule attendu

-#define	CBotErrCaseOut			5006	// case en dehors d'un switch

-//	CBotErrNoTerm			5007, plus utile

-#define	CBotErrCloseBlock		5008	// manque " } "

-#define	CBotErrElseWhitoutIf	5009	// else sans if correspondant

-#define	CBotErrOpenBlock		5010	// manque " { "

-#define	CBotErrBadType1			5011	// mauvais type pour l'assignation

-#define	CBotErrRedefVar			5012	// redéfinition de la variable

-#define	CBotErrBadType2			5013	// 2 opérandes de type incompatibles

-#define	CBotErrUndefCall		5014	// routine inconnue

-#define	CBotErrNoDoubleDots		5015	// " : " attendu

-//	CBotErrWhile			5016, plus utile

-#define	CBotErrBreakOutside		5017	// break en dehors d'une boucle

-#define	CBotErrUndefLabel		5019	// label inconnu

-#define	CBotErrLabel			5018	// label ne peut se mettre ici

-#define	CBotErrNoCase			5020	// manque " case "

-#define	CBotErrBadNum			5021	// nombre attendu

-#define	CBotErrVoid				5022	// " void " pas possible ici

-#define	CBotErrNoType			5023	// déclaration de type attendue

-#define	CBotErrNoVar			5024	// nom de variable attendu

-#define	CBotErrNoFunc			5025	// nom de fonction attendu

-#define	CBotErrOverParam		5026	// trop de paramètres

-#define	CBotErrRedefFunc		5027	// cette fonction existe déjà

-#define	CBotErrLowParam			5028	// pas assez de paramètres

-#define	CBotErrBadParam			5029	// mauvais types de paramètres

-#define	CBotErrNbParam			5030	// mauvais nombre de paramètres

-#define	CBotErrUndefItem		5031	// élément n'existe pas dans la classe

-#define	CBotErrUndefClass		5032	// variable n'est pas une classe

-#define	CBotErrNoConstruct		5033	// pas de constructeur approprié

-#define	CBotErrRedefClass		5034	// classe existe déjà

-#define	CBotErrCloseIndex		5035	// " ] " attendu

-#define	CBotErrReserved			5036	// mot réservé (par un DefineNum)

-#define CBotErrBadNew			5037	// mauvais paramètre pour new

-#define CBotErrOpenIndex	    5038	// " [ " attendu

-#define CBotErrBadString		5039	// chaîne de caractère attendue

-#define CBotErrBadIndex			5040	// mauvais type d'index "[ false ]"

-#define CBotErrPrivate			5041	// élément protégé

-#define CBotErrNoPublic			5042	// manque le mot "public"

-

-// voici la liste des erreurs pouvant être retournées par le module

-// pour l'exécution

-

-#define	CBotErrZeroDiv			6000	// division par zéro

-#define	CBotErrNotInit			6001	// variable non initialisée

-#define	CBotErrBadThrow			6002	// throw d'une valeur négative

-#define	CBotErrNoRetVal			6003	// fonction n'a pas retourné de résultat

-#define	CBotErrNoRun			6004	// Run() sans fonction active

-#define	CBotErrUndefFunc		6005	// appel d'une fonction qui n'existe plus

-#define CBotErrNotClass			6006	// cette classe n'existe pas

-#define CBotErrNull				6007	// pointeur null

-#define CBotErrNan				6008	// calcul avec un NAN

-#define CBotErrOutArray			6009	// index hors du tableau

-#define CBotErrStackOver		6010	// dépassement de la pile

-#define CBotErrDeletedPtr		6011	// pointeur à un objet détruit

-

-#define CBotErrFileOpen			6012	// ouverture du fichier impossible

-#define CBotErrNotOpen			6013	// canal pas ouvert

-#define CBotErrRead				6014	// erreur à la lecture

-#define CBotErrWrite			6015	// erreur à l'écriture

-

-// d'autres valeurs peuvent être rendues 

-// par exemple les exceptions rendues par les routines externes

-// et les " throw " avec un nombre quelconque.

-

-

-////////////////////////////////////////////////////////////////////////

-// définie une classe pour l'utilisation des strings

-// car CString fait partie de MFC pas utilisé ici.

-//

-// ( toutes les fonctions ne sont pas encore implémentées )

-

-class CBotString

-{

-private:

-	char*			m_ptr;						// pointeur à la chaine

-	int				m_lg;						// longueur de la chaine

-	static 

-	HINSTANCE		m_hInstance;

-

-public:

-	DllExport

-					CBotString();

-	DllExport

-					CBotString(const char* p);

-	DllExport

-					CBotString(const CBotString& p);

-	DllExport

-					~CBotString();

-

-	DllExport

-	void			Empty();

-	DllExport

-	BOOL			IsEmpty() const;

-	DllExport

-	int				GivLength();

-	DllExport

-	int				Find(const char c);

-	DllExport

-	int				Find(LPCTSTR lpsz);

-	DllExport

-	int				ReverseFind(const char c);

-	DllExport

-	int				ReverseFind(LPCTSTR lpsz);

-	DllExport

-	BOOL			LoadString(UINT id);

-	DllExport

-	CBotString		Mid(int nFirst, int nCount) const;

-	DllExport

-	CBotString		Mid(int nFirst) const;

-	DllExport

-	CBotString		Left(int nCount) const;

-	DllExport

-	CBotString		Right(int nCount) const;

-

-	DllExport

-	const CBotString&

-					operator=(const CBotString& stringSrc);

-	DllExport

-	const CBotString&

-					operator=(const char ch);

-	DllExport

-	const CBotString&

-					operator=(const char* pString);

-	DllExport

-	const CBotString&

-					operator+(const CBotString& str);

-	DllExport

-	friend CBotString 

-					operator+(const CBotString& string, LPCTSTR lpsz);

-

-	DllExport

-	const CBotString&

-					operator+=(const char ch);

-	DllExport

-	const CBotString& 

-					operator+=(const CBotString& str);

-	DllExport

-	BOOL			operator==(const CBotString& str);

-	DllExport

-	BOOL			operator==(const char* p);

-	DllExport

-	BOOL			operator!=(const CBotString& str);

-	DllExport

-	BOOL			operator!=(const char* p);

-	DllExport

-	BOOL			operator>(const CBotString& str);

-	DllExport

-	BOOL			operator>(const char* p);

-	DllExport

-	BOOL			operator>=(const CBotString& str);

-	DllExport

-	BOOL			operator>=(const char* p);

-	DllExport

-	BOOL			operator<(const CBotString& str);

-	DllExport

-	BOOL			operator<(const char* p);

-	DllExport

-	BOOL			operator<=(const CBotString& str);

-	DllExport

-	BOOL			operator<=(const char* p);

-

-	DllExport

-					operator LPCTSTR() const;           // as a C string

-

-	int				Compare(LPCTSTR lpsz) const;

-

-	DllExport

-	CBotString		Mid(int start, int lg=-1);

-

-	DllExport

-	void			MakeUpper();

-	DllExport

-	void			MakeLower();

-};

-

-

-// idem avec la gestion en tableau

-

-class CBotStringArray : public CBotString

-{

-private:

-	int				m_nSize;					// nombre d'éléments

-	int				m_nMaxSize;					// taille réservée

-	CBotString*		m_pData;					// ^aux données

-

-public:

-	DllExport

-					CBotStringArray();

-	DllExport

-					~CBotStringArray();

-	DllExport

-	void			SetSize(int nb);

-	DllExport

-	int				GivSize();

-	DllExport

-	void			Add(const CBotString& str);

-	DllExport

-	CBotString&		operator[](int nIndex);

-

-	DllExport

-	CBotString&		ElementAt(int nIndex);

-};

-

-// différents mode pour GetPosition

-enum CBotGet

-{

-	GetPosExtern	= 1,

-	GetPosNom		= 2,

-	GetPosParam		= 3,

-	GetPosBloc		= 4

-};

-

-////////////////////////////////////////////////////////////////////

-// classe principale gérant un programme CBot

-//

-

-class CBotProgram

-{

-private:

-	CBotFunction*	m_Prog;			// les fonctions définies par l'utilisateur

-	CBotFunction*	m_pRun;			// la fonction de base pour l'exécution

-	CBotClass*		m_pClass;		// les classes définies dans cette partie

-	CBotStack*		m_pStack;		// la pile d'exécution

-	CBotVar*		m_pInstance;	// instance de la classe parent

-	friend class	CBotFunction;

-

-	int				m_ErrorCode;

-	int				m_ErrorStart;

-	int				m_ErrorEnd;

-

-	long			m_Ident;		// identificateur associé

-

-public:

-	static

-	CBotString		m_DebugVarStr;	// a fin de debug

-	BOOL			m_bDebugDD;		// idem déclanchable par robot

-

-	BOOL			m_bCompileClass;

-

-public:

-	DllExport

-	static

-	void			Init();

-	//				initialise le module (défini les mots clefs pour les erreurs)

-	//				doit être fait une fois (et une seule) au tout début

-	DllExport

-	static

-	void			Free();

-	//				libère les zones mémoires statiques

-

-	DllExport

-	static

-	int				GivVersion();

-	//				donne la version de la librairie CBOT

-

-

-	DllExport

-					CBotProgram();

-	DllExport

-					CBotProgram(CBotVar* pInstance);

-	DllExport

-					~CBotProgram();

-

-	DllExport

-	BOOL			Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);

-	//				compile le programme donné en texte

-	//				retourne FALSE s'il y a une erreur à la compilation

-	//				voir GetCompileError() pour récupérer l'erreur

-	//				ListFonctions retourne le nom des fonctions déclarées extern

-	//				pUser permet de passer un pointeur pour les routines définies par AddFunction

-

-	DllExport

-	void			SetIdent(long n);

-	//				associe un identificateur avec l'instance CBotProgram

-

-	DllExport

-	long			GivIdent();

-	//				redonne l'identificateur

-

-	DllExport

-	int				GivError();

-	DllExport

-	BOOL			GetError(int& code, int& start, int& end);

-	DllExport

-	BOOL			GetError(int& code, int& start, int& end, CBotProgram* &pProg);

-	//				si TRUE

-	//				donne l'erreur trouvée à la compilation

-	//				ou à l'exécution

-	//				start et end délimite le bloc où se trouve l'erreur

-	//				pProg permet de savoir dans quel "module" s'est produite l'erreur d'exécution

-	DllExport

-	static

-	CBotString		GivErrorText(int code);

-

-

-	DllExport

-	BOOL			Start(const char* name);

-	//				définie quelle fonction doit être exécutée

-	//				retourne FALSE si la fontion name n'est pas trouvée

-	//				le programme ne fait rien, il faut appeller Run() pour cela

-

-	DllExport

-	BOOL			Run(void* pUser = NULL, int timer = -1);

-	//				exécute le programme

-	//				retourne FALSE si le programme a été suspendu

-	//				retourne TRUE si le programme s'est terminé avec ou sans erreur

-	//				timer = 0 permet de faire une avance pas à pas

-

-	DllExport

-	BOOL			GetRunPos(const char* &FunctionName, int &start, int &end);

-	//				donne la position dans le programme en exécution

-	//				retourne FALSE si on n'est pas en exécution (programme terminé)

-	//				FunctionName est un pointeur rendu sur le nom de la fonction

-	//				start et end la position dans le texte du token en traitement

-

-	DllExport

-	CBotVar*		GivStackVars(const char* &FunctionName, int level);

-	//				permet d'obtenir le pointeur aux variables sur la pile d'exécution

-	//				level est un paramètre d'entrée, 0 pour le dernier niveau, -1, -2, etc pour les autres niveau

-	//				la valeur retournée (CBotVar*) est une liste de variable (ou NULL)

-	//					qui peut être traité que la liste des paramètres reçu par une routine

-	//				FunctionName donne le nom de la fonction où se trouvent ces variables

-	//				FunctionName == NULL signifiant qu'on est plus dans le programme (selon level)

-

-	DllExport

-	void			Stop();

-	//				arrête l'exécution du programme

-	//				quitte donc le mode "suspendu"

-

-	DllExport

-	static

-	void			SetTimer(int n);

-	//				défini le nombre de pas (parties d'instructions) à faire

-	//				dans Run() avant de rendre la main "FALSE"

-

-	DllExport

-	static

-	BOOL			AddFunction(const char* name, 

-								BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-								CBotTypResult rCompile (CBotVar* &pVar, void* pUser));

-	//				cet appel permet d'ajouter de manière externe (**)

-	//				une nouvelle fonction utilisable par le programme CBot

-

-	DllExport

-	static

-	BOOL			DefineNum(const char* name, long val);

-

-	DllExport

-	BOOL			SaveState(FILE* pf);

-	//				sauvegarde l'état d'exécution dans le fichier

-	//				le fichier doit avoir été ouvert avec l'appel fopen de cette dll

-	//				sinon le système plante

-	DllExport

-	BOOL			RestoreState(FILE* pf);

-	//				rétablie l'état de l'exécution depuis le fichier

-	//				le programme compilé doit évidemment être identique

-

-	DllExport

-	BOOL			GetPosition(const char* name, int& start, int& stop, 

-								CBotGet modestart = GetPosExtern, 

-								CBotGet modestop  = GetPosBloc);

-	//				donne la position d'une routine dans le texte d'origine

-	//				le mode permet de choisir l'élément à trouver pour le début et la fin

-	//				voir les modes ci-dessus dans CBotGet

-

-

-	CBotFunction*	GivFunctions();

-};

-

-

-///////////////////////////////////////////////////////////////////////////////

-// routines pour la gestion d'un fichier (FILE*)

-	DllExport

-	FILE*		fOpen(const char* name, const char* mode);

-	DllExport

-	int			fClose(FILE* filehandle);

-	DllExport

-	size_t		fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle);

-	DllExport

-	size_t		fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle);

-

-

-#if 0

-/*

-(**) Note:

-	 Pour définir une fonction externe, il faut procéder ainsi:

-

-	a) définir une routine pour la compilation

-		cette routine reçois la liste des paramètres (sans valeurs)

-		et retourne soit un type de résultat (CBotTyp... ou 0 = void)

-		soit un numéro d'erreur

-	b) définir une routine pour l'exécution

-		cette rourine reCoit la liste des paramètres (avec valeurs),

-		une variable pour stocker le résultat (selon le type donné à la compilation)

-

-	Par exemple, une routine qui calcule la moyenne d'une liste de paramètres */

-

-int	cMoyenne(CBotVar* &pVar, CBotString& ClassName)

-{

-	if ( pVar == NULL ) return 6001;	// il n'y a aucun paramètre !

-

-	while ( pVar != NULL )

-	{

-		if ( pVar->GivType() > CBotTypDouble ) return 6002;		// ce n'est pas un nombre

-		pVar = pVar -> GivNext();

-	}

-

-	return CBotTypFloat;		// le type du résultat pourrait dépendre des paramètres !

-}

-

-

-BOOL rMoyenne(CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	float total = 0;

-	int   nb	  = 0;

-	while (pVar != NULL)

-	{

-		total += pVar->GivValFloat();

-		pVar = pVar->GivNext();

-		nb++;

-	}

-	pResult->SetValFloat(total/nb);				// retourne la valeur moyenne

-

-	return TRUE;								// opération totalement terminée

-}

-

-#endif

-

-/////////////////////////////////////////////////////////////////////////////////

-// Classe pour la gestion des variables

-

-// les méthodes marquées DllExport 

-// peuvent être utile à l'exterieur du module

-// ( il n'est pour l'instant pas prévu de pouvoir créer ces objets en externe )

-

-// résultats pour GivInit()

-#define	IS_UNDEF	0		// variable indéfinie

-#define IS_DEF		1		// variable définie

-#define	IS_NAN		999		// variable définie comme étant not a number

-

-// type de variable SetPrivate / IsPrivate

-#define PR_PUBLIC	0		// variable publique

-#define	PR_READ		1		// read only

-#define PR_PROTECT	2		// protected (héritage)

-#define PR_PRIVATE	3		// strictement privée

-

-class CBotVar

-{

-protected:

-	CBotToken*		m_token;					// le token correspondant

-

-	CBotVar*		m_next;						// liste de variables

-	friend class	CBotStack;

-	friend class	CBotCStack;

-	friend class	CBotInstrCall;

-	friend class	CBotProgram;

-

-	CBotTypResult	m_type;						// type de valeur

-

-	int				m_binit;					// pas initialisée ?

-	CBotVarClass*	m_pMyThis;					// ^élément this correspondant

-	void*			m_pUserPtr;					// ^données user s'il y a lieu

-	BOOL			m_bStatic;					// élément static (dans une classe)

-	int				m_mPrivate;					// élément public, protected ou private ?

-

-	CBotInstr*		m_InitExpr;					// expression pour le contenu initial

-	CBotInstr*		m_LimExpr;					// liste des limites pour un tableau

-	friend class	CBotClass;

-	friend class	CBotVarClass;

-	friend class	CBotVarPointer;

-	friend class	CBotVarArray;

-

-	long			m_ident;					// identificateur unique

-	static long		m_identcpt;					// compteur

-

-public:

-					CBotVar();

-virtual				~CBotVar( );						// destructeur

-

-

-/*	DllExport

-	static

-	CBotVar*		Create( const char* name, int type, const char* ClassName = NULL);

-	//				crée une variable selon son type,*/

-

-	DllExport

-	static

-	CBotVar*		Create( const char* name, CBotTypResult type);

-	//				idem à partir du type complet

-

-	DllExport

-	static

-	CBotVar*		Create( const char* name, CBotClass* pClass);

-	//				idem pour une instance d'une classe connue

-

-	static

-	CBotVar*		Create( const CBotToken* name, int type );

-	static

-	CBotVar*		Create( const CBotToken* name, CBotTypResult type );

-

-	static

-	CBotVar*		Create( const char* name, int type, CBotClass* pClass);

-

-	static

-	CBotVar*		Create( CBotVar* pVar );

-

-

-	DllExport

-	void			SetUserPtr(void* pUser);

-	//				associe un pointeur utilisateur à une instance

-

-	DllExport

-	virtual void	SetIdent(long UniqId);

-	//				associe un identificateur unique à une instance

-	//				( c'est à l'utilisateur de s'assurer que l'id est unique)

-

-	DllExport

-	void*			GivUserPtr();

-	//				rend le pointeur associé à la variable

-

-	DllExport

-	CBotString		GivName();					// le nom de la variable, s'il est connu

-	////////////////////////////////////////////////////////////////////////////////////

-	void			SetName(const char* name);	// change le nom de la variable

-

-	DllExport

-	int				GivType(int mode = 0);		// rend le type de base (int) de la variable

-	////////////////////////////////////////////////////////////////////////////////////////

-

-	DllExport

-	CBotTypResult	GivTypResult(int mode = 0);	// rend le type complet de la variable

-

-

-	CBotToken*		GivToken();

-	void			SetType(CBotTypResult& type);

-

-	DllExport

-	void			SetInit(int bInit);			// met la variable dans l'état IS_UNDEF, IS_DEF, IS_NAN

-

-	DllExport

-	int				GivInit();					// donne l'état de la variable

-

-	DllExport

-	void			SetStatic(BOOL bStatic);

-	DllExport

-	BOOL			IsStatic();

-

-	DllExport

-	void			SetPrivate(int mPrivate);

-	DllExport

-	BOOL			IsPrivate(int mode = PR_PROTECT);

-	DllExport

-	int				GivPrivate();

-

-	virtual

-	void			ConstructorSet();

-

-	void			SetVal(CBotVar* var);		// remprend une valeur

-

-	DllExport

-	virtual

-	CBotVar*		GivItem(const char* name);	// rend un élément d'une classe selon son nom (*)

-	virtual

-	CBotVar*		GivItemRef(int nIdent);		// idem à partir du n° ref

-

-	DllExport

-	virtual

-	CBotVar*		GivItem(int row, BOOL bGrow = FALSE); 

-

-	DllExport

-	virtual

-	CBotVar*		GivItemList();				// donne la liste des éléments

-

-	DllExport

-	CBotVar*		GivStaticVar();				// rend le pointeur à la variable si elle est statique

-

-	DllExport

-	BOOL			IsElemOfClass(const char* name);

-												// dit si l'élément appartient à la classe "name"

-												// rend TRUE si l'objet est d'une classe fille

-

-	DllExport

-	CBotVar*		GivNext();					// prochaine variable dans la liste (paramètres)

-	////////////////////////////////////////////////////////////////////////////////////////////

-

-	void			AddNext(CBotVar* pVar);		// ajoute dans une liste

-

-	virtual

-	void			Copy(CBotVar* pSrc, BOOL bName = TRUE);	// fait une copie de la variable

-

-	DllExport

-	virtual void	SetValInt(int val, const char* name = NULL);

-												// initialise avec une valeur entière (#)

-	/////////////////////////////////////////////////////////////////////////////////

-

-	DllExport

-	virtual void	SetValFloat(float val);		// initialise avec une valeur réelle (#)

-	////////////////////////////////////////////////////////////////////////////////

-

-	DllExport

-	virtual void	SetValString(const char* p);// initialise avec une valeur chaîne (#)

-	////////////////////////////////////////////////////////////////////////////////

-

-	DllExport

-	virtual int		GivValInt();				// demande la valeur entière (#)

-	////////////////////////////////////////////////////////////////////////

-

-	DllExport

-	virtual float	GivValFloat();				// demande la valeur réelle (#)

-	///////////////////////////////////////////////////////////////////////

-

-	virtual

-	CBotString 		GivValString();				// demande la valeur chaîne (#)

-	///////////////////////////////////////////////////////////////////////

-

-	virtual void	SetClass(CBotClass* pClass);

-	virtual

-	CBotClass*		GivClass();

-

-	virtual void	SetPointer(CBotVar* p);

-	virtual

-	CBotVarClass*	GivPointer();

-//	virtual void	SetIndirection(CBotVar* pVar);

-

-	virtual void	Add(CBotVar* left, CBotVar* right);	// addition

-	virtual void	Sub(CBotVar* left, CBotVar* right);	// soustraction

-	virtual void	Mul(CBotVar* left, CBotVar* right);	// multiplication

-	virtual int 	Div(CBotVar* left, CBotVar* right);	// division

-	virtual int		Modulo(CBotVar* left, CBotVar* right);	// reste de division

-	virtual void	Power(CBotVar* left, CBotVar* right);	// puissance

-

-	virtual BOOL	Lo(CBotVar* left, CBotVar* right);

-	virtual BOOL	Hi(CBotVar* left, CBotVar* right);

-	virtual BOOL	Ls(CBotVar* left, CBotVar* right);

-	virtual BOOL	Hs(CBotVar* left, CBotVar* right);

-	virtual BOOL	Eq(CBotVar* left, CBotVar* right);

-	virtual BOOL	Ne(CBotVar* left, CBotVar* right);

-

-	virtual void	And(CBotVar* left, CBotVar* right);

-	virtual void	Or(CBotVar* left, CBotVar* right);

-	virtual void	XOr(CBotVar* left, CBotVar* right);

-	virtual void	ASR(CBotVar* left, CBotVar* right);

-	virtual void	SR(CBotVar* left, CBotVar* right);

-	virtual void	SL(CBotVar* left, CBotVar* right);

-

-	virtual void	Neg();

-	virtual void	Not();

-	virtual void	Inc();

-	virtual void	Dec();

-

-

-	virtual BOOL	Save0State(FILE* pf);

-	virtual BOOL	Save1State(FILE* pf);

-	static	BOOL	RestoreState(FILE* pf, CBotVar* &pVar);

-

-	DllExport

-	void			debug();

-

-//	virtual

-//	CBotVar*		GivMyThis();

-

-	DllExport

-	virtual

-	void			Maj(void* pUser = NULL, BOOL bContinue = TRUE);

-

-	void			SetUniqNum(long n);

-	long			GivUniqNum();

-	static long		NextUniqNum();

-};

-

-/* NOTE (#)

-	les méthodes	SetValInt() SetValFloat() et SetValString()

-	ne peuvent êtes appellées qu'avec des objets respectivement entier, réelle ou chaîne

-	toujours s'assurer du type de la variable avant d'appeller ces méthodes

-

-	if ( pVar->GivType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!

-

-	les méthodes	GivValInt(), GivValFloat() et GivValString()

-	font des conversions de valeur,

-	GivValString() fonctionne sur des nombres (rend la chaîne correspondante)

-	par contre il ne faut pas faire de GivValInt() avec une variable de type chaîne !

-*/

-

-

-

-////////////////////////////////////////////////////////////////////////

-// Gestion des classes

-////////////////////////////////////////////////////////////////////////

-

-// classe pour définir de nouvelle classes dans le language CBOT

-// par exemple pour définir la classe CPoint (x,y)

-

-class CBotClass

-{

-private:

-	static

-	CBotClass*		m_ExClass;		// liste des classes existante à un moment donné

-	CBotClass*		m_ExNext;		// pour cette liste générale

-	CBotClass*		m_ExPrev;		// pour cette liste générale

-

-private:

-	CBotClass*		m_pParent;		// classe parent

-	CBotString		m_name;			// nom de cette classe-ci

-	int				m_nbVar;		// nombre de variables dans la chaîne

-	CBotVar*		m_pVar;			// contenu de la classe

-	BOOL			m_bIntrinsic;	// classe intrinsèque

-	CBotClass*		m_next;			// chaine les classe

-	CBotCallMethode* m_pCalls;		// liste des méthodes définie en externe

-	CBotFunction*	m_pMethod;		// liste des méthodes compilées

-	void			(*m_rMaj) ( CBotVar* pThis, void* pUser );

-	friend class	CBotVarClass;

-	int				m_cptLock;		// pour Lock / UnLock

-	int				m_cptOne;		// pour réentrance Lock

-	CBotProgram*	m_ProgInLock[5];// processus en attente pour synchro

-

-public:

-	BOOL			m_IsDef;		// marque si est définie ou pas encore

-

-	DllExport

-					CBotClass( const char* name,

-							   CBotClass* pParent, BOOL bIntrinsic = FALSE );		// constructeur

-	//				Dès qu'une classe est créée, elle est connue

-	//				partout dans CBot

-	//				le mode intrinsic donne une classe qui n'est pas gérée par des pointeurs

-

-	DllExport

-					~CBotClass( );							// destructeur

-

-	DllExport

-	BOOL			AddFunction(const char* name, 

-								BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 

-								CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));

-	//				cet appel permet d'ajouter de manière externe (**)

-	//				une nouvelle méthode utilisable par les objets de cette classe

-

-	DllExport

-	BOOL			AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );

-	//				défini la routine qui sera appellée pour mettre à jour les élements de la classe

-

-	DllExport

-	BOOL			AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);

-	//				ajoute un élément à la classe

-//	DllExport

-//	BOOL			AddItem(CBotString name, CBotClass* pClass);

-	//				idem pour des éléments appartenant à pClass

-	DllExport

-	BOOL			AddItem(CBotVar* pVar);

-	//				idem en passant le pointeur à une instance d'une variable

-	//				l'objet est pris tel quel, il ne faut donc pas le détruire

-

-

-

-	// idem en donnant un élément de type CBotVar

-	void			AddNext(CBotClass* pClass);

-

-	DllExport

-	CBotString		GivName();					// rend le nom de la classe

-	DllExport

-	CBotClass*		GivParent();				// donne la classe père (ou NULL)

-

-	// dit si une classe est dérivée (Extends) d'une autre

-	// rend TRUE aussi si les classes sont identiques

-	DllExport

-	BOOL			IsChildOf(CBotClass* pClass);

-

-	static

-	CBotClass*		Find(CBotToken* &pToken);	// trouve une classe d'après son nom

-

-	DllExport

-	static

-	CBotClass*		Find(const char* name);

-

-	CBotVar*		GivVar();					// rend la liste des variables

-	CBotVar*		GivItem(const char* name);	// l'une des variables selon son nom

-	CBotVar*		GivItemRef(int nIdent);

-

-	CBotTypResult	CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams, 

-								   CBotCStack* pStack, long& nIdent);

-

-	BOOL			ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken);

-	void			RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack);

-

-	// compile une classe déclarée par l'utilisateur

-	static

-	CBotClass*		Compile(CBotToken* &p, CBotCStack* pStack);

-	static

-	CBotClass*		Compile1(CBotToken* &p, CBotCStack* pStack);

-

-	BOOL			CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond);

-	

-	BOOL			IsIntrinsic();

-	void			Purge();

-	static

-	void			Free();

-

-	DllExport

-	static

-	BOOL			SaveStaticState(FILE* pf);

-

-	DllExport

-	static

-	BOOL			RestoreStaticState(FILE* pf);

-

-	BOOL			Lock(CBotProgram* p);

-	void			Unlock();

-	static

-	void			FreeLock(CBotProgram* p);

-

-	BOOL			CheckCall(CBotToken* &pToken, CBotDefParam* pParam);

-

-};

-

-#define	MAXDEFNUM			1000				// nombre limite des DefineNum

-

-/////////////////////////////////////////////////////////////////////////////////////

-// gestion des jetons (tokens)

-

-#define	TokenTypKeyWord		1					// un mot clef du language (voir TokenKeyWord)

-#define	TokenTypNum			2					// un nombre

-#define TokenTypString		3					// une chaine

-#define TokenTypVar			4					// un nom de variable

-#define TokenTypDef			5					// une valeur selon DefineNum

-

-#define TokenKeyWord		2000				// les mots clefs du langage

-#define TokenKeyDeclare		2100				// mots clefs pour déclarations (int, float,..)

-#define TokenKeyVal			2200				// les mots représentant une "valeur" (true, false, null, nan)

-#define TokenKeyOp			2300				// les opérateurs

-

-

-class CBotToken

-{

-private:

-	static

-	CBotStringArray	m_ListKeyWords;				// liste des mots clefs du language

-	static

-	int				m_ListIdKeyWords[200];		// les codes correspondants

-

-	static

-	CBotStringArray	m_ListKeyDefine;			// les noms définis par un DefineNum

-	static

-	long			m_ListKeyNums[MAXDEFNUM];	// les valeurs associées

-

-private:

-	CBotToken*		m_next;						// suivant dans la liste

-	CBotToken*		m_prev;

-	int				m_type;						// type de Token

-	long			m_IdKeyWord;				// numéro du mot clef si c'en est un

-												// ou valeur du "define"

-

-	CBotString		m_Text;						// mot trouvé comme token

-	CBotString		m_Sep;						// séparateurs qui suivent

-

-	int				m_start;					// position dans le texte d'origine (programme)

-	int				m_end;						// itou pour la fin du token

-

-	static

-	int				GivKeyWords(const char* w);	// est-ce un mot clef ?

-	static

-	BOOL			GivKeyDefNum(const char* w, CBotToken* &token);

-

-	static

-	void			LoadKeyWords();				// fait la liste des mots clefs

-

-public:

-					CBotToken();

-					CBotToken(const CBotToken* pSrc);

-					CBotToken(const CBotString& mot, const CBotString& sep, int start=0, int end=0);

-					CBotToken(const char* mot, const char* sep = NULL);

-												// constructeur

-					~CBotToken();				// destructeur

-

-	DllExport

-	int				GivType();					// rend le type du token

-

-	DllExport

-	CBotString&		GivString();				// rend la chaine correspondant à ce token

-

-	DllExport

-	CBotString&		GivSep();					// rend le séparateur suivant le token

-

-	DllExport

-	int				GivStart();					// position du début dans le texte

-	DllExport

-	int				GivEnd();					// position de fin dans le texte

-

-	DllExport

-	CBotToken*		GivNext();					// rend le suivant dans la liste

-	DllExport

-	CBotToken*		GivPrev();					// rend le Précédent dans la liste

-

-	DllExport

-	static

-	CBotToken*		CompileTokens(const char* p, int& error);

-												// transforme tout le programme

-	DllExport

-	static

-	void			Delete(CBotToken* pToken);	// libère la liste

-

-

-	// fonctions non utiles en export

-	static

-	BOOL			DefineNum(const char* name, long val);

-	void			SetString(const char* name);

-

-	void			SetPos(int start, int end);

-	long			GivIdKey();

-	void			AddNext(CBotToken* p);		// ajoute un token (une copie)

-

-	static

-	CBotToken*		NextToken(char* &program, int& error, BOOL first = FALSE);

-												// trouve le prochain token

-	const CBotToken&

-					operator=(const CBotToken& src);

-

-	static

-	void			Free();

-};

-

-

-

-#if 0

-////////////////////////////////////////////////////////////////////////

-// Exemples d'utilisation

-// Définition de classes et de fonctions

-

-

-// définie la classe globale CPoint

-// --------------------------------

-	m_pClassPoint	= new CBotClass("CPoint", NULL);

-	// ajoute le composant ".x"

-	m_pClassPoint->AddItem("x", CBotTypResult(CBotTypFloat));

-	// ajoute le composant ".y"

-	m_pClassPoint->AddItem("y", CBotTypResult(CBotTypFloat));

-	// le joueur peut alors utiliser les instructions

-	// CPoint position; position.x = 12; position.y = -13.6

-

-// définie la classe CColobotObject

-// --------------------------------

-// cette classe gère tous les objets dans le monde de COLOBOT

-// le programme utilisateur "main" appartient à cette classe

-	m_pClassObject	= new CBotClass("CColobotObject", m_pClassBase);

-	// ajoute le composant ".position"

-	m_pClassObject->AddItem("position", m_pClassPoint);

-	// ajoute le composant ".type"

-	m_pClassObject->AddItem("type", CBotTypResult(CBotTypShort));

-	// ajoute une définition de constante

-	m_pClassObject->AddConst("ROBOT", CBotTypShort, 1);			// ROBOT équivalent à la valeur 1

-	// ajoute la routine FIND

-	m_pClassObject->AddFunction( rCompFind, rDoFind );

-	// le joueur peut maintenant utiliser les instructions

-	// CColobotObject chose; chose = FIND( ROBOT )

-

-

-

-// définie la classe CColobotRobot dérivée de CColobotObject

-// ---------------------------------------------------------

-// les programmes "main" associés aux robots font partie de cette classe

-	m_pClassRobot	= new CBotClass("CColobotRobot", m_pClassObject);

-	// ajoute la routine GOTO

-	m_pClassRobot->AddFunction( rCompGoto, rDoGoto );

-	// le joueur peut maintenant faire

-	// GOTO( FIND ( ROBOT ) );

-

-

-// crée une instance de la classe Robot

-// ------------------------------------

-// par exemple un nouveau robot qui vient d'être fabriqué

-	CBotVar*	m_pMonRobot = new CBotVar("MonRobot", m_pClassRobot);

-

-// compile le programme main pour ce robot-là

-// ------------------------------------------

-	CString LeProgramme( "void main() {GOTO(0, 0); return 0;}" );

-	if ( !m_pMonRobot->Compile( LeProgramme ) ) {gestion d'erreur...};

-

-// construit une pile pour l'interpréteur

-// --------------------------------------

-	CBotStack*	pStack = new CBotStack(NULL);

-

-// exécute le programme main

-// -------------------------

-	while( FALSE = m_pMonRobot->Execute( "main", pStack ))

-	{

-		// programme suspendu

-		// on pourrait passer la main à un autre (en sauvegardant pStack pour ce robot-là)

-	};

-	// programme "main" terminé !

-

-

-

-

-// routine implémentant l'instruction GOTO( CPoint pos )

-BOOL rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )

-{

-	if (pVar->GivType() != CBotTypeClass ||

-		pVar->IsElemOfClas("CPoint") ) { exception = 6522; return FALSE; )

-		// le paramètre n'est pas de la bonne classe ?

-		// NB en fait ce contrôle est déjà fait par la routine pour la compilation

-

-	m_PosToGo.Copy( pVar );				// garde la position à atteindre (object type CBotVar)

-

-	// ou alors

-	CBotVar*	temp;

-	temp = pVar->GivItem("x");			// trouve forcément pour un object de type "CPoint"

-	ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);

-	m_PosToGo.x = temp->GivValFloat();

-

-	temp = pVar->GivItem("y");			// trouve forcément pour un object de type "CPoint"

-	ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);

-	m_PosToGo.y = temp->GivValFloat();

-

-	return (m_CurentPos == m_PosToGo);	// rend TRUE si la position est atteinte

-										// rend FALSE s'il faut patienter encore

-}

-

-#endif
\ No newline at end of file
+// * 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  http://www.gnu.org/licenses/.
+////////////////////////////////////////////////////////////////////////
+
+#pragma once
+#ifndef _CBOTDLL_H_ 
+#define _CBOTDLL_H_
+/**
+ * \file CBotDll.h
+ * \brief Library for interpretation of CBOT language
+ */
+
+#include <stdio.h>
+#include "resource.h"
+#include <map>
+#include <cstring>
+
+
+#define    CBOTVERSION    104
+
+////////////////////////////////////////////////////////////////////////
+// forward declaration of needed classes
+
+class CBotToken;        // program turned into "tokens
+class CBotStack;        // for the execution stack
+class CBotClass;        // class of object
+class CBotInstr;        // instruction to be executed
+class CBotFunction;     // user functions
+class CBotVar;          // variables
+class CBotVarClass;     // instance of class
+class CBotVarPointer;   // pointer to an instance of class
+class CBotCall;         // functions
+class CBotCallMethode;  // methods
+class CBotDefParam;     // parameter list
+class CBotCStack;       // stack
+
+
+////////////////////////////////////////////////////////////////////////
+// Variables management
+////////////////////////////////////////////////////////////////////////
+
+/** \brief CBotType Defines known types. This types are modeled on Java types. Do not change the order of elements */
+enum CBotType
+{
+    CBotTypVoid         = 0,
+    CBotTypByte         = 1,                //n
+    CBotTypShort        = 2,                //n
+    CBotTypChar         = 3,                //n
+    CBotTypInt          = 4,
+    CBotTypLong         = 5,                //n
+    CBotTypFloat        = 6,
+    CBotTypDouble       = 7,                //n
+    CBotTypBoolean      = 8,
+    CBotTypString       = 9,
+
+    CBotTypArrayPointer = 10,                // array of variables
+    CBotTypArrayBody    = 11,                // same but creates an instance
+
+    CBotTypPointer      = 12,                // pointer to an instance
+    CBotTypNullPointer  = 13,                // null pointer is special
+    CBotTypClass        = 15,
+    CBotTypIntrinsic    = 16                // instance of a class intrinsic
+};
+//n = not implemented yet
+
+// for SetUserPtr when deleting an object
+#define OBJECTDELETED ((void*)-1)
+// value set before initialization
+#define OBJECTCREATED ((void*)-2)
+
+
+/** \brief CBotTypResult class to define the complete type of a result*/
+class CBotTypResult
+{
+public:
+    /**
+     * \brief CBotTypResult constructor  for simple types (CBotTypInt to CBotTypString)
+     * \param type type of created result, see CBotType
+     */
+    CBotTypResult(int type);
+    // for simple types (CBotTypInt à CBotTypString)
+
+    
+    CBotTypResult(int type, const char* name);
+    // for pointer types and intrinsic classes
+    
+    CBotTypResult(int type, CBotClass* pClass);
+    // for the instance of a class
+    
+    CBotTypResult(int type, CBotTypResult elem);
+    // for arrays of variables
+    
+    CBotTypResult(const CBotTypResult& typ);
+    // for assignments
+    
+    CBotTypResult();
+    // for default
+    
+    ~CBotTypResult();
+
+    int            GivType(int mode = 0) const;
+    // returns type CBotType* as a result
+
+    void        SetType(int n);
+    // modifies a type
+
+    CBotClass*    GivClass() const;
+    // makes the pointer to the class (for CBotTypClass, CBotTypPointer)
+
+    int            GivLimite() const;
+    // returns limit size of table (CBotTypArray)
+
+    void        SetLimite(int n);
+    // set limit to the table
+
+    void        SetArray(int* max );
+    // set limits for a list of dimensions (arrays of arrays)
+
+    CBotTypResult& GivTypElem() const;
+    // returns type of array elements (CBotTypArray)
+    // rend le type des éléments du tableau (CBotTypArray)
+
+    bool        Compare(const CBotTypResult& typ) const;
+    // compares whether the types are compatible
+    bool        Eq(int type) const;
+    // compare type
+
+    CBotTypResult& operator=(const CBotTypResult& src);
+    // copy a complete type in another
+
+private:
+    int                m_type;
+    CBotTypResult*    m_pNext;    // for the types of type
+    CBotClass*        m_pClass;    // for the derivatives of class
+    int                m_limite;    // limits of tables
+    friend class    CBotVarClass;
+    friend class    CBotVarPointer;    
+};
+
+/*
+// to define a result as output, using for example
+
+    // to return a simple Float
+    return CBotTypResult( CBotTypFloat );
+
+
+    // to return a string array
+    return CBotTypResult( CBotTypArray, CBotTypResult( CBotTypString ) );
+
+    // to return un array of array of "point" class
+    CBotTypResult    typPoint( CBotTypIntrinsic, "point" );
+    CBotTypResult    arrPoint( CBotTypArray, typPoint );
+    return    CBotTypResult( CBotTypArray, arrPoint );
+*/
+
+
+////////////////////////////////////////////////////////////////////////
+// Error Handling of compilation and execution
+////////////////////////////////////////////////////////////////////////
+
+// Here are the list of errors that can be returned by the module
+// for compilation
+
+#define    CBotErrOpenPar            5000    // missing the opening parenthesis
+#define    CBotErrClosePar            5001    // missing the closing parenthesis
+#define    CBotErrNotBoolean        5002    // expression must be a boolean
+#define    CBotErrUndefVar            5003    // undeclared variable
+#define    CBotErrBadLeft            5004    // assignment impossible ( 5 = ... )
+#define    CBotErrNoTerminator        5005    // semicolon expected
+#define    CBotErrCaseOut            5006    // case outside a switch
+//    CBotErrNoTerm            5007, plus utile
+#define    CBotErrCloseBlock        5008    // missing " } "
+#define    CBotErrElseWhitoutIf    5009    // else without matching if
+#define    CBotErrOpenBlock        5010    // missing " { "
+#define    CBotErrBadType1            5011    // wrong type for the assignment
+#define    CBotErrRedefVar            5012    // redefinition of the variable
+#define    CBotErrBadType2            5013    // Two operands are incompatible
+#define    CBotErrUndefCall        5014    // routine undefined
+#define    CBotErrNoDoubleDots        5015    // " : " expected
+//    CBotErrWhile            5016, plus utile
+#define    CBotErrBreakOutside        5017    // break outside of a loop
+#define    CBotErrUndefLabel        5019    // label udnefined
+#define    CBotErrLabel            5018    // label ne peut se mettre ici (label can not get here)
+#define    CBotErrNoCase            5020    // missing " case "
+#define    CBotErrBadNum            5021    // expected number
+#define    CBotErrVoid                5022    // " void " not possible here
+#define    CBotErrNoType            5023    // type declaration expected
+#define    CBotErrNoVar            5024    // variable name expected
+#define    CBotErrNoFunc            5025    // expected function name
+#define    CBotErrOverParam        5026    // too many parameters
+#define    CBotErrRedefFunc        5027    // this function already exists
+#define    CBotErrLowParam            5028    // not enough parameters
+#define    CBotErrBadParam            5029    // wrong types of parameters
+#define    CBotErrNbParam            5030    // wrong number of parameters
+#define    CBotErrUndefItem        5031    // element does not exist in the class
+#define    CBotErrUndefClass        5032    // variable is not a class
+#define    CBotErrNoConstruct        5033    // no appropriate constructor
+#define    CBotErrRedefClass        5034    // class already exists
+#define    CBotErrCloseIndex        5035    // " ] " expected
+#define    CBotErrReserved            5036    // reserved word (for a DefineNum)
+#define CBotErrBadNew            5037    // wrong setting for new
+#define CBotErrOpenIndex        5038    // " [ " expected
+#define CBotErrBadString        5039    // expected string
+#define CBotErrBadIndex            5040    // wrong index type "[ false ]"
+#define CBotErrPrivate            5041    // protected item
+#define CBotErrNoPublic            5042    // missing word "public"
+
+// here is the list of errors that can be returned by the module
+// for the execution
+
+#define    CBotErrZeroDiv            6000    // division by zero
+#define    CBotErrNotInit            6001    // uninitialized variable
+#define    CBotErrBadThrow            6002    // throw a negative value
+#define    CBotErrNoRetVal            6003    // function did not return results
+#define    CBotErrNoRun            6004    // Run() without active function
+#define    CBotErrUndefFunc        6005    // calling a function that no longer exists
+#define CBotErrNotClass            6006    // this class does not exist
+#define CBotErrNull                6007    // null pointer
+#define CBotErrNan                6008    // calculation with a NAN
+#define CBotErrOutArray            6009    // index out of array
+#define CBotErrStackOver        6010    // stack overflow
+#define CBotErrDeletedPtr        6011    // pointer to an object destroyed
+
+#define CBotErrFileOpen            6012    // cannot open the file
+#define CBotErrNotOpen            6013    // channel not open
+#define CBotErrRead                6014    // error while reading
+#define CBotErrWrite            6015    // writing error
+
+
+// other values ​​may be returned
+// for example exceptions returned by external routines
+// and " throw " with any number.
+
+
+////////////////////////////////////////////////////////////////////////
+// 
+// as part of MFC CString not used here.
+//
+// ( all functions are not implemented yet )
+
+/** \brief CBotString Class used to work on strings */
+class CBotString
+{
+public:
+    CBotString();
+    CBotString(const char* p);
+    CBotString(const CBotString& p);
+    ~CBotString();
+
+    void       Empty();
+    bool       IsEmpty() const;
+    int        GivLength();
+    int        Find(const char c);
+    int        Find(const char* lpsz);
+    int        ReverseFind(const char c);
+    int        ReverseFind(const char* lpsz);
+    bool       LoadString(unsigned int id);
+    CBotString Mid(int nFirst, int nCount) const;
+    CBotString Mid(int nFirst) const;
+    CBotString Mid(int start, int lg=-1);
+    CBotString Left(int nCount) const;
+    CBotString Right(int nCount) const;
+    int        Compare(const char* lpsz) const;
+    void       MakeUpper();
+    void       MakeLower();
+
+
+    /**
+     * \brief Overloaded oprators to work on CBotString classes
+     */
+    const CBotString& operator=(const CBotString& stringSrc);
+    const CBotString& operator=(const char ch);
+    const CBotString& operator=(const char* pString);
+    const CBotString& operator+(const CBotString& str);
+    friend CBotString operator+(const CBotString& string, const char* lpsz);
+
+    const CBotString& operator+=(const char ch);
+    const CBotString& operator+=(const CBotString& str);
+    bool              operator==(const CBotString& str);
+    bool              operator==(const char* p);
+    bool              operator!=(const CBotString& str);
+    bool              operator!=(const char* p);
+    bool              operator>(const CBotString& str);
+    bool              operator>(const char* p);
+    bool              operator>=(const CBotString& str);
+    bool              operator>=(const char* p);
+    bool              operator<(const CBotString& str);
+    bool              operator<(const char* p);
+    bool              operator<=(const CBotString& str);
+    bool              operator<=(const char* p);
+
+                      operator const char*() const;           // as a C string
+
+
+private:
+
+    /** \brief Pointer to string */
+    char* m_ptr;
+
+    /** \brief Length of the string */
+    int m_lg;
+
+    /** \brief Keeps the string corresponding to keyword ID */
+    static const std::map<EID, char *> s_keywordString;
+
+    /**
+     * \brief MapIdToString maps given ID to its string equivalent
+     * \param id Provided identifier
+     * \return string if found, else NullString
+     */
+    static const char * MapIdToString(EID id);
+};
+
+
+// Class used to array management
+
+class CBotStringArray : public CBotString
+{
+private:
+    int                m_nSize;                    // number of elements
+    int                m_nMaxSize;                    // reserved size
+    CBotString*        m_pData;                    // ^data
+
+public:
+                    CBotStringArray();
+                    ~CBotStringArray();
+    void            SetSize(int nb);
+    int             GivSize();
+    void            Add(const CBotString& str);
+    CBotString&        operator[](int nIndex);
+
+    CBotString&        ElementAt(int nIndex);
+};
+
+// different modes for GetPosition
+enum CBotGet
+{
+    GetPosExtern    = 1,
+    GetPosNom        = 2,
+    GetPosParam        = 3,
+    GetPosBloc        = 4
+};
+
+////////////////////////////////////////////////////////////////////
+// main class managing CBot program
+//
+
+class CBotProgram
+{
+private:
+    CBotFunction*    m_Prog;            // the user-defined functions
+    CBotFunction*    m_pRun;            // the basic function for the execution
+    CBotClass*        m_pClass;        // classes defined in this part
+    CBotStack*        m_pStack;        // execution stack
+    CBotVar*        m_pInstance;    // instance of the parent class
+    friend class    CBotFunction;
+
+    int                m_ErrorCode;
+    int                m_ErrorStart;
+    int                m_ErrorEnd;
+
+    long            m_Ident;        // associated identifier
+
+public:
+    static CBotString        m_DebugVarStr;    // end of a debug
+    bool m_bDebugDD;        // idem déclanchable par robot \TODO ???
+    bool m_bCompileClass;
+
+public:
+    static void Init();
+    //                initializes the module (defined keywords for errors)
+    //                should be done once (and only one) at the beginning
+    static
+    void            Free();
+    //                frees the static memory areas
+
+    static
+    int                GivVersion();
+    //                gives the version of the library CBOT
+
+
+                    CBotProgram();
+                    CBotProgram(CBotVar* pInstance);
+                    ~CBotProgram();
+
+    bool            Compile( const char* program, CBotStringArray& ListFonctions, void* pUser = NULL);
+    //                compiles the program given in text
+    //                returns false if an error at compile
+    //                see GetCompileError () to retrieve the error
+    //                ListFonctions returns the names of functions declared as extern
+    //                pUser can pass a pointer to routines defined by AddFunction
+
+    void            SetIdent(long n);
+    //                associates an identifier with the instance CBotProgram
+
+    long            GivIdent();
+    //                gives the identifier
+
+    int                GivError();
+    bool            GetError(int& code, int& start, int& end);
+    bool            GetError(int& code, int& start, int& end, CBotProgram* &pProg);
+    //                if true
+    //                gives the error found in the compilation
+    //                or execution
+    //                delimits the start and end block where the error
+    //                pProg lets you know what "module" has produced runtime error
+    static         CBotString        GivErrorText(int code);
+
+
+    bool            Start(const char* name);
+    //                defines what function should be executed
+    //                returns false if the funtion name is not found
+    //                the program does nothing, we must call Run () for this
+
+    bool            Run(void* pUser = NULL, int timer = -1);
+    //                executes the program
+    //                returns false if the program was suspended
+    //                returns true if the program ended with or without error
+    //                timer = 0 allows to advance step by step
+
+    bool            GetRunPos(const char* &FunctionName, int &start, int &end);
+    //                gives the position in the executing program
+    //                returns false if it is not running (program completion)
+    //                FunctionName is a pointer made to the name of the function
+    //                start and end position in the text of the token processing
+
+    CBotVar*        GivStackVars(const char* &FunctionName, int level);
+    //                provides the pointer to the variables on the execution stack
+    //                level is an input parameter,  0 for the last level, -1, -2, etc. for the other levels
+    //                the return value (CBotVar *) is a variable list (or NULL)
+    //                    that can be processed as the list of parameters received by a routine
+    //                FunctionName gives the name of the function where are these variables
+    //                FunctionName == NULL means that is more in a program (depending on  level)
+
+    void            Stop();
+    //                stops execution of the program
+    //                therefore quits "suspend" mode
+
+    static
+    void            SetTimer(int n);
+    //                defines the number of steps (parts of instructions) to done  
+    //                in Run() before rendering hand "false" \TODO avant de rendre la main "false"
+
+    static
+    bool            AddFunction(const char* name, 
+                                bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                                CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
+    //                call this to add externally (**)
+    //                a new function used by the program CBoT
+
+    static
+    bool            DefineNum(const char* name, long val);
+
+    bool            SaveState(FILE* pf);
+    //                backup the execution status in the file
+    //                the file must have been opened with the fopen call this dll (\TODO this library??)
+    //                if the system crashes
+    bool            RestoreState(FILE* pf);
+    //                restores the state of execution from file
+    //                the compiled program must obviously be the same
+
+    bool            GetPosition(const char* name, int& start, int& stop, 
+                                CBotGet modestart = GetPosExtern, 
+                                CBotGet modestop  = GetPosBloc);
+    //                gives the position of a routine in the original text
+    //                the user can select the item to find from the beginning to the end
+    //                see the above modes in CBotGet
+
+
+    CBotFunction*    GivFunctions();
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// routines for file management  (* FILE)
+    FILE*        fOpen(const char* name, const char* mode);
+    int            fClose(FILE* filehandle);
+    size_t        fWrite(const void *buffer, size_t elemsize, size_t length, FILE* filehandle);
+    size_t        fRead(void *buffer, size_t elemsize, size_t length, FILE* filehandle);
+
+
+#if 0
+/*
+(**) Note:
+     To define an external function, proceed as follows:
+
+    a) define a routine for compilation
+        this routine receive list of parameters (no values)
+        and either returns a result type (CBotTyp... or 0 = void)
+        or an error number
+    b) define a routine for the execution
+        this routine receive list of parameters (with valeurs),
+        a variable to store the result (according to the given type at compile time)
+
+    For example, a routine which calculates the mean of a parameter list */
+
+int    cMean(CBotVar* &pVar, CBotString& ClassName)
+{
+    if ( pVar == NULL ) return 6001;    // there is no parameter!
+
+    while ( pVar != NULL )
+    {
+        if ( pVar->GivType() > CBotTypDouble ) return 6002;        // this is not a number 
+        pVar = pVar -> GivNext();
+    }
+
+    return CBotTypFloat;        // the type of the result may depend on the parameters!
+}
+
+
+bool rMean(CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    float total = 0;
+    int   nb      = 0;
+    while (pVar != NULL)
+    {
+        total += pVar->GivValFloat();
+        pVar = pVar->GivNext();
+        nb++;
+    }
+    pResult->SetValFloat(total/nb);                // returns the mean value
+
+    return true;                                // operation fully completed
+}
+
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////
+// Class for managing variables
+
+// may be useful to the outside of the module
+// ( it is currently not expected to be able to create these objects in outer )
+
+// results of GivInit()
+#define    IS_UNDEF    0        // undefined variable
+#define IS_DEF        1        // variable defined
+#define    IS_NAN        999        // variable defined as not a number
+
+// variable type SetPrivate / IsPrivate
+#define PR_PUBLIC    0        // public variable
+#define    PR_READ        1        // read only
+#define PR_PROTECT    2        // protected (inheritance)
+#define PR_PRIVATE    3        // strictly private
+
+class CBotVar
+{
+protected:
+    CBotToken*        m_token;                    // the corresponding token
+
+    CBotVar*        m_next;                        // list of variables
+    friend class    CBotStack;
+    friend class    CBotCStack;
+    friend class    CBotInstrCall;
+    friend class    CBotProgram;
+
+    CBotTypResult    m_type;                        // type of value
+
+    int                m_binit;                    // not initialized?
+    CBotVarClass*    m_pMyThis;                    // ^ corresponding this element
+    void*            m_pUserPtr;                    // ^user data if necessary
+    bool            m_bStatic;                    // static element (in class)
+    int                m_mPrivate;                    // element public, protected or private?
+
+    CBotInstr*        m_InitExpr;                    // expression for the original content
+    CBotInstr*        m_LimExpr;                    // list of limits for a table
+    friend class    CBotClass;
+    friend class    CBotVarClass;
+    friend class    CBotVarPointer;
+    friend class    CBotVarArray;
+
+    long            m_ident;                    // unique identifier
+    static long        m_identcpt;                    // counter
+
+public:
+                    CBotVar();
+virtual                ~CBotVar( );                        // destructor
+
+    static
+    CBotVar*        Create( const char* name, CBotTypResult type);
+    //                creates from a complete type
+
+    static
+    CBotVar*        Create( const char* name, CBotClass* pClass);
+    //                creates from one instance of a known class
+
+    static
+    CBotVar*        Create( const CBotToken* name, int type );
+    static
+    CBotVar*        Create( const CBotToken* name, CBotTypResult type );
+
+    static
+    CBotVar*        Create( const char* name, int type, CBotClass* pClass);
+
+    static
+    CBotVar*        Create( CBotVar* pVar );
+
+
+    void            SetUserPtr(void* pUser);
+    //                associate a user pointer to an instance
+
+    virtual void    SetIdent(long UniqId);
+    //                associates a unique identifier to an instance
+    //                ( it is used to ensure that the id is unique)
+
+    void*            GivUserPtr();
+    //                makes the pointer associated with the variable
+
+    CBotString        GivName();                    // the name of the variable, if known
+    ////////////////////////////////////////////////////////////////////////////////////
+    void            SetName(const char* name);    // changes the name of the variable
+
+    int                GivType(int mode = 0);          // returns the base type (int) of the variable
+                                                        // TODO check it    
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    CBotTypResult    GivTypResult(int mode = 0);    // returns the complete type of the variable
+
+
+    CBotToken*        GivToken();
+    void            SetType(CBotTypResult& type);
+
+    void            SetInit(int bInit);            // is the variable in the state IS_UNDEF, IS_DEF, IS_NAN
+
+    int                GivInit();                    // gives the state of the variable
+
+    void            SetStatic(bool bStatic);
+    bool            IsStatic();
+
+    void            SetPrivate(int mPrivate);
+    bool            IsPrivate(int mode = PR_PROTECT);
+    int                GivPrivate();
+
+    virtual
+    void            ConstructorSet();
+
+    void            SetVal(CBotVar* var);          // remprend une valeur
+                                                    // TODO remprend value
+    virtual
+    CBotVar*        GivItem(const char* name);    // returns an element of a class according to its name (*)
+    virtual
+    CBotVar*        GivItemRef(int nIdent);        // idem à partir du n° ref
+                                                    // TODO ditto from ref no.
+    virtual
+    CBotVar*        GivItem(int row, bool bGrow = false); 
+
+    virtual
+    CBotVar*        GivItemList();                // lists the elements
+
+    CBotVar*        GivStaticVar();                // makes the pointer to the variable if it is static
+
+    bool            IsElemOfClass(const char* name);
+                                                // said if the element belongs to the class "name"
+                                                // makes true if the object is a subclass
+
+    CBotVar*        GivNext();                    // next variable in the list (parameters)
+    ////////////////////////////////////////////////////////////////////////////////////////////
+
+    void            AddNext(CBotVar* pVar);        // added to a list
+
+    virtual
+    void            Copy(CBotVar* pSrc, bool bName = true);    // makes a copy of the variable
+
+    virtual void    SetValInt(int val, const char* name = NULL);
+                                                // initialized with an integer value (#)
+    /////////////////////////////////////////////////////////////////////////////////
+
+    virtual void    SetValFloat(float val);        // initialized with a real value (#)
+    ////////////////////////////////////////////////////////////////////////////////
+
+    virtual void    SetValString(const char* p);// initialized with a string value (#)
+    ////////////////////////////////////////////////////////////////////////////////
+
+    virtual int        GivValInt();                // request the full value (#)
+    ////////////////////////////////////////////////////////////////////////
+
+    virtual float    GivValFloat();                // gets real value (#)
+    ///////////////////////////////////////////////////////////////////////
+
+    virtual
+    CBotString         GivValString();                // request the string value (#)
+    ///////////////////////////////////////////////////////////////////////
+
+    virtual void    SetClass(CBotClass* pClass);
+    virtual
+    CBotClass*        GivClass();
+
+    virtual void    SetPointer(CBotVar* p);
+    virtual
+    CBotVarClass*    GivPointer();
+//    virtual void    SetIndirection(CBotVar* pVar);
+
+    virtual void    Add(CBotVar* left, CBotVar* right);    // addition
+    virtual void    Sub(CBotVar* left, CBotVar* right);    // subtraction
+    virtual void    Mul(CBotVar* left, CBotVar* right);    // multiplication
+    virtual int     Div(CBotVar* left, CBotVar* right);    // division
+    virtual int     Modulo(CBotVar* left, CBotVar* right);    // remainder of division
+    virtual void    Power(CBotVar* left, CBotVar* right);    // power
+
+    virtual bool    Lo(CBotVar* left, CBotVar* right);
+    virtual bool    Hi(CBotVar* left, CBotVar* right);
+    virtual bool    Ls(CBotVar* left, CBotVar* right);
+    virtual bool    Hs(CBotVar* left, CBotVar* right);
+    virtual bool    Eq(CBotVar* left, CBotVar* right);
+    virtual bool    Ne(CBotVar* left, CBotVar* right);
+
+    virtual void    And(CBotVar* left, CBotVar* right);
+    virtual void    Or(CBotVar* left, CBotVar* right);
+    virtual void    XOr(CBotVar* left, CBotVar* right);
+    virtual void    ASR(CBotVar* left, CBotVar* right);
+    virtual void    SR(CBotVar* left, CBotVar* right);
+    virtual void    SL(CBotVar* left, CBotVar* right);
+
+    virtual void    Neg();
+    virtual void    Not();
+    virtual void    Inc();
+    virtual void    Dec();
+
+
+    virtual bool    Save0State(FILE* pf);
+    virtual bool    Save1State(FILE* pf);
+    static    bool    RestoreState(FILE* pf, CBotVar* &pVar);
+
+    void            debug();
+
+//    virtual
+//    CBotVar*        GivMyThis();
+
+    virtual
+    void            Maj(void* pUser = NULL, bool bContinue = true);
+
+    void            SetUniqNum(long n);
+    long            GivUniqNum();
+    static long        NextUniqNum();
+};
+
+/* NOTE (#)
+    methods    SetValInt() SetValFloat() et SetValString()
+    can be called  with objects which are respectively integer, real or string
+    Always be sure of the type of the variable before calling these methods
+
+    if ( pVar->GivType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!
+
+    methods    GivValInt(), GivValFloat() et GivValString()
+    use value conversions,
+    GivValString() works on numbers (makes the corresponding string)
+    but do not make GivValInt () with a string variable!
+*/
+
+
+
+////////////////////////////////////////////////////////////////////////
+// management of classes
+////////////////////////////////////////////////////////////////////////
+
+// class to define new classes in the language CBOT
+// for example to define the class CPoint (x, y)
+
+class CBotClass
+{
+private:
+    static
+    CBotClass*        m_ExClass;        // list of classes existing at a given time
+    CBotClass*        m_ExNext;        // for this general list
+    CBotClass*        m_ExPrev;        // for this general list
+
+private:
+    CBotClass*        m_pParent;        // parent class
+    CBotString        m_name;            // name of this class
+    int                m_nbVar;        // number of variables in the chain
+    CBotVar*        m_pVar;            // content of the class
+    bool            m_bIntrinsic;    // intrinsic class
+    CBotClass*        m_next;            // the string class
+    CBotCallMethode* m_pCalls;        // list of methods defined in external
+    CBotFunction*    m_pMethod;        // compiled list of methods
+    void            (*m_rMaj) ( CBotVar* pThis, void* pUser );
+    friend class    CBotVarClass;
+    int                m_cptLock;        // for Lock / UnLock
+    int                m_cptOne;        // Lock for reentrancy
+    CBotProgram*    m_ProgInLock[5];// processes waiting for sync
+
+public:
+    bool            m_IsDef;        //  mark if is set or not
+
+                    CBotClass( const char* name,
+                               CBotClass* pParent, bool bIntrinsic = false );        // constructor
+    //                Once a class is created, it is known
+    //                around CBoT
+    //                intrinsic mode gives a class that is not managed by pointers
+
+                    ~CBotClass( );                            // destructor
+
+    bool            AddFunction(const char* name, 
+                                bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 
+                                CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
+    //                this call allows to add as external (**)
+    //                new method used by the objects of this class
+
+    bool            AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) );
+    //                defines routine to be called to update the elements of the class
+
+    bool            AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC);
+    //                adds an element to the class
+//    bool            AddItem(CBotString name, CBotClass* pClass);
+    //                the same for elements belonging to pClass
+    bool            AddItem(CBotVar* pVar);
+    //                adds an item by passing the pointer to an instance of a variable
+    //                the object is taken as is, so do not destroyed
+
+
+
+    // adds an element by giving an element of type CBotVar
+    void            AddNext(CBotClass* pClass);
+
+    CBotString        GivName();                    // gives the name of the class
+    CBotClass*        GivParent();                // gives the parent class (or NULL)
+
+    // true if a class is derived (Extends) of another
+    // return true also if the classes are identical
+    bool            IsChildOf(CBotClass* pClass);
+
+    static
+    CBotClass*        Find(CBotToken* &pToken);    // trouve une classe d'après son nom
+                                                    // return a class by it's its name
+    static
+    CBotClass*        Find(const char* name);
+
+    CBotVar*        GivVar();                    // return the list of variables
+    CBotVar*        GivItem(const char* name);    // one of the variables according to its name
+    CBotVar*        GivItemRef(int nIdent);
+
+    CBotTypResult    CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams, 
+                                   CBotCStack* pStack, long& nIdent);
+
+    bool            ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken);
+    void            RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack);
+
+    // compiles a class declared by the user
+    static
+    CBotClass*        Compile(CBotToken* &p, CBotCStack* pStack);
+    static
+    CBotClass*        Compile1(CBotToken* &p, CBotCStack* pStack);
+
+    bool            CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond);
+    
+    bool            IsIntrinsic();
+    void            Purge();
+    static
+    void            Free();
+
+    static
+    bool            SaveStaticState(FILE* pf);
+
+    static
+    bool            RestoreStaticState(FILE* pf);
+
+    bool            Lock(CBotProgram* p);
+    void            Unlock();
+    static
+    void            FreeLock(CBotProgram* p);
+
+    bool            CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
+
+};
+
+#define    MAXDEFNUM            1000                // limited number of DefineNum
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Token management (tokens)
+
+#define TokenTypKeyWord        1                    // a keyword of the language (see TokenKeyWord)
+#define TokenTypNum            2                    // number
+#define TokenTypString         3                    // string
+#define TokenTypVar            4                    // a variable name
+#define TokenTypDef            5                    // value according DefineNum
+
+#define TokenKeyWord        2000                // keywords of the language
+#define TokenKeyDeclare        2100                // keywords of declarations (int, float,..)
+#define TokenKeyVal            2200                // keywords representing the value (true, false, null, nan)
+#define TokenKeyOp            2300                // operators
+
+/** \class Responsible for token management */
+class CBotToken
+{
+private:
+    static
+    CBotStringArray    m_ListKeyWords;                // list of keywords of language
+    static
+    int                m_ListIdKeyWords[200];        // the corresponding codes
+
+    static
+    CBotStringArray    m_ListKeyDefine;            // names defined by a DefineNum
+    static
+    long            m_ListKeyNums[MAXDEFNUM];    // the ​​associated values
+
+private:
+    CBotToken*        m_next;                        // following in the list
+    CBotToken*        m_prev;
+    int                m_type;                        // type of Token
+    long            m_IdKeyWord;                // number of the keyword if it is a
+                                                // or value of the "define"
+
+    CBotString        m_Text;                        // word found as token
+    CBotString        m_Sep;                        //  following separators
+
+    int                m_start;                    // position in the original text (program)
+    int                m_end;                        // the same for the end of the token
+    
+    /**
+     * \brief Check whether given parameter is a keyword
+     */
+    static
+    int                GivKeyWords(const char* w);    // is it a keyword?
+    static
+    bool            GivKeyDefNum(const char* w, CBotToken* &token);
+
+    /**
+     * \brief Loads the list of keywords
+     */
+    static
+    void            LoadKeyWords();
+
+public:
+    /**
+     * \brief Constructors
+     */
+                    CBotToken();
+                    CBotToken(const CBotToken* pSrc);
+                    CBotToken(const CBotString& mot, const CBotString& sep, int start=0, int end=0);
+                    CBotToken(const char* mot, const char* sep = NULL);
+
+    /**
+     * \brief Destructor
+     */
+                    ~CBotToken();
+    /**
+     * \brief Returns the type of token
+     */
+    int                GivType();
+
+    /**
+     * \brief makes the string corresponding to this token
+     */
+    CBotString&        GivString();
+
+    /**
+     * \brief makes the following separator token
+     */
+    CBotString&        GivSep();
+
+    /**
+     * \brief position of the beginning in the text
+     */
+    int                GivStart();
+    /**
+     * \brief end position in the text
+     */
+    int                GivEnd();
+
+    /**
+     * \brief gives the next token in the list
+     */
+    CBotToken*        GivNext();
+    /**
+     * \brief gives the previous token in a list
+     */
+    CBotToken*        GivPrev();
+
+    /**
+     * \brief transforms the entire program 
+     */
+    static
+    CBotToken*        CompileTokens(const char* p, int& error);
+       
+    /**
+     * \brief releases the list
+     */
+    static
+    void            Delete(CBotToken* pToken);    // libère la liste
+
+
+    // fonctions non utiles en export
+    static
+    bool            DefineNum(const char* name, long val);
+    void            SetString(const char* name);
+
+    void            SetPos(int start, int end);
+    long            GivIdKey();
+    /**
+     * \brief adds a token (a copy)
+     */
+    void            AddNext(CBotToken* p);
+
+    /**
+     * finds the next token
+     */
+    static
+    CBotToken*        NextToken(char* &program, int& error, bool first = false);
+
+    const CBotToken&
+                    operator=(const CBotToken& src);
+
+    static
+    void            Free();
+};
+
+
+
+#if 0
+////////////////////////////////////////////////////////////////////////
+// Examples of use
+// Definition classes and functions
+
+
+// define the global class CPoint
+// --------------------------------
+    m_pClassPoint    = new CBotClass("CPoint", NULL);
+    // adds the component ".x"
+    m_pClassPoint->AddItem("x", CBotTypResult(CBotTypFloat));
+    // adds the component ".y"
+    m_pClassPoint->AddItem("y", CBotTypResult(CBotTypFloat));
+    // the player can then use the instructions
+    // CPoint position; position.x = 12; position.y = -13.6
+
+// define class CColobotObject
+// --------------------------------
+// This class manages all the objects in the world of COLOBOT
+// the  "main" user program belongs to this class
+    m_pClassObject    = new CBotClass("CColobotObject", m_pClassBase);
+    // adds the component ".position"
+    m_pClassObject->AddItem("position", m_pClassPoint);
+    // adds the component ".type"
+    m_pClassObject->AddItem("type", CBotTypResult(CBotTypShort));
+    // adds a definition of constant
+    m_pClassObject->AddConst("ROBOT", CBotTypShort, 1);            // ROBOT equivalent to the value 1
+    // adds the FIND routine
+    m_pClassObject->AddFunction( rCompFind, rDoFind );
+    // the player can now use the instructions
+    // CColobotObject chose; chose = FIND( ROBOT )
+
+
+
+// define class CColobotRobot derived from CColobotObject
+// ---------------------------------------------------------
+// programs "main" associated with robots as a part of this class
+    m_pClassRobot    = new CBotClass("CColobotRobot", m_pClassObject);
+    // add routine GOTO
+    m_pClassRobot->AddFunction( rCompGoto, rDoGoto );
+    // the player can now use
+    // GOTO( FIND ( ROBOT ) );
+
+
+// creates an instance of the class Robot
+// ------------------------------------
+// for example a new robot which has just been manufactured
+    CBotVar*    m_pMonRobot = new CBotVar("MonRobot", m_pClassRobot);
+
+// compiles the program by hand for this robot
+// ------------------------------------------
+    CString LeProgramme( "void main() {GOTO(0, 0); return 0;}" );
+    if ( !m_pMonRobot->Compile( LeProgramme ) ) {error handling ...};
+
+// build a stack for interpreter
+// --------------------------------------
+    CBotStack*    pStack = new CBotStack(NULL);
+
+// executes the main program
+// -------------------------
+    while( false = m_pMonRobot->Execute( "main", pStack ))
+    {
+        // program suspended
+        // could be pass a handle to another (safeguarding pstack for the robot one)
+    };
+    // programme "main" finished !
+
+
+
+
+// routine that implements the GOTO (CPoint pos)
+bool rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
+{
+    if (pVar->GivType() != CBotTypeClass ||
+        pVar->IsElemOfClas("CPoint") ) { exception = 6522; return false; )
+        // the parameter is not the right class?
+        // in fact the control is done to the routine of compilation
+
+    m_PosToGo.Copy( pVar );                // keeps the target position (object type CBotVar)
+
+    // or so
+    CBotVar*    temp;
+    temp = pVar->GivItem("x");            // is necessary for the object of type CPoint
+    ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
+    m_PosToGo.x = temp->GivValFloat();
+
+    temp = pVar->GivItem("y");            // is necessary for the object of type CPoint
+    ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
+    m_PosToGo.y = temp->GivValFloat();
+
+    return (m_CurentPos == m_PosToGo);    // makes true if the position is reached
+                                        // returns false if one had wait yet
+}
+
+#endif
+#endif //_CBOTDLL_H_
+
diff --git a/src/CBot/CBotFunction.cpp b/src/CBot/CBotFunction.cpp
index 488061c..1c94c1b 100644
--- a/src/CBot/CBotFunction.cpp
+++ b/src/CBot/CBotFunction.cpp
@@ -1,1648 +1,1647 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////

-// compilation des diverses fonctions déclarées par l'utilisateur

-//

-

-#include "CBot.h"

-

-// les divers constructeurs / destructeurs

-// pour libérer tout selon l'arbre établi

-CBotFunction::CBotFunction()

-{

-	m_Param		 = NULL;			// liste des paramètres vide

-	m_Block		 = NULL;			// le bloc d'instructions

-	m_next		 = NULL;			// les fonctions peuvent être chaînées

-	m_bPublic	 = FALSE;			// fonction non publique

-	m_bExtern	 = FALSE;			// fonction non externe

-	m_nextpublic = NULL;

-	m_prevpublic = NULL;

-	m_pProg		 = NULL;

-//	m_nThisIdent = 0;

-	m_nFuncIdent = 0;

-	m_bSynchro	  = FALSE;

-}

-

-CBotFunction* CBotFunction::m_listPublic = NULL;

-

-CBotFunction::~CBotFunction()

-{

-	delete	m_Param;				// liste des paramètres vide

-	delete	m_Block;				// le bloc d'instructions

-	delete	m_next;

-

-	// enlève de la liste publique s'il y a lieu

-	if ( m_bPublic )

-	{

-		if ( m_nextpublic != NULL )

-		{

-			m_nextpublic->m_prevpublic = m_prevpublic;

-		}

-		if ( m_prevpublic != NULL)

-		{

-			m_prevpublic->m_nextpublic = m_nextpublic;

-		}

-		else

-		{

-			// si prev = next = null peut ne pas être dans la liste !

-			if ( m_listPublic == this ) m_listPublic = m_nextpublic;

-		}

-	}

-}

-

-BOOL CBotFunction::IsPublic()

-{

-	return m_bPublic;

-}

-

-BOOL CBotFunction::IsExtern()

-{

-	return m_bExtern;

-}

-

-BOOL CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop)

-{

-	start = m_extern.GivStart();

-	stop = m_closeblk.GivEnd();

-

-	if (modestart == GetPosExtern)

-	{

-		start = m_extern.GivStart();

-	}

-	if (modestop == GetPosExtern)

-	{

-		stop = m_extern.GivEnd();

-	}

-	if (modestart == GetPosNom)

-	{

-		start = m_token.GivStart();

-	}

-	if (modestop == GetPosNom)

-	{

-		stop = m_token.GivEnd();

-	}

-	if (modestart == GetPosParam)

-	{

-		start = m_openpar.GivStart();

-	}

-	if (modestop == GetPosParam)

-	{

-		stop = m_closepar.GivEnd();

-	}

-	if (modestart == GetPosBloc)

-	{

-		start = m_openblk.GivStart();

-	}

-	if (modestop == GetPosBloc)

-	{

-		stop = m_closeblk.GivEnd();

-	}

-

-	return TRUE;

-}

-

-

-CBotTypResult	ArrayType(CBotToken* &p, CBotCStack* pile, CBotTypResult type)

-{

-	while ( IsOfType( p, ID_OPBRK ) )

-	{

-		if ( !IsOfType( p, ID_CLBRK ) )

-		{

-			pile->SetError(TX_CLBRK, p->GivStart());

-			return CBotTypResult( -1 );

-		}

-		type = CBotTypResult( CBotTypArrayPointer, type );

-	}

-	return type;

-}

-

-CBotTypResult	TypeParam(CBotToken* &p, CBotCStack* pile)

-{

-	CBotClass*	pClass = NULL;

-

-	switch (p->GivType())

-	{

-	case ID_INT:

-		p = p->GivNext();

-		return ArrayType(p, pile, CBotTypResult( CBotTypInt ));

-	case ID_FLOAT:

-		p = p->GivNext();

-		return ArrayType(p, pile, CBotTypResult( CBotTypFloat ));

-	case ID_BOOLEAN:

-	case ID_BOOL:

-		p = p->GivNext();

-		return ArrayType(p, pile, CBotTypResult( CBotTypBoolean ));

-	case ID_STRING:

-		p = p->GivNext();

-		return ArrayType(p, pile, CBotTypResult( CBotTypString ));

-	case ID_VOID:

-		p = p->GivNext();

-		return CBotTypResult( 0 );

-

-	case TokenTypVar:

-		pClass = CBotClass::Find(p);

-		if ( pClass != NULL)

-		{

-			p = p->GivNext();

-			return ArrayType(p, pile, 

-							 pClass->IsIntrinsic() ? 

-							 CBotTypResult( CBotTypIntrinsic, pClass ) : 

-							 CBotTypResult( CBotTypPointer,   pClass ) );

-		}

-	}

-	return CBotTypResult( -1 );

-}

-

-// compile une nouvelle fonction

-// bLocal permet de mettre la déclaration des paramètres au même niveau

-// que le éléments appartenant à la classe pour les méthodes

-CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, BOOL bLocal)

-{

-	CBotToken*		pp;

- 	CBotFunction* func = finput;

-	if ( func == NULL ) func = new CBotFunction();

-

-	CBotCStack*	pStk = pStack->TokenStack(p, bLocal);

-

-//	func->m_nFuncIdent = CBotVar::NextUniqNum();

-

-	while (TRUE)

-	{

-		if ( IsOfType(p, ID_PUBLIC) )

-		{

-			func->m_bPublic = TRUE;

-			continue;

-		}

-		pp = p;

-		if ( IsOfType(p, ID_EXTERN) )

-		{

-			func->m_extern = pp;		// pour la position du mot "extern"

-			func->m_bExtern = TRUE;

-//			func->m_bPublic = TRUE;		// donc aussi publique!

-			continue;

-		}

-		break;

-	}

-

-	func->m_retToken = *p;

-//	CBotClass*	pClass;

-	func->m_retTyp = TypeParam(p, pStk);		// type du résultat

-

-	if (func->m_retTyp.GivType() >= 0)

-	{

-		CBotToken*	pp = p;

-		func->m_token = *p;

-

-		if ( IsOfType(p, ID_NOT) )

-		{

-			CBotToken d("~" + p->GivString());

-			func->m_token = d;

-		}

-

-		// un nom de fonction est-il là ?

-		if (IsOfType(p, TokenTypVar))

-		{

-			if ( IsOfType( p, ID_DBLDOTS ) )		// méthode pour une classe

-			{

-				func->m_MasterClass = pp->GivString();

-				CBotClass* pClass = CBotClass::Find(pp);

-				if ( pClass == NULL ) goto bad;

-

-//				pp = p;

-				func->m_token = *p;

-				if (!IsOfType(p, TokenTypVar)) goto bad;

-

-			}

-			func->m_openpar = p;

-			func->m_Param = CBotDefParam::Compile( p, pStk );

-			func->m_closepar = p->GivPrev();

-			if (pStk->IsOk())

-			{

-				pStk->SetRetType(func->m_retTyp);	// pour savoir de quel type les return

-

-				if (!func->m_MasterClass.IsEmpty())

-				{

-					// rend "this" connu

-					CBotVar* pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, func->m_MasterClass ));

-					pThis->SetInit(2);

-//					pThis->SetUniqNum(func->m_nThisIdent = -2); //CBotVar::NextUniqNum() va pas

-					pThis->SetUniqNum(-2);

-					pStk->AddVar(pThis);

-

-					// initialise les variables selon This

-					// n'enregistre que le pointeur à la première, 

-					// le reste est chainé

-					CBotVar* pv = pThis->GivItemList();

-//					int num = 1;

-					while (pv != NULL)

-					{

-						CBotVar* pcopy = CBotVar::Create(pv);

-//						pcopy->SetInit(2);

-						pcopy->Copy(pv);

-						pcopy->SetPrivate(pv->GivPrivate());

-//						pcopy->SetUniqNum(pv->GivUniqNum()); //num++);

-						pStk->AddVar(pcopy);

-						pv = pv->GivNext();

-					}

-				}

-

-				// et compile le bloc d'instruction qui suit

-				func->m_openblk = p;

-				func->m_Block	= CBotBlock::Compile(p, pStk, FALSE);

-				func->m_closeblk = p->GivPrev();

-				if ( pStk->IsOk() )

-				{

-					if ( func->m_bPublic )	// fonction publique, la rend connue pour tous

-					{

-						CBotFunction::AddPublic(func);

-					}

-					return pStack->ReturnFunc(func, pStk);

-				}

-			}

-		}

-bad:

-		pStk->SetError(TX_NOFONC, p);

-	}

-	pStk->SetError(TX_NOTYP, p);

-	if ( finput == NULL ) delete func;

-	return pStack->ReturnFunc(NULL, pStk);

-}

-

-// pré-compile une nouvelle fonction

-CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass*	pClass)

-{

- 	CBotFunction* func = new CBotFunction();

-	func->m_nFuncIdent = CBotVar::NextUniqNum();

-	

-	CBotCStack*	pStk = pStack->TokenStack(p, TRUE);

-

-	while (TRUE)

-	{

-		if ( IsOfType(p, ID_PUBLIC) )

-		{

-		//	func->m_bPublic = TRUE;		// sera fait en passe 2

-			continue;

-		}

-		if ( IsOfType(p, ID_EXTERN) )

-		{

-			func->m_bExtern = TRUE;

-			continue;

-		}

-		break;

-	}

-

-	func->m_retToken = *p;

-	func->m_retTyp = TypeParam(p, pStack);		// type du résultat

-

-	if (func->m_retTyp.GivType() >= 0)

-	{

-		CBotToken*	pp = p;

-		func->m_token = *p;

-		// un nom de fonction est-il là ?

-		if (IsOfType(p, TokenTypVar))

-		{

-			if ( IsOfType( p, ID_DBLDOTS ) )		// méthode pour une classe

-			{

-				func->m_MasterClass = pp->GivString();

-				CBotClass* pClass = CBotClass::Find(pp);

-				if ( pClass == NULL )

-				{

-					pStk->SetError(TX_NOCLASS, pp);

-					goto bad;

-				}

-

-				pp = p;

-				func->m_token = *p;

-				if (!IsOfType(p, TokenTypVar)) goto bad;

-

-			}

-			func->m_Param = CBotDefParam::Compile( p, pStk );

-			if (pStk->IsOk())

-			{

-				// regarde si la fonction existe ailleurs

-				if (( pClass != NULL || !pStack->CheckCall(pp, func->m_Param)) &&

-					( pClass == NULL || !pClass->CheckCall(pp, func->m_Param)) )

-				{

-					if (IsOfType(p, ID_OPBLK))

-					{

-						int level = 1;

-						// et saute le bloc d'instructions qui suit

-						do

-						{

-							int type = p->GivType();

-							p = p->GivNext();

-							if (type == ID_OPBLK) level++;

-							if (type == ID_CLBLK) level--;

-						}

-						while (level > 0 && p != NULL);

-					

-						return pStack->ReturnFunc(func, pStk);

-					}

-					pStk->SetError(TX_OPENBLK, p);

-				}

-			}

-			pStk->SetError(TX_REDEF, pp);

-		}

-bad:

-		pStk->SetError(TX_NOFONC, p);

-	}

-	pStk->SetError(TX_NOTYP, p);

-	delete func;

-	return pStack->ReturnFunc(NULL, pStk);

-}

-

-#ifdef	_DEBUG

-static int xx = 0;

-#endif

-

-BOOL CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)

-{

-	CBotStack*	pile = pj->AddStack(this, 2);				// un bout de pile local à cette fonction

-//	if ( pile == EOX ) return TRUE;

-

-	pile->SetBotCall(m_pProg);								// bases pour les routines

-

-	if ( pile->GivState() == 0 )

-	{

-		if ( !m_Param->Execute(ppVars, pile) ) return FALSE;	// défini les paramètres

-		pile->IncState();

-	}

-

-	if ( pile->GivState() == 1 && !m_MasterClass.IsEmpty() )

-	{

-		// rend "this" connu

-		CBotVar* pThis ;

-		if ( pInstance == NULL )

-		{

-			pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, m_MasterClass ));

-			pThis->SetInit(2);

-		}

-		else

-		{

-			pThis = CBotVar::Create("this", CBotTypResult( CBotTypPointer, m_MasterClass ));

-			pThis->SetPointer(pInstance);

-			pThis->SetInit(2);

-		}

-

-//		pThis->SetUniqNum(m_nThisIdent);

-		pThis->SetUniqNum(-2);

-		pile->AddVar(pThis);

-

-		pile->IncState();

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	if ( !m_Block->Execute(pile) )

-	{

-		if ( pile->GivError() < 0 )

-			pile->SetError( 0 );

-		else

-			return FALSE;

-	}

-

-	return pj->Return(pile);

-}

-

-

-void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)

-{

-	CBotStack*	pile = pj->RestoreStack(this);			// un bout de pile local à cette fonction

-	if ( pile == NULL ) return;

-	CBotStack*	pile2 = pile;

-

-	pile->SetBotCall(m_pProg);							// bases pour les routines

-

-	if ( pile->GivBlock() < 2 )

-	{

-		CBotStack*	pile2 = pile->RestoreStack(NULL);		// un bout de pile local à cette fonction

-		if ( pile2 == NULL ) return;

-		pile->SetState(pile->GivState() + pile2->GivState());

-		pile2->Delete();

-	}

-

-	m_Param->RestoreState(pile2, TRUE);					// les paramètres

-

-	if ( !m_MasterClass.IsEmpty() )

-	{

-		CBotVar* pThis = pile->FindVar("this");

-		pThis->SetInit(2);

-		pThis->SetUniqNum(-2);

-	}

-

-	m_Block->RestoreState(pile2, TRUE);

-}

-

-void CBotFunction::AddNext(CBotFunction* p)

-{

-	CBotFunction*	pp = this;

-	while (pp->m_next != NULL) pp = pp->m_next;

-

-	pp->m_next = p;

-}

-

-

-CBotTypResult CBotFunction::CompileCall(const char* name, CBotVar** ppVars, long& nIdent)

-{

-	nIdent = 0;

-	CBotTypResult	type;

-

-	CBotFunction*	pt = FindLocalOrPublic(nIdent, name, ppVars, type);

-	return type;

-}

-

-

-// trouve une fonction selon son identificateur unique

-// si l'identificateur n'est pas trouvé, cherche selon le nom et les paramètres

-

-CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, BOOL bPublic)

-{

-	TypeOrError.SetType(TX_UNDEFCALL);		// pas de routine de ce nom

-	CBotFunction*	pt;

-

-	if ( nIdent )

-	{

-		if ( this != NULL ) for ( pt = this ; pt != NULL ; pt = pt->m_next )

-		{

-			if ( pt->m_nFuncIdent == nIdent )

-			{

-				TypeOrError = pt->m_retTyp;

-				return pt;

-			}

-		}

-

-		// recherche dans la liste des fonctions publiques

-

-		for ( pt = m_listPublic ; pt != NULL ; pt = pt->m_nextpublic )

-		{

-			if ( pt->m_nFuncIdent == nIdent )

-			{

-				TypeOrError = pt->m_retTyp;

-				return pt;

-			}

-		}

-	}

-

-	if ( name == NULL ) return NULL;

-

-	int		delta	= 99999;				// cherche la signature la plus faible

-	CBotFunction*	pFunc = NULL;			// la meilleure fonction trouvée

-

-	if ( this != NULL )

-	{

-		for ( pt = this ; pt != NULL ; pt = pt->m_next )

-		{

-			if ( pt->m_token.GivString() == name )

-			{

-				int	i = 0;

-				int	alpha = 0;							// signature des paramètres

-				// les paramètres sont-ils compatibles ?

-				CBotDefParam* pv = pt->m_Param;			// liste des paramètres attendus

-				CBotVar* pw = ppVars[i++];				// liste des paramètres fournis

-				while ( pv != NULL && pw != NULL)

-				{

-					if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))

-					{

-						if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;

-						break;

-					}

-					int d = pv->GivType() - pw->GivType(2);

-					alpha += d>0 ? d : -10*d;		// perte de qualité, 10 fois plus cher !!

-

-					pv = pv->GivNext();

-					pw = ppVars[i++];

-				}

-				if ( pw != NULL ) 

-				{

-					if ( pFunc != NULL ) continue;

-					if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);

-					if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);

-					continue;					// trop de paramètres

-				}

-				if ( pv != NULL )

-				{

-					if ( pFunc != NULL ) continue;

-					if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);

-					if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);

-					continue;					// pas assez de paramètres

-				}

-

-				if (alpha == 0)					// signature parfaite

-				{

-					nIdent = pt->m_nFuncIdent;

-					TypeOrError = pt->m_retTyp;

-					return pt;

-				}

-

-				if ( alpha < delta )			// une meilleur signature ?

-				{

-					pFunc = pt;

-					delta = alpha;

-				}

-			}

-		}

-	}

-

-	if ( bPublic )

-	{

-		for ( pt = m_listPublic ; pt != NULL ; pt = pt->m_nextpublic )

-		{

-			if ( pt->m_token.GivString() == name )

-			{

-				int	i = 0;

-				int	alpha = 0;							// signature des paramètres

-				// les paramètres sont-ils compatibles ?

-				CBotDefParam* pv = pt->m_Param;			// liste des paramètres attendus

-				CBotVar* pw = ppVars[i++];				// liste des paramètres fournis

-				while ( pv != NULL && pw != NULL)

-				{

-					if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))

-					{

-						if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;

-						break;

-					}

-					int d = pv->GivType() - pw->GivType(2);

-					alpha += d>0 ? d : -10*d;		// perte de qualité, 10 fois plus cher !!

-

-					pv = pv->GivNext();

-					pw = ppVars[i++];

-				}

-				if ( pw != NULL ) 

-				{

-					if ( pFunc != NULL ) continue;

-					if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);

-					if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);

-					continue;					// trop de paramètres

-				}

-				if ( pv != NULL )

-				{

-					if ( pFunc != NULL ) continue;

-					if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);

-					if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);

-					continue;					// pas assez de paramètres

-				}

-

-				if (alpha == 0)					// signature parfaite

-				{

-					nIdent = pt->m_nFuncIdent;

-					TypeOrError = pt->m_retTyp;

-					return pt;

-				}

-

-				if ( alpha < delta )			// une meilleur signature ?

-				{

-					pFunc = pt;

-					delta = alpha;

-				}

-			}

-		}

-	}

-

-	if ( pFunc != NULL )

-	{

-		nIdent = pFunc->m_nFuncIdent;

-		TypeOrError = pFunc->m_retTyp;

-		return pFunc;

-	}

-	return NULL;

-}

-

-

-// fait un appel à une fonction

-

-int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken)

-{

-	CBotTypResult	type;

-	CBotFunction*	pt = NULL;

-	

-	pt = FindLocalOrPublic(nIdent, name, ppVars, type);

-

-	if ( pt != NULL )

-	{

-		CBotStack*	pStk1 = pStack->AddStack(pt, 2);	// pour mettre "this"

-//		if ( pStk1 == EOX ) return TRUE;

-

-		pStk1->SetBotCall(pt->m_pProg);					// on a peut-être changé de module

-

-		if ( pStk1->IfStep() ) return FALSE;

-

-		CBotStack*	pStk3 = pStk1->AddStack(NULL, TRUE);	// paramètres

-

-		// prépare les paramètres sur la pile

-

-		if ( pStk1->GivState() == 0 )

-		{

-			if ( !pt->m_MasterClass.IsEmpty() )

-			{

-				CBotVar* pInstance = m_pProg->m_pInstance;

-				// rend "this" connu

-				CBotVar* pThis ;

-				if ( pInstance == NULL )

-				{

-					pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, pt->m_MasterClass ));

-					pThis->SetInit(2);

-				}

-				else

-				{

-					pThis = CBotVar::Create("this", CBotTypResult( CBotTypPointer, pt->m_MasterClass ));

-					pThis->SetPointer(pInstance);

-					pThis->SetInit(2);

-				}

-

-				pThis->SetUniqNum(-2);

-				pStk1->AddVar(pThis);

-

-			}

-

-			// initialise les variables selon paramètres

-			pt->m_Param->Execute(ppVars, pStk3);			// ne peut pas être interrompu

-

-			pStk1->IncState();

-		}

-

-		// finalement exécute la fonction trouvée

-

-		if ( !pStk3->GivRetVar(						// remet le résultat sur la pile

-			pt->m_Block->Execute(pStk3) ))			// GivRetVar dit si c'est interrompu

-		{

-			if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )

-			{

-#ifdef _DEBUG

-				if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return FALSE;

-#endif

-				pStk3->SetPosError(pToken);			// indique l'erreur sur l'appel de procédure

-			}

-			return FALSE;	// interrompu !

-		}

-

-		return pStack->Return( pStk3 );

-	}

-	return -1;

-}

-

-void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack)

-{

-	CBotTypResult	type;

-	CBotFunction*	pt = NULL;

-	CBotStack*		pStk1;

-	CBotStack*		pStk3;

-

-	// recherche la fonction pour remettre l'identificateur ok

-

-	pt = FindLocalOrPublic(nIdent, name, ppVars, type);

-

-	if ( pt != NULL )

-	{

-		pStk1 = pStack->RestoreStack(pt);

-		if ( pStk1 == NULL ) return;

-

-		pStk1->SetBotCall(pt->m_pProg);					// on a peut-être changé de module

-

-		if ( pStk1->GivBlock() < 2 )

-		{

-			CBotStack* pStk2 = pStk1->RestoreStack(NULL); // plus utilisé

-			if ( pStk2 == NULL ) return;

-			pStk3 = pStk2->RestoreStack(NULL);

-			if ( pStk3 == NULL ) return;

-		}

-		else

-		{

-			pStk3 = pStk1->RestoreStack(NULL);

-			if ( pStk3 == NULL ) return;

-		}

-

-		// prépare les paramètres sur la pile

-

-		{

-			if ( !pt->m_MasterClass.IsEmpty() )

-			{

-				CBotVar* pInstance = m_pProg->m_pInstance;

-				// rend "this" connu

-				CBotVar* pThis = pStk1->FindVar("this");

-				pThis->SetInit(2);

-				pThis->SetUniqNum(-2);

-			}

-		}

-

-		if ( pStk1->GivState() == 0 )

-		{

-			pt->m_Param->RestoreState(pStk3, TRUE);

-			return;

-		}

-

-		// initialise les variables selon paramètres

-		pt->m_Param->RestoreState(pStk3, FALSE);

-		pt->m_Block->RestoreState(pStk3, TRUE);

-	}

-}

-

-

-

-// fait un appel d'une méthode

-// note : this est déjà sur la pile, le pointeur pThis est juste là pour simplifier

-

-int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)

-{

-	CBotTypResult	type;

-	CBotProgram*	pProgCurrent = pStack->GivBotCall();

-

-	CBotFunction*	pt = FindLocalOrPublic(nIdent, name, ppVars, type, FALSE);

-

-	if ( pt != NULL )

-	{

-//		DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack);

-

-		CBotStack*	pStk = pStack->AddStack(pt, 2);

-//		if ( pStk == EOX ) return TRUE;

-

-		pStk->SetBotCall(pt->m_pProg);					// on a peut-être changé de module

-		CBotStack*	pStk3 = pStk->AddStack(NULL, TRUE); // pour mettre les paramètres passés

-

-		// prépare les paramètres sur la pile

-

-		if ( pStk->GivState() == 0 )

-		{

-			// met la variable "this" sur la pile

-			CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);

-			pthis->Copy(pThis, FALSE);

-			pthis->SetUniqNum(-2);		// valeur spéciale

-			pStk->AddVar(pthis);

-

-			CBotClass*	pClass = pThis->GivClass()->GivParent();

-			if ( pClass )

-			{

-				// met la variable "super" sur la pile

-				CBotVar* psuper = CBotVar::Create("super", CBotTypNullPointer);

-				psuper->Copy(pThis, FALSE);	// en fait identique à "this"

-				psuper->SetUniqNum(-3);		// valeur spéciale

-				pStk->AddVar(psuper);

-			}

-			// initialise les variables selon paramètres

-			pt->m_Param->Execute(ppVars, pStk3);			// ne peut pas être interrompu

-			pStk->IncState();

-		}

-

-		if ( pStk->GivState() == 1 )

-		{

-			if ( pt->m_bSynchro )

-			{

-				CBotProgram* pProgBase = pStk->GivBotCall(TRUE);

-				if ( !pClass->Lock(pProgBase) ) return FALSE;		// attend de pouvoir

-			}

-			pStk->IncState();

-		}

-		// finalement appelle la fonction trouvée

-

-		if ( !pStk3->GivRetVar(							// remet le résultat sur la pile

-			pt->m_Block->Execute(pStk3) ))			// GivRetVar dit si c'est interrompu

-		{

-			if ( !pStk3->IsOk() )

-			{

-				if ( pt->m_bSynchro )

-				{

-					pClass->Unlock();					// libère la fonction

-				}

-

-				if ( pt->m_pProg != pProgCurrent )

-				{

-					pStk3->SetPosError(pToken);			// indique l'erreur sur l'appel de procédure

-				}

-			}

-			return FALSE;	// interrompu !

-		}

-

-		if ( pt->m_bSynchro )

-		{

-			pClass->Unlock();							// libère la fonction

-		}

-

-		return pStack->Return( pStk3 );

-	}

-	return -1;

-}

-

-void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass)

-{

-	CBotTypResult	type;

-	CBotFunction*	pt = FindLocalOrPublic(nIdent, name, ppVars, type);

-

-	if ( pt != NULL )

-	{

-		CBotStack*	pStk = pStack->RestoreStack(pt);

-		if ( pStk == NULL ) return;

-		pStk->SetBotCall(pt->m_pProg);					// on a peut-être changé de module

-

-		CBotVar*	pthis = pStk->FindVar("this");

-		pthis->SetUniqNum(-2);

-

-		CBotStack*	pStk3 = pStk->RestoreStack(NULL);	// pour mettre les paramètres passés

-		if ( pStk3 == NULL ) return;

-

-		pt->m_Param->RestoreState(pStk3, TRUE);					// les paramètres

-

-		if ( pStk->GivState() > 1 &&						// vérouillage est effectif ?

-			 pt->m_bSynchro )

-			{

-				CBotProgram* pProgBase = pStk->GivBotCall(TRUE);

-				pClass->Lock(pProgBase);					// vérouille la classe

-			}

-

-		// finalement appelle la fonction trouvée

-

-		pt->m_Block->RestoreState(pStk3, TRUE);					// interrompu !

-	}

-}

-

-// regarde si la "signature" des paramètres est identique

-BOOL CBotFunction::CheckParam(CBotDefParam* pParam)

-{

-	CBotDefParam*	pp = m_Param;

-	while ( pp != NULL && pParam != NULL )

-	{

-		CBotTypResult type1 = pp->GivType();

-		CBotTypResult type2 = pParam->GivType();

-		if ( !type1.Compare(type2) ) return FALSE;

-		pp = pp->GivNext();

-		pParam = pParam->GivNext();

-	}

-	return ( pp == NULL && pParam == NULL );

-}

-

-CBotString CBotFunction::GivName()

-{

-	return	m_token.GivString();

-}

-

-CBotString CBotFunction::GivParams()

-{

-	if ( m_Param == NULL ) return CBotString("()");

-

-	CBotString		params = "( ";

-	CBotDefParam*	p = m_Param;		// liste des paramètres

-

-	while (p != NULL)

-	{

-		params += p->GivParamString();

-		p = p->GivNext();

-		if ( p != NULL ) params += ", ";

-	}

-

-	params += " )";

-	return params;

-}

-

-CBotFunction* CBotFunction::Next()

-{

-	return	m_next;

-}

-

-void CBotFunction::AddPublic(CBotFunction* func)

-{

-	if ( m_listPublic != NULL )

-	{

-		func->m_nextpublic = m_listPublic;

-		m_listPublic->m_prevpublic = func;

-	}

-	m_listPublic = func;

-}

-

-

-

-/////////////////////////////////////////////////////////////////////////

-// gestion des paramètres

-

-

-CBotDefParam::CBotDefParam()

-{

-	m_next	 = NULL;

-	m_nIdent = 0;

-}

-

-CBotDefParam::~CBotDefParam()

-{

-	delete	m_next;

-}

-

-

-// compile une liste de paramètres

-CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	// surtout pas de pStack->TokenStack ici

-	// les variables déclarées doivent rester visibles par la suite

-

-	pStack->SetStartError(p->GivStart());

-

-	if (IsOfType(p, ID_OPENPAR))

-	{

-		CBotDefParam* list = NULL;

-	

-		while (!IsOfType(p, ID_CLOSEPAR))

-		{

-		 	CBotDefParam* param = new CBotDefParam();

-			if (list == NULL) list = param;

-			else list->AddNext(param);			// ajoute à la liste

-

-			CBotClass*	pClass = NULL;//= CBotClass::Find(p);

-			param->m_typename = p->GivString();

-			CBotTypResult type = param->m_type = TypeParam(p, pStack);

-//			if ( type == CBotTypPointer ) type = CBotTypClass;			// il faut créer un nouvel objet

-

-			if (param->m_type.GivType() > 0)

-			{

-				CBotToken*	pp = p;

-				param->m_token = *p;

-				if (pStack->IsOk() && IsOfType(p, TokenTypVar) )

-				{

-

-					// variable déjà déclarée ?

-					if (pStack->CheckVarLocal(pp))

-					{

-						pStack->SetError(TX_REDEFVAR, pp);

-						break;

-					}

-

-					if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);

-					CBotVar*	var = CBotVar::Create(pp->GivString(), type);		// crée la variable 

-//					if ( pClass ) var->SetClass(pClass);

-					var->SetInit(2);									// la marque initialisée

-					param->m_nIdent = CBotVar::NextUniqNum();

-					var->SetUniqNum(param->m_nIdent);

-					pStack->AddVar(var);								// la place sur la pile

-

-					if (IsOfType(p, ID_COMMA) || p->GivType() == ID_CLOSEPAR)

-						continue;

-				}

-				pStack->SetError(TX_CLOSEPAR, p->GivStart());

-			}

-			pStack->SetError(TX_NOTYP, p);

-			delete list;

-			return NULL;

-		}

-		return list;

-	}

-	pStack->SetError(TX_OPENPAR, p->GivStart());

-	return NULL;

-}

-

-void CBotDefParam::AddNext(CBotDefParam* p)

-{

-	CBotDefParam*	pp = this;

-	while (pp->m_next != NULL) pp = pp->m_next;

-

-	pp->m_next = p;

-}

-

-

-BOOL CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)

-{

-	int				i = 0;

-	CBotDefParam*	p = this;

-

-	while ( p != NULL )

-	{

-		// crée une variable locale sur la pile

-		CBotVar*	newvar = CBotVar::Create(p->m_token.GivString(), p->m_type);

-

-		// procède ainsi pour faire la transformation des types :

-		if ( ppVars != NULL && ppVars[i] != NULL )

-		{

-			switch (p->m_type.GivType())

-			{

-			case CBotTypInt:

-				newvar->SetValInt(ppVars[i]->GivValInt());

-				break;

-			case CBotTypFloat:

-				newvar->SetValFloat(ppVars[i]->GivValFloat());

-				break;

-			case CBotTypString:

-				newvar->SetValString(ppVars[i]->GivValString());

-				break;

-			case CBotTypBoolean:

-				newvar->SetValInt(ppVars[i]->GivValInt());

-				break;

-			case CBotTypIntrinsic:

-				((CBotVarClass*)newvar)->Copy(ppVars[i], FALSE);

-				break;

-			case CBotTypPointer:

-			case CBotTypArrayPointer:

-				{

-					newvar->SetPointer(ppVars[i]->GivPointer());

-				}

-				break;

-			default:

-				ASM_TRAP();

-			}

-		}

-		newvar->SetUniqNum(p->m_nIdent);

-		pj->AddVar(newvar);		// place la variable

-		p = p->m_next;

-		i++;

-	}

-

-	return TRUE;

-}

-

-void CBotDefParam::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	int				i = 0;

-	CBotDefParam*	p = this;

-

-	while ( p != NULL )

-	{

-		// crée une variable locale sur la pile

-		CBotVar*	var = pj->FindVar(p->m_token.GivString());

-		var->SetUniqNum(p->m_nIdent);

-		p = p->m_next;

-	}

-}

-

-int CBotDefParam::GivType()

-{

-	return	m_type.GivType();

-}

-

-CBotTypResult CBotDefParam::GivTypResult()

-{

-	return	m_type;

-}

-

-CBotDefParam* CBotDefParam::GivNext()

-{

-	return	m_next;

-}

-

-CBotString CBotDefParam::GivParamString()

-{

-	CBotString	param;

-	

-	param = m_typename;

-	param += ' ';

-

-	param += m_token.GivString();

-	return param;

-}

-

-

-

-//////////////////////////////////////////////////////////////////////////

-// retour des paramètres 

-

-CBotReturn::CBotReturn()

-{

-	m_Instr	= NULL;

-	name = "CBotReturn";		// debug

-}

-

-CBotReturn::~CBotReturn()

-{

-	delete	m_Instr;

-}

-

-CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;

-

-	if (!IsOfType(p, ID_RETURN)) return NULL;	// ne devrait jamais arriver

-

-	CBotReturn*	inst = new CBotReturn();		// crée l'objet

-	inst->SetToken( pp );

-

-	CBotTypResult	type = pStack->GivRetType();

-

-	if ( type.GivType() == 0 )					// retourne void ?

-	{

-		if ( IsOfType( p, ID_SEP ) ) return inst;

-		pStack->SetError( TX_BADTYPE, pp );

-		return NULL;

-	}

-

-	inst->m_Instr = CBotExpression::Compile(p, pStack);

-	if ( pStack->IsOk() )

-	{

-		CBotTypResult	retType = pStack->GivTypResult(2);

-		if (TypeCompatible(retType, type, ID_ASS)) 

-		{

-			if ( IsOfType( p, ID_SEP ) )

-				return inst;

-

-			pStack->SetError(TX_ENDOF, p->GivStart());

-		}

-		pStack->SetError(TX_BADTYPE, p->GivStart());

-	}

-

-	delete inst;

-	return NULL;							// pas d'objet, l'erreur est sur la pile

-}

-

-BOOL CBotReturn::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState() == 0 )

-	{

-		if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return FALSE;	// évalue le résultat

-		// le résultat est sur la pile 

-		pile->IncState();

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	pile->SetBreak(3, CBotString());

-	return pj->Return(pile);

-}

-

-void CBotReturn::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-	CBotStack*	pile = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	if ( pile->GivState() == 0 )

-	{

-		if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain);	// évalue le résultat

-		return;

-	}

-}

-

-////////////////////////////////////////////////////////////////////////////////

-// Les appels à ces fonctions

-

-CBotInstrCall::CBotInstrCall()

-{

-	m_Parameters = NULL;

-	m_nFuncIdent = 0;

-	name = "CBotInstrCall";

-}

-

-CBotInstrCall::~CBotInstrCall()

-{

-	delete	m_Parameters;

-}

-

-CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotVar*	ppVars[1000];

-

-	int			i = 0;

-

-	CBotToken*	pp = p; 

-	p = p->GivNext();

-

-	pStack->SetStartError(p->GivStart());

-	CBotCStack* pile = pStack;

-

-	if ( IsOfType(p, ID_OPENPAR) )

-	{

-		int	start, end;

-		CBotInstrCall* inst = new CBotInstrCall();

-		inst->SetToken(pp);

-

-		// compile la liste des paramètres

-		if (!IsOfType(p, ID_CLOSEPAR)) while (TRUE)

-		{

-			start = p->GivStart();

-			pile = pile->TokenStack();						// garde les résultats sur la pile

-

-			CBotInstr*	param = CBotExpression::Compile(p, pile);

-			end	  = p->GivStart();

-			if ( inst->m_Parameters == NULL ) inst->m_Parameters = param;

-			else inst->m_Parameters->AddNext(param);			// construit la liste

-

-			if ( !pile->IsOk() )

-			{

-				delete inst;

-				return pStack->Return(NULL, pile);

-			}

-

-			if ( param != NULL )

-			{

-				if ( pile->GivTypResult().Eq(99) )

-				{

-					delete pStack->TokenStack();

-					pStack->SetError(TX_VOID, p->GivStart());

-					delete inst;

-					return NULL;

-				}

-				ppVars[i] = pile->GivVar();

-				ppVars[i]->GivToken()->SetPos(start, end);

-				i++;

-

-				if (IsOfType(p, ID_COMMA)) continue;			// saute la virgule

-				if (IsOfType(p, ID_CLOSEPAR)) break;

-			}

-

-			pStack->SetError(TX_CLOSEPAR, p->GivStart());

-			delete pStack->TokenStack();

-			delete inst;

-			return NULL;

-		}

-		ppVars[i] = NULL;

-

-		// la routine est-elle connue ?

-//		CBotClass*	pClass = NULL;

-		inst->m_typRes = pStack->CompileCall(pp, ppVars, inst->m_nFuncIdent);

-		if ( inst->m_typRes.GivType() >= 20 )

-		{

-//			if (pVar2!=NULL) pp = pVar2->RetToken();

-			pStack->SetError( inst->m_typRes.GivType(), pp );

-			delete pStack->TokenStack();

-			delete inst;

-			return NULL;

-		}

-

-		delete pStack->TokenStack();

-		if ( inst->m_typRes.GivType() > 0 )

-		{

-			CBotVar* pRes = CBotVar::Create("", inst->m_typRes);

-			pStack->SetVar(pRes);	// pour connaître le type du résultat

-		}

-		else pStack->SetVar(NULL);			// routine retourne void

-

-		return inst;

-	}

-	p = pp;

-	delete pStack->TokenStack();

-	return NULL;

-}

-

-BOOL CBotInstrCall::Execute(CBotStack* &pj)

-{

-	CBotVar*	ppVars[1000];

-	CBotStack*	pile  = pj->AddStack(this);

-	if ( pile->StackOver() ) return pj->Return( pile );

-

-	CBotStack*	pile1 = pile;

-

-	int		i = 0;

-

-	CBotInstr*	p = m_Parameters;

-	// évalue les paramètres

-	// et place les valeurs sur la pile

-	// pour pouvoir être interrompu n'importe quand

-	if ( p != NULL) while ( TRUE )

-	{

-		pile = pile->AddStack();						// de la place sur la pile pour les résultats

-		if ( pile->GivState() == 0 )

-		{

-			if (!p->Execute(pile)) return FALSE;		// interrompu ici ?

-			pile->SetState(1);							// marque spéciale pour reconnaîre les paramètres

-		}

-		ppVars[i++] = pile->GivVar();

-		p = p->GivNext();

-		if ( p == NULL) break;

-	}

-	ppVars[i] = NULL;

-

-	CBotStack* pile2 = pile->AddStack();

-	if ( pile2->IfStep() ) return FALSE;

-

-	if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return FALSE;	// interrompu

-

-	return pj->Return(pile2);	// libère toute la pile

-}

-

-void CBotInstrCall::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile  = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	CBotStack*	pile1 = pile;

-

-	int			i = 0;

-	CBotVar*	ppVars[1000];

-	CBotInstr*	p = m_Parameters;

-	// évalue les paramètres

-	// et place les valeurs sur la pile

-	// pour pouvoir être interrompu n'importe quand

-	if ( p != NULL) while ( TRUE )

-	{

-		pile = pile->RestoreStack();						// de la place sur la pile pour les résultats

-		if ( pile == NULL ) return;

-		if ( pile->GivState() == 0 )

-		{

-			p->RestoreState(pile, bMain);					// interrompu ici !

-			return;

-		}

-		ppVars[i++] = pile->GivVar();				// construit la liste des paramètres

-		p = p->GivNext();

-		if ( p == NULL) break;

-	}

-	ppVars[i] = NULL;

-

-	CBotStack* pile2 = pile->RestoreStack();

-	if ( pile2 == NULL ) return;

-

-	pile2->RestoreCall(m_nFuncIdent, GivToken(), ppVars);

-}

-

-//////////////////////////////////////////////////////////////////////////////

-// déclaration des classes par l'utilisateur

-

-// pré-compile une nouvelle class

-// l'analyse est complète à l'execption du corps des routines

-

-CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)

-{

-	if ( !IsOfType(p, ID_PUBLIC) )

-	{

-		pStack->SetError(TX_NOPUBLIC, p);

-		return NULL;

-	}

-	

-	if ( !IsOfType(p, ID_CLASS) ) return NULL;

-

-	CBotString name = p->GivString();

-

-	CBotClass* pOld = CBotClass::Find(name);

-	if ( pOld != NULL && pOld->m_IsDef )

-	{

-		pStack->SetError( TX_REDEFCLASS, p );

-		return NULL;

-	}

-

-	// un nom pour la classe est-il là ?

-	if (IsOfType(p, TokenTypVar))

-	{

-		CBotClass* pPapa = NULL;

-#if		EXTENDS

-		if ( IsOfType( p, ID_EXTENDS ) )

-		{

-			CBotString name = p->GivString();

-			pPapa = CBotClass::Find(name);

-

-			if (!IsOfType(p, TokenTypVar) || pPapa == NULL )

-			{

-				pStack->SetError( TX_NOCLASS, p );

-				return NULL;

-			}

-		}

-#endif

-		CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;

-		classe->Purge();							// vide les anciennes définitions

-		classe->m_IsDef = FALSE;					// définition en cours

-

-		if ( !IsOfType( p, ID_OPBLK) )

-		{

-			pStack->SetError(TX_OPENBLK, p);

-			return NULL;

-		}

-

-		while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )

-		{

-			classe->CompileDefItem(p, pStack, FALSE);

-		}

-

-		if (pStack->IsOk()) return classe;

-	}

-	pStack->SetError(TX_ENDOF, p);

-	return NULL;

-}

-

-BOOL CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, BOOL bSecond)

-{

-	BOOL	bStatic = FALSE;

-	int		mProtect = PR_PUBLIC;

-	BOOL	bSynchro = FALSE;

-

-	while (IsOfType(p, ID_SEP)) ;

-

-	CBotTypResult	type( -1 );

-

-	if ( IsOfType(p, ID_SYNCHO) ) bSynchro = TRUE;

-	CBotToken*		pBase = p;

-

-	if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE;

-	if ( IsOfType(p, ID_PUBLIC) ) mProtect = PR_PUBLIC;

-	if ( IsOfType(p, ID_PRIVATE) ) mProtect = PR_PRIVATE;

-	if ( IsOfType(p, ID_PROTECTED) ) mProtect = PR_PROTECT;

-	if ( IsOfType(p, ID_STATIC) ) bStatic = TRUE;

-

-//	CBotClass* pClass = NULL;

-	type = TypeParam(p, pStack);		// type du résultat

-

-	if ( type.Eq(-1) )

-	{

-		pStack->SetError(TX_NOTYP, p);

-		return FALSE;

-	}

-

-	while (pStack->IsOk()) 

-	{

-		CBotToken*	pp = p;

-		IsOfType(p, ID_NOT);	// saute le ~ éventuel (destructeur)

-

-		if (IsOfType(p, TokenTypVar))

-		{

-			CBotInstr* limites = NULL;

-			while ( IsOfType( p, ID_OPBRK ) )	// un tableau ?

-			{

-				CBotInstr* i = NULL;

-

-				if ( p->GivType() != ID_CLBRK )

-					i = CBotExpression::Compile( p, pStack );			// expression pour la valeur

-				else

-					i = new CBotEmpty();							// spécial si pas de formule

-

-				type = CBotTypResult(CBotTypArrayPointer, type);

-

-				if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) )

-				{

-					pStack->SetError(TX_CLBRK, p->GivStart());

-					return FALSE;

-				}

-

-/*				CBotVar* pv = pStack->GivVar();

-				if ( pv->GivType()>= CBotTypBoolean )

-				{

-					pStack->SetError(TX_BADTYPE, p->GivStart());

-					return FALSE;

-				}*/

-

-				if (limites == NULL) limites = i;

-				else limites->AddNext3(i);

-			}

-

-			if ( p->GivType() == ID_OPENPAR )

-			{

-				if ( !bSecond )

-				{

-					p = pBase;

-					CBotFunction* f = 

-					CBotFunction::Compile1(p, pStack, this);

-

-					if ( f == NULL ) return FALSE;

-

-					if (m_pMethod == NULL) m_pMethod = f;

-					else m_pMethod->AddNext(f);

-				}

-				else

-				{

-					// retrouve la méthode précompilée en passe 1

-					CBotFunction*	pf = m_pMethod;

-					CBotFunction*	prev = NULL;

-					while ( pf != NULL ) 

-					{

-						if (pf->GivName() == pp->GivString()) break;

-						prev = pf;

-						pf = pf->Next();

-					}

-

-					BOOL bConstructor = (pp->GivString() == GivName());

-					CBotCStack* pile = pStack->TokenStack(NULL, TRUE);

-

-					// rend "this" connu

-					CBotToken TokenThis(CBotString("this"), CBotString());

-					CBotVar* pThis = CBotVar::Create(&TokenThis, CBotTypResult( CBotTypClass, this ) );

-					pThis->SetUniqNum(-2);

-					pile->AddVar(pThis);

-

-					if ( m_pParent )

-					{

-						// rend "super" connu

-						CBotToken TokenSuper(CBotString("super"), CBotString());

-						CBotVar* pThis = CBotVar::Create(&TokenSuper, CBotTypResult( CBotTypClass, m_pParent ) );

-						pThis->SetUniqNum(-3);

-						pile->AddVar(pThis);

-					}

-

-//					int num = 1;

-					CBotClass*	my = this;

-					while (my != NULL)

-					{

-						// place une copie des varibles de la classe (this) sur la pile

-						CBotVar* pv = my->m_pVar;

-						while (pv != NULL)

-						{

-							CBotVar* pcopy = CBotVar::Create(pv);

-							pcopy->SetInit(!bConstructor || pv->IsStatic());

-							pcopy->SetUniqNum(pv->GivUniqNum());

-							pile->AddVar(pcopy);

-							pv = pv->GivNext();

-						}

-						my = my->m_pParent;

-					}

-

-					// compile une méthode

-					p = pBase;

-					CBotFunction* f = 

-					CBotFunction::Compile(p, pile, NULL/*, FALSE*/);

-

-					if ( f != NULL )

-					{

-						f->m_pProg = pStack->GivBotCall();

-						f->m_bSynchro = bSynchro;

-						// remplace l'élément dans la chaîne

-						f->m_next = pf->m_next;

-						pf->m_next = NULL;

-						delete pf;

-						if (prev == NULL) m_pMethod = f;

-						else prev->m_next = f;

-					}

-					pStack->Return(NULL, pile);

-				}

-

-				return pStack->IsOk();

-			}

-

-			// définition d'un élément

-			if (type.Eq(0))

-			{

-				pStack->SetError(TX_ENDOF, p);

-				return FALSE;

-			}

-

-			CBotInstr* i = NULL;

-			if ( IsOfType(p, ID_ASS ) )

-			{

-				if ( type.Eq(CBotTypArrayPointer) )

-				{

-					i = CBotListArray::Compile(p, pStack, type.GivTypElem());

-				}

-				else

-				{

-					// il y a une assignation à calculer

-					i = CBotTwoOpExpr::Compile(p, pStack);

-				}

-				if ( !pStack->IsOk() ) return FALSE;

-			}

-

-

-			if ( !bSecond )

-			{

-				CBotVar*	pv = CBotVar::Create(pp->GivString(), type);

-				pv -> SetStatic( bStatic );

-				pv -> SetPrivate( mProtect );

-

-				AddItem( pv );

-

-				pv->m_InitExpr = i;

-				pv->m_LimExpr = limites;

-

-

-				if ( pv->IsStatic() && pv->m_InitExpr != NULL )

-				{

-					CBotStack* pile = CBotStack::FirstStack();				// une pile indépendante

-					while(pile->IsOk() && !pv->m_InitExpr->Execute(pile));	// évalue l'expression sans timer

-					pv->SetVal( pile->GivVar() ) ;

-					pile->Delete();

-				}

-			}

-			else

-				delete i;

-

-			if ( IsOfType(p, ID_COMMA) ) continue;

-			if ( IsOfType(p, ID_SEP) ) break;

-		}

-		pStack->SetError(TX_ENDOF, p);

-	}

-	return pStack->IsOk();

-}

-

-

-CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	if ( !IsOfType(p, ID_PUBLIC) ) return NULL;

-	if ( !IsOfType(p, ID_CLASS) ) return NULL;

-

-	CBotString name = p->GivString();

-

-	// un nom pour la classe est-il là ?

-	if (IsOfType(p, TokenTypVar))

-	{

-		// la classe à été créée par Compile1

-		CBotClass* pOld = CBotClass::Find(name);

-

-#if		EXTENDS

-		if ( IsOfType( p, ID_EXTENDS ) )

-		{

-			IsOfType(p, TokenTypVar); // forcément

-		}

-#endif

-		IsOfType( p, ID_OPBLK);	// forcément

-

-		while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )

-		{

-			pOld->CompileDefItem(p, pStack, TRUE);

-		}

-

-		pOld->m_IsDef = TRUE;			// définition terminée

-		if (pStack->IsOk())	return pOld;

-	}

-	pStack->SetError(TX_ENDOF, p);

-	return NULL;

-}

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////////////////////////
+// compilation of various functions declared by the user
+//
+
+#include "CBot.h"
+
+// various constructors / destructors
+// \TODO translation:to liberate all according to esteblished tree
+// pour libérer tout selon l'arbre établi
+CBotFunction::CBotFunction()
+{
+    m_Param      = NULL;            // empty parameter list
+    m_Block      = NULL;            // the instruction block
+    m_next       = NULL;            // functions can be chained
+    m_bPublic    = false;           // function not public 
+    m_bExtern    = false;           // function not extern
+    m_nextpublic = NULL;
+    m_prevpublic = NULL;
+    m_pProg      = NULL;
+//  m_nThisIdent = 0;
+    m_nFuncIdent = 0;
+    m_bSynchro    = false;
+}
+
+CBotFunction* CBotFunction::m_listPublic = NULL;
+
+CBotFunction::~CBotFunction()
+{
+    delete  m_Param;                // empty parameter list
+    delete  m_Block;                // the instruction block
+    delete  m_next;
+
+    // remove public list if there is
+    if ( m_bPublic )
+    {
+        if ( m_nextpublic != NULL )
+        {
+            m_nextpublic->m_prevpublic = m_prevpublic;
+        }
+        if ( m_prevpublic != NULL)
+        {
+            m_prevpublic->m_nextpublic = m_nextpublic;
+        }
+        else
+        {
+            // if prev = next = null may not be in the list!
+            if ( m_listPublic == this ) m_listPublic = m_nextpublic;
+        }
+    }
+}
+
+bool CBotFunction::IsPublic()
+{
+    return m_bPublic;
+}
+
+bool CBotFunction::IsExtern()
+{
+    return m_bExtern;
+}
+
+bool CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop)
+{
+    start = m_extern.GivStart();
+    stop = m_closeblk.GivEnd();
+
+    if (modestart == GetPosExtern)
+    {
+        start = m_extern.GivStart();
+    }
+    if (modestop == GetPosExtern)
+    {
+        stop = m_extern.GivEnd();
+    }
+    if (modestart == GetPosNom)
+    {
+        start = m_token.GivStart();
+    }
+    if (modestop == GetPosNom)
+    {
+        stop = m_token.GivEnd();
+    }
+    if (modestart == GetPosParam)
+    {
+        start = m_openpar.GivStart();
+    }
+    if (modestop == GetPosParam)
+    {
+        stop = m_closepar.GivEnd();
+    }
+    if (modestart == GetPosBloc)
+    {
+        start = m_openblk.GivStart();
+    }
+    if (modestop == GetPosBloc)
+    {
+        stop = m_closeblk.GivEnd();
+    }
+
+    return true;
+}
+
+
+CBotTypResult   ArrayType(CBotToken* &p, CBotCStack* pile, CBotTypResult type)
+{
+    while ( IsOfType( p, ID_OPBRK ) )
+    {
+        if ( !IsOfType( p, ID_CLBRK ) )
+        {
+            pile->SetError(TX_CLBRK, p->GivStart());
+            return CBotTypResult( -1 );
+        }
+        type = CBotTypResult( CBotTypArrayPointer, type );
+    }
+    return type;
+}
+
+CBotTypResult   TypeParam(CBotToken* &p, CBotCStack* pile)
+{
+    CBotClass*  pClass = NULL;
+
+    switch (p->GivType())
+    {
+    case ID_INT:
+        p = p->GivNext();
+        return ArrayType(p, pile, CBotTypResult( CBotTypInt ));
+    case ID_FLOAT:
+        p = p->GivNext();
+        return ArrayType(p, pile, CBotTypResult( CBotTypFloat ));
+    case ID_BOOLEAN:
+    case ID_BOOL:
+        p = p->GivNext();
+        return ArrayType(p, pile, CBotTypResult( CBotTypBoolean ));
+    case ID_STRING:
+        p = p->GivNext();
+        return ArrayType(p, pile, CBotTypResult( CBotTypString ));
+    case ID_VOID:
+        p = p->GivNext();
+        return CBotTypResult( 0 );
+
+    case TokenTypVar:
+        pClass = CBotClass::Find(p);
+        if ( pClass != NULL)
+        {
+            p = p->GivNext();
+            return ArrayType(p, pile, 
+                             pClass->IsIntrinsic() ? 
+                             CBotTypResult( CBotTypIntrinsic, pClass ) : 
+                             CBotTypResult( CBotTypPointer,   pClass ) );
+        }
+    }
+    return CBotTypResult( -1 );
+}
+
+// compiles a new function
+// bLocal allows of the declaration of parameters on the same level
+// as the elements belonging to the class for methods
+CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* finput, bool bLocal)
+{
+    CBotToken*      pp;
+    CBotFunction* func = finput;
+    if ( func == NULL ) func = new CBotFunction();
+
+    CBotCStack* pStk = pStack->TokenStack(p, bLocal);
+
+//  func->m_nFuncIdent = CBotVar::NextUniqNum();
+
+    while (true)
+    {
+        if ( IsOfType(p, ID_PUBLIC) )
+        {
+            func->m_bPublic = true;
+            continue;
+        }
+        pp = p;
+        if ( IsOfType(p, ID_EXTERN) )
+        {
+            func->m_extern = pp;        // for the position of the word "extern"
+            func->m_bExtern = true;
+//          func->m_bPublic = true;     // therefore also public!
+            continue;
+        }
+        break;
+    }
+
+    func->m_retToken = *p;
+//  CBotClass*  pClass;
+    func->m_retTyp = TypeParam(p, pStk);        // type of the result
+
+    if (func->m_retTyp.GivType() >= 0)
+    {
+        CBotToken*  pp = p;
+        func->m_token = *p;
+
+        if ( IsOfType(p, ID_NOT) )
+        {
+            CBotToken d("~" + p->GivString());
+            func->m_token = d;
+        }
+
+        // un nom de fonction est-il là ?
+        if (IsOfType(p, TokenTypVar))
+        {
+            if ( IsOfType( p, ID_DBLDOTS ) )        // method for a class
+            {
+                func->m_MasterClass = pp->GivString();
+                CBotClass* pClass = CBotClass::Find(pp);
+                if ( pClass == NULL ) goto bad;
+
+//              pp = p;
+                func->m_token = *p;
+                if (!IsOfType(p, TokenTypVar)) goto bad;
+
+            }
+            func->m_openpar = p;
+            func->m_Param = CBotDefParam::Compile( p, pStk );
+            func->m_closepar = p->GivPrev();
+            if (pStk->IsOk())
+            {
+                pStk->SetRetType(func->m_retTyp);   // for knowledge what type returns
+
+                if (!func->m_MasterClass.IsEmpty())
+                {
+                    // return "this" known
+                    CBotVar* pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, func->m_MasterClass ));
+                    pThis->SetInit(2);
+//                  pThis->SetUniqNum(func->m_nThisIdent = -2); //CBotVar::NextUniqNum() will not
+                    pThis->SetUniqNum(-2);
+                    pStk->AddVar(pThis);
+
+                    // initialize variables acording to This
+                    // only saves the pointer to the first,
+                    // the rest is chained
+                    CBotVar* pv = pThis->GivItemList();
+//                  int num = 1;
+                    while (pv != NULL)
+                    {
+                        CBotVar* pcopy = CBotVar::Create(pv);
+//                      pcopy->SetInit(2);
+                        pcopy->Copy(pv);
+                        pcopy->SetPrivate(pv->GivPrivate());
+//                      pcopy->SetUniqNum(pv->GivUniqNum()); //num++);
+                        pStk->AddVar(pcopy);
+                        pv = pv->GivNext();
+                    }
+                }
+
+                // and compiles the following instruction block 
+                func->m_openblk = p;
+                func->m_Block   = CBotBlock::Compile(p, pStk, false);
+                func->m_closeblk = p->GivPrev();
+                if ( pStk->IsOk() )
+                {
+                    if ( func->m_bPublic )  // public function, return known for all
+                    {
+                        CBotFunction::AddPublic(func);
+                    }
+                    return pStack->ReturnFunc(func, pStk);
+                }
+            }
+        }
+bad:
+        pStk->SetError(TX_NOFONC, p);
+    }
+    pStk->SetError(TX_NOTYP, p);
+    if ( finput == NULL ) delete func;
+    return pStack->ReturnFunc(NULL, pStk);
+}
+
+// pre-compile a new function
+CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass*  pClass)
+{
+    CBotFunction* func = new CBotFunction();
+    func->m_nFuncIdent = CBotVar::NextUniqNum();
+    
+    CBotCStack* pStk = pStack->TokenStack(p, true);
+
+    while (true)
+    {
+        if ( IsOfType(p, ID_PUBLIC) )
+        {
+        //  func->m_bPublic = true;     // will be done in two passes
+            continue;
+        }
+        if ( IsOfType(p, ID_EXTERN) )
+        {
+            func->m_bExtern = true;
+            continue;
+        }
+        break;
+    }
+
+    func->m_retToken = *p;
+    func->m_retTyp = TypeParam(p, pStack);      // type of the result
+
+    if (func->m_retTyp.GivType() >= 0)
+    {
+        CBotToken*  pp = p;
+        func->m_token = *p;
+        // un nom de fonction est-il là ?
+        if (IsOfType(p, TokenTypVar))
+        {
+            if ( IsOfType( p, ID_DBLDOTS ) )        // method for a class
+            {
+                func->m_MasterClass = pp->GivString();
+                CBotClass* pClass = CBotClass::Find(pp);
+                if ( pClass == NULL )
+                {
+                    pStk->SetError(TX_NOCLASS, pp);
+                    goto bad;
+                }
+
+                pp = p;
+                func->m_token = *p;
+                if (!IsOfType(p, TokenTypVar)) goto bad;
+
+            }
+            func->m_Param = CBotDefParam::Compile( p, pStk );
+            if (pStk->IsOk())
+            {
+                // looks if the function exists elsewhere 
+                if (( pClass != NULL || !pStack->CheckCall(pp, func->m_Param)) &&
+                    ( pClass == NULL || !pClass->CheckCall(pp, func->m_Param)) )
+                {
+                    if (IsOfType(p, ID_OPBLK))
+                    {
+                        int level = 1;
+                        // and skips the following instruction block
+                        do
+                        {
+                            int type = p->GivType();
+                            p = p->GivNext();
+                            if (type == ID_OPBLK) level++;
+                            if (type == ID_CLBLK) level--;
+                        }
+                        while (level > 0 && p != NULL);
+                    
+                        return pStack->ReturnFunc(func, pStk);
+                    }
+                    pStk->SetError(TX_OPENBLK, p);
+                }
+            }
+            pStk->SetError(TX_REDEF, pp);
+        }
+bad:
+        pStk->SetError(TX_NOFONC, p);
+    }
+    pStk->SetError(TX_NOTYP, p);
+    delete func;
+    return pStack->ReturnFunc(NULL, pStk);
+}
+
+#ifdef  _DEBUG
+static int xx = 0;
+#endif
+
+bool CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
+{
+    CBotStack*  pile = pj->AddStack(this, 2);               // one end of stack local to this function
+//  if ( pile == EOX ) return true;
+
+    pile->SetBotCall(m_pProg);                              // bases for routines
+
+    if ( pile->GivState() == 0 )
+    {
+        if ( !m_Param->Execute(ppVars, pile) ) return false;    // define parameters
+        pile->IncState();
+    }
+
+    if ( pile->GivState() == 1 && !m_MasterClass.IsEmpty() )
+    {
+        // makes "this" known
+        CBotVar* pThis ;
+        if ( pInstance == NULL )
+        {
+            pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, m_MasterClass ));
+            pThis->SetInit(2);
+        }
+        else
+        {
+            pThis = CBotVar::Create("this", CBotTypResult( CBotTypPointer, m_MasterClass ));
+            pThis->SetPointer(pInstance);
+            pThis->SetInit(2);
+        }
+
+//      pThis->SetUniqNum(m_nThisIdent);
+        pThis->SetUniqNum(-2);
+        pile->AddVar(pThis);
+
+        pile->IncState();
+    }
+
+    if ( pile->IfStep() ) return false;
+
+    if ( !m_Block->Execute(pile) )
+    {
+        if ( pile->GivError() < 0 )
+            pile->SetError( 0 );
+        else
+            return false;
+    }
+
+    return pj->Return(pile);
+}
+
+
+void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
+{
+    CBotStack*  pile = pj->RestoreStack(this);          // one end of stack local to this function
+    if ( pile == NULL ) return;
+    CBotStack*  pile2 = pile;
+
+    pile->SetBotCall(m_pProg);                          // bases for routines
+
+    if ( pile->GivBlock() < 2 )
+    {
+        CBotStack*  pile2 = pile->RestoreStack(NULL);       // one end of stack local to this function
+        if ( pile2 == NULL ) return;
+        pile->SetState(pile->GivState() + pile2->GivState());
+        pile2->Delete();
+    }
+
+    m_Param->RestoreState(pile2, true);                 // parameters
+
+    if ( !m_MasterClass.IsEmpty() )
+    {
+        CBotVar* pThis = pile->FindVar("this");
+        pThis->SetInit(2);
+        pThis->SetUniqNum(-2);
+    }
+
+    m_Block->RestoreState(pile2, true);
+}
+
+void CBotFunction::AddNext(CBotFunction* p)
+{
+    CBotFunction*   pp = this;
+    while (pp->m_next != NULL) pp = pp->m_next;
+
+    pp->m_next = p;
+}
+
+
+CBotTypResult CBotFunction::CompileCall(const char* name, CBotVar** ppVars, long& nIdent)
+{
+    nIdent = 0;
+    CBotTypResult   type;
+
+    CBotFunction*   pt = FindLocalOrPublic(nIdent, name, ppVars, type);
+    return type;
+}
+
+
+// is a function according to its unique identifier
+// if the identifier is not found, looking by name and parameters
+
+CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, bool bPublic)
+{
+    TypeOrError.SetType(TX_UNDEFCALL);      // no routine of the name
+    CBotFunction*   pt;
+
+    if ( nIdent )
+    {
+        if ( this != NULL ) for ( pt = this ; pt != NULL ; pt = pt->m_next )
+        {
+            if ( pt->m_nFuncIdent == nIdent )
+            {
+                TypeOrError = pt->m_retTyp;
+                return pt;
+            }
+        }
+
+        // search the list of public functions
+
+        for ( pt = m_listPublic ; pt != NULL ; pt = pt->m_nextpublic )
+        {
+            if ( pt->m_nFuncIdent == nIdent )
+            {
+                TypeOrError = pt->m_retTyp;
+                return pt;
+            }
+        }
+    }
+
+    if ( name == NULL ) return NULL;
+
+    int     delta   = 99999;                // seeks the lowest signature
+    CBotFunction*   pFunc = NULL;           // the best function found
+
+    if ( this != NULL )
+    {
+        for ( pt = this ; pt != NULL ; pt = pt->m_next )
+        {
+            if ( pt->m_token.GivString() == name )
+            {
+                int i = 0;
+                int alpha = 0;                          // signature of parameters
+                // parameters are compatible?
+                CBotDefParam* pv = pt->m_Param;         // expected list of parameters
+                CBotVar* pw = ppVars[i++];              // provided list parameter
+                while ( pv != NULL && pw != NULL)
+                {
+                    if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
+                    {
+                        if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;
+                        break;
+                    }
+                    int d = pv->GivType() - pw->GivType(2);
+                    alpha += d>0 ? d : -10*d;       // quality loss, 10 times more expensive!
+
+                    pv = pv->GivNext();
+                    pw = ppVars[i++];
+                }
+                if ( pw != NULL ) 
+                {
+                    if ( pFunc != NULL ) continue;
+                    if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
+                    if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
+                    continue;                   // too many parameters
+                }
+                if ( pv != NULL )
+                {
+                    if ( pFunc != NULL ) continue;
+                    if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
+                    if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
+                    continue;                   // not enough parameters
+                }
+
+                if (alpha == 0)                 // perfect signature
+                {
+                    nIdent = pt->m_nFuncIdent;
+                    TypeOrError = pt->m_retTyp;
+                    return pt;
+                }
+
+                if ( alpha < delta )            // a better signature?
+                {
+                    pFunc = pt;
+                    delta = alpha;
+                }
+            }
+        }
+    }
+
+    if ( bPublic )
+    {
+        for ( pt = m_listPublic ; pt != NULL ; pt = pt->m_nextpublic )
+        {
+            if ( pt->m_token.GivString() == name )
+            {
+                int i = 0;
+                int alpha = 0;                          // signature of parameters
+                // parameters sont-ils compatibles ?
+                CBotDefParam* pv = pt->m_Param;         // list of expected parameters
+                CBotVar* pw = ppVars[i++];              // list of provided parameters
+                while ( pv != NULL && pw != NULL)
+                {
+                    if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
+                    {
+                        if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;
+                        break;
+                    }
+                    int d = pv->GivType() - pw->GivType(2);
+                    alpha += d>0 ? d : -10*d;       // quality loss, 10 times more expensive!
+
+                    pv = pv->GivNext();
+                    pw = ppVars[i++];
+                }
+                if ( pw != NULL ) 
+                {
+                    if ( pFunc != NULL ) continue;
+                    if ( TypeOrError.Eq(TX_LOWPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
+                    if ( TypeOrError.Eq(TX_UNDEFCALL)) TypeOrError.SetType(TX_OVERPARAM);
+                    continue;                   // to many parameters
+                }
+                if ( pv != NULL )
+                {
+                    if ( pFunc != NULL ) continue;
+                    if ( TypeOrError.Eq(TX_OVERPARAM) ) TypeOrError.SetType(TX_NUMPARAM);
+                    if ( TypeOrError.Eq(TX_UNDEFCALL) ) TypeOrError.SetType(TX_LOWPARAM);
+                    continue;                   // not enough parameters
+                }
+
+                if (alpha == 0)                 // perfect signature
+                {
+                    nIdent = pt->m_nFuncIdent;
+                    TypeOrError = pt->m_retTyp;
+                    return pt;
+                }
+
+                if ( alpha < delta )            // a better signature?
+                {
+                    pFunc = pt;
+                    delta = alpha;
+                }
+            }
+        }
+    }
+
+    if ( pFunc != NULL )
+    {
+        nIdent = pFunc->m_nFuncIdent;
+        TypeOrError = pFunc->m_retTyp;
+        return pFunc;
+    }
+    return NULL;
+}
+
+
+// fait un appel à une fonction
+
+int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken)
+{
+    CBotTypResult   type;
+    CBotFunction*   pt = NULL;
+    
+    pt = FindLocalOrPublic(nIdent, name, ppVars, type);
+
+    if ( pt != NULL )
+    {
+        CBotStack*  pStk1 = pStack->AddStack(pt, 2);    // to put "this"
+//      if ( pStk1 == EOX ) return true;
+
+        pStk1->SetBotCall(pt->m_pProg);                 // it may have changed module
+
+        if ( pStk1->IfStep() ) return false;
+
+        CBotStack*  pStk3 = pStk1->AddStack(NULL, true);    // parameters
+
+        // preparing parameters on the stack
+
+        if ( pStk1->GivState() == 0 )
+        {
+            if ( !pt->m_MasterClass.IsEmpty() )
+            {
+                CBotVar* pInstance = m_pProg->m_pInstance;
+                // make "this" known
+                CBotVar* pThis ;
+                if ( pInstance == NULL )
+                {
+                    pThis = CBotVar::Create("this", CBotTypResult( CBotTypClass, pt->m_MasterClass ));
+                    pThis->SetInit(2);
+                }
+                else
+                {
+                    pThis = CBotVar::Create("this", CBotTypResult( CBotTypPointer, pt->m_MasterClass ));
+                    pThis->SetPointer(pInstance);
+                    pThis->SetInit(2);
+                }
+
+                pThis->SetUniqNum(-2);
+                pStk1->AddVar(pThis);
+
+            }
+
+            // initializes the variables as parameters
+            pt->m_Param->Execute(ppVars, pStk3);            // cannot be interrupted
+
+            pStk1->IncState();
+        }
+
+        // finally execution of the found function
+
+        if ( !pStk3->GivRetVar(                     // puts the result on the stack
+            pt->m_Block->Execute(pStk3) ))          // GivRetVar said if it is interrupted
+        {
+            if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
+            {
+#ifdef _DEBUG
+                if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return false;
+#endif
+                pStk3->SetPosError(pToken);         // indicates the error on the procedure call
+            }
+            return false;   // interrupt !
+        }
+
+        return pStack->Return( pStk3 );
+    }
+    return -1;
+}
+
+void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack)
+{
+    CBotTypResult   type;
+    CBotFunction*   pt = NULL;
+    CBotStack*      pStk1;
+    CBotStack*      pStk3;
+
+    // search function to return the ok identifier
+
+    pt = FindLocalOrPublic(nIdent, name, ppVars, type);
+
+    if ( pt != NULL )
+    {
+        pStk1 = pStack->RestoreStack(pt);
+        if ( pStk1 == NULL ) return;
+
+        pStk1->SetBotCall(pt->m_pProg);                 // it may have changed module
+
+        if ( pStk1->GivBlock() < 2 )
+        {
+            CBotStack* pStk2 = pStk1->RestoreStack(NULL); // used more
+            if ( pStk2 == NULL ) return;
+            pStk3 = pStk2->RestoreStack(NULL);
+            if ( pStk3 == NULL ) return;
+        }
+        else
+        {
+            pStk3 = pStk1->RestoreStack(NULL);
+            if ( pStk3 == NULL ) return;
+        }
+
+        // preparing parameters on the stack
+
+        {
+            if ( !pt->m_MasterClass.IsEmpty() )
+            {
+                CBotVar* pInstance = m_pProg->m_pInstance;
+                // make "this" known
+                CBotVar* pThis = pStk1->FindVar("this");
+                pThis->SetInit(2);
+                pThis->SetUniqNum(-2);
+            }
+        }
+
+        if ( pStk1->GivState() == 0 )
+        {
+            pt->m_Param->RestoreState(pStk3, true);
+            return;
+        }
+
+        // initializes the variables as parameters
+        pt->m_Param->RestoreState(pStk3, false);
+        pt->m_Block->RestoreState(pStk3, true);
+    }
+}
+
+
+
+// makes call of a method 
+// note: this is already on the stack, the pointer pThis is just to simplify
+
+int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)
+{
+    CBotTypResult   type;
+    CBotProgram*    pProgCurrent = pStack->GivBotCall();
+
+    CBotFunction*   pt = FindLocalOrPublic(nIdent, name, ppVars, type, false);
+
+    if ( pt != NULL )
+    {
+//      DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack);
+
+        CBotStack*  pStk = pStack->AddStack(pt, 2);
+//      if ( pStk == EOX ) return true;
+
+        pStk->SetBotCall(pt->m_pProg);                  // it may have changed module
+        CBotStack*  pStk3 = pStk->AddStack(NULL, true); // to set parameters passed
+
+        // preparing parameters on the stack
+
+        if ( pStk->GivState() == 0 )
+        {
+            // sets the variable "this" on the stack
+            CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
+            pthis->Copy(pThis, false);
+            pthis->SetUniqNum(-2);      // special value
+            pStk->AddVar(pthis);
+
+            CBotClass*  pClass = pThis->GivClass()->GivParent();
+            if ( pClass )
+            {
+                // sets the variable "super" on the stack
+                CBotVar* psuper = CBotVar::Create("super", CBotTypNullPointer);
+                psuper->Copy(pThis, false); // in fact identical to "this"
+                psuper->SetUniqNum(-3);     // special value
+                pStk->AddVar(psuper);
+            }
+            // initializes the variables as parameters
+            pt->m_Param->Execute(ppVars, pStk3);            // cannot be interrupted
+            pStk->IncState();
+        }
+
+        if ( pStk->GivState() == 1 )
+        {
+            if ( pt->m_bSynchro )
+            {
+                CBotProgram* pProgBase = pStk->GivBotCall(true);
+                if ( !pClass->Lock(pProgBase) ) return false;       // expected to power \TODO attend de pouvoir
+            }
+            pStk->IncState();
+        }
+        // finally calls the found function
+
+        if ( !pStk3->GivRetVar(                         // puts the result on the stack
+            pt->m_Block->Execute(pStk3) ))          // GivRetVar said if it is interrupted
+        {
+            if ( !pStk3->IsOk() )
+            {
+                if ( pt->m_bSynchro )
+                {
+                    pClass->Unlock();                   // release function
+                }
+
+                if ( pt->m_pProg != pProgCurrent )
+                {
+                    pStk3->SetPosError(pToken);         // indicates the error on the procedure call
+                }
+            }
+            return false;   // interrupt !
+        }
+
+        if ( pt->m_bSynchro )
+        {
+            pClass->Unlock();                           // release function
+        }
+
+        return pStack->Return( pStk3 );
+    }
+    return -1;
+}
+
+void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass)
+{
+    CBotTypResult   type;
+    CBotFunction*   pt = FindLocalOrPublic(nIdent, name, ppVars, type);
+
+    if ( pt != NULL )
+    {
+        CBotStack*  pStk = pStack->RestoreStack(pt);
+        if ( pStk == NULL ) return;
+        pStk->SetBotCall(pt->m_pProg);                  // it may have changed module
+
+        CBotVar*    pthis = pStk->FindVar("this");
+        pthis->SetUniqNum(-2);
+
+        CBotStack*  pStk3 = pStk->RestoreStack(NULL);   // to set parameters passed
+        if ( pStk3 == NULL ) return;
+
+        pt->m_Param->RestoreState(pStk3, true);                 // parameters
+
+        if ( pStk->GivState() > 1 &&                        // latching is effective?
+             pt->m_bSynchro )
+            {
+                CBotProgram* pProgBase = pStk->GivBotCall(true);
+                pClass->Lock(pProgBase);                    // locks the class
+            }
+
+        // finally calls the found function
+
+        pt->m_Block->RestoreState(pStk3, true);                 // interrupt !
+    }
+}
+
+// see if the "signature" of parameters is identical
+bool CBotFunction::CheckParam(CBotDefParam* pParam)
+{
+    CBotDefParam*   pp = m_Param;
+    while ( pp != NULL && pParam != NULL )
+    {
+        CBotTypResult type1 = pp->GivType();
+        CBotTypResult type2 = pParam->GivType();
+        if ( !type1.Compare(type2) ) return false;
+        pp = pp->GivNext();
+        pParam = pParam->GivNext();
+    }
+    return ( pp == NULL && pParam == NULL );
+}
+
+CBotString CBotFunction::GivName()
+{
+    return  m_token.GivString();
+}
+
+CBotString CBotFunction::GivParams()
+{
+    if ( m_Param == NULL ) return CBotString("()");
+
+    CBotString      params = "( ";
+    CBotDefParam*   p = m_Param;        // list of parameters
+
+    while (p != NULL)
+    {
+        params += p->GivParamString();
+        p = p->GivNext();
+        if ( p != NULL ) params += ", ";
+    }
+
+    params += " )";
+    return params;
+}
+
+CBotFunction* CBotFunction::Next()
+{
+    return  m_next;
+}
+
+void CBotFunction::AddPublic(CBotFunction* func)
+{
+    if ( m_listPublic != NULL )
+    {
+        func->m_nextpublic = m_listPublic;
+        m_listPublic->m_prevpublic = func;
+    }
+    m_listPublic = func;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////
+// management of parameters
+
+
+CBotDefParam::CBotDefParam()
+{
+    m_next   = NULL;
+    m_nIdent = 0;
+}
+
+CBotDefParam::~CBotDefParam()
+{
+    delete  m_next;
+}
+
+
+// compiles a list of parameters
+CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    // mainly not pStack->TokenStack here
+    // declared variables must remain visible thereafter
+
+    pStack->SetStartError(p->GivStart());
+
+    if (IsOfType(p, ID_OPENPAR))
+    {
+        CBotDefParam* list = NULL;
+    
+        while (!IsOfType(p, ID_CLOSEPAR))
+        {
+            CBotDefParam* param = new CBotDefParam();
+            if (list == NULL) list = param;
+            else list->AddNext(param);          // added to the list
+
+            CBotClass*  pClass = NULL;//= CBotClass::Find(p);
+            param->m_typename = p->GivString();
+            CBotTypResult type = param->m_type = TypeParam(p, pStack);
+//          if ( type == CBotTypPointer ) type = CBotTypClass;          // we must create a new object
+
+            if (param->m_type.GivType() > 0)
+            {
+                CBotToken*  pp = p;
+                param->m_token = *p;
+                if (pStack->IsOk() && IsOfType(p, TokenTypVar) )
+                {
+
+                    // variable already declared?
+                    if (pStack->CheckVarLocal(pp))
+                    {
+                        pStack->SetError(TX_REDEFVAR, pp);
+                        break;
+                    }
+
+                    if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
+                    CBotVar*    var = CBotVar::Create(pp->GivString(), type);       // creates the variable
+//                  if ( pClass ) var->SetClass(pClass);
+                    var->SetInit(2);                                    // mark initialized
+                    param->m_nIdent = CBotVar::NextUniqNum();
+                    var->SetUniqNum(param->m_nIdent);
+                    pStack->AddVar(var);                                // place on the stack
+
+                    if (IsOfType(p, ID_COMMA) || p->GivType() == ID_CLOSEPAR)
+                        continue;
+                }
+                pStack->SetError(TX_CLOSEPAR, p->GivStart());
+            }
+            pStack->SetError(TX_NOTYP, p);
+            delete list;
+            return NULL;
+        }
+        return list;
+    }
+    pStack->SetError(TX_OPENPAR, p->GivStart());
+    return NULL;
+}
+
+void CBotDefParam::AddNext(CBotDefParam* p)
+{
+    CBotDefParam*   pp = this;
+    while (pp->m_next != NULL) pp = pp->m_next;
+
+    pp->m_next = p;
+}
+
+
+bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
+{
+    int             i = 0;
+    CBotDefParam*   p = this;
+
+    while ( p != NULL )
+    {
+        // creates a local variable on the stack
+        CBotVar*    newvar = CBotVar::Create(p->m_token.GivString(), p->m_type);
+
+        // serves to make the transformation of types:
+        if ( ppVars != NULL && ppVars[i] != NULL )
+        {
+            switch (p->m_type.GivType())
+            {
+            case CBotTypInt:
+                newvar->SetValInt(ppVars[i]->GivValInt());
+                break;
+            case CBotTypFloat:
+                newvar->SetValFloat(ppVars[i]->GivValFloat());
+                break;
+            case CBotTypString:
+                newvar->SetValString(ppVars[i]->GivValString());
+                break;
+            case CBotTypBoolean:
+                newvar->SetValInt(ppVars[i]->GivValInt());
+                break;
+            case CBotTypIntrinsic:
+                ((CBotVarClass*)newvar)->Copy(ppVars[i], false);
+                break;
+            case CBotTypPointer:
+            case CBotTypArrayPointer:
+                {
+                    newvar->SetPointer(ppVars[i]->GivPointer());
+                }
+                break;
+            default:
+                ASM_TRAP();
+            }
+        }
+        newvar->SetUniqNum(p->m_nIdent);
+        pj->AddVar(newvar);     // add a variable
+        p = p->m_next;
+        i++;
+    }
+
+    return true;
+}
+
+void CBotDefParam::RestoreState(CBotStack* &pj, bool bMain)
+{
+    int             i = 0;
+    CBotDefParam*   p = this;
+
+    while ( p != NULL )
+    {
+        // creates a local variable on the stack
+        CBotVar*    var = pj->FindVar(p->m_token.GivString());
+        var->SetUniqNum(p->m_nIdent);
+        p = p->m_next;
+    }
+}
+
+int CBotDefParam::GivType()
+{
+    return  m_type.GivType();
+}
+
+CBotTypResult CBotDefParam::GivTypResult()
+{
+    return  m_type;
+}
+
+CBotDefParam* CBotDefParam::GivNext()
+{
+    return  m_next;
+}
+
+CBotString CBotDefParam::GivParamString()
+{
+    CBotString  param;
+    
+    param = m_typename;
+    param += ' ';
+
+    param += m_token.GivString();
+    return param;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// return parameters
+
+CBotReturn::CBotReturn()
+{
+    m_Instr = NULL;
+    name = "CBotReturn";        // debug
+}
+
+CBotReturn::~CBotReturn()
+{
+    delete  m_Instr;
+}
+
+CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*  pp = p;
+
+    if (!IsOfType(p, ID_RETURN)) return NULL;   // should never happen
+
+    CBotReturn* inst = new CBotReturn();        // creates the object
+    inst->SetToken( pp );
+
+    CBotTypResult   type = pStack->GivRetType();
+
+    if ( type.GivType() == 0 )                  // returned void ?
+    {
+        if ( IsOfType( p, ID_SEP ) ) return inst;
+        pStack->SetError( TX_BADTYPE, pp );
+        return NULL;
+    }
+
+    inst->m_Instr = CBotExpression::Compile(p, pStack);
+    if ( pStack->IsOk() )
+    {
+        CBotTypResult   retType = pStack->GivTypResult(2);
+        if (TypeCompatible(retType, type, ID_ASS)) 
+        {
+            if ( IsOfType( p, ID_SEP ) )
+                return inst;
+
+            pStack->SetError(TX_ENDOF, p->GivStart());
+        }
+        pStack->SetError(TX_BADTYPE, p->GivStart());
+    }
+
+    delete inst;
+    return NULL;                            // no object, the error is on the stack
+}
+
+bool CBotReturn::Execute(CBotStack* &pj)
+{
+    CBotStack*  pile = pj->AddStack(this);
+//  if ( pile == EOX ) return true;
+
+    if ( pile->GivState() == 0 )
+    {
+        if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return false; // evaluate the result
+        // the result is on the stack
+        pile->IncState();
+    }
+
+    if ( pile->IfStep() ) return false;
+
+    pile->SetBreak(3, CBotString());
+    return pj->Return(pile);
+}
+
+void CBotReturn::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+    CBotStack*  pile = pj->RestoreStack(this);
+    if ( pile == NULL ) return;
+
+    if ( pile->GivState() == 0 )
+    {
+        if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain);  // evaluate the result
+        return;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Calls of these functions
+
+CBotInstrCall::CBotInstrCall()
+{
+    m_Parameters = NULL;
+    m_nFuncIdent = 0;
+    name = "CBotInstrCall";
+}
+
+CBotInstrCall::~CBotInstrCall()
+{
+    delete  m_Parameters;
+}
+
+CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotVar*    ppVars[1000];
+
+    int         i = 0;
+
+    CBotToken*  pp = p; 
+    p = p->GivNext();
+
+    pStack->SetStartError(p->GivStart());
+    CBotCStack* pile = pStack;
+
+    if ( IsOfType(p, ID_OPENPAR) )
+    {
+        int start, end;
+        CBotInstrCall* inst = new CBotInstrCall();
+        inst->SetToken(pp);
+
+        // compile la list of parameters
+        if (!IsOfType(p, ID_CLOSEPAR)) while (true)
+        {
+            start = p->GivStart();
+            pile = pile->TokenStack();                      // keeps the results on the stack
+
+            CBotInstr*  param = CBotExpression::Compile(p, pile);
+            end   = p->GivStart();
+            if ( inst->m_Parameters == NULL ) inst->m_Parameters = param;
+            else inst->m_Parameters->AddNext(param);            // constructs the list
+
+            if ( !pile->IsOk() )
+            {
+                delete inst;
+                return pStack->Return(NULL, pile);
+            }
+
+            if ( param != NULL )
+            {
+                if ( pile->GivTypResult().Eq(99) )
+                {
+                    delete pStack->TokenStack();
+                    pStack->SetError(TX_VOID, p->GivStart());
+                    delete inst;
+                    return NULL;
+                }
+                ppVars[i] = pile->GivVar();
+                ppVars[i]->GivToken()->SetPos(start, end);
+                i++;
+
+                if (IsOfType(p, ID_COMMA)) continue;            // skips the comma
+                if (IsOfType(p, ID_CLOSEPAR)) break;
+            }
+
+            pStack->SetError(TX_CLOSEPAR, p->GivStart());
+            delete pStack->TokenStack();
+            delete inst;
+            return NULL;
+        }
+        ppVars[i] = NULL;
+
+        // the routine is known?
+//      CBotClass*  pClass = NULL;
+        inst->m_typRes = pStack->CompileCall(pp, ppVars, inst->m_nFuncIdent);
+        if ( inst->m_typRes.GivType() >= 20 )
+        {
+//          if (pVar2!=NULL) pp = pVar2->RetToken();
+            pStack->SetError( inst->m_typRes.GivType(), pp );
+            delete pStack->TokenStack();
+            delete inst;
+            return NULL;
+        }
+
+        delete pStack->TokenStack();
+        if ( inst->m_typRes.GivType() > 0 )
+        {
+            CBotVar* pRes = CBotVar::Create("", inst->m_typRes);
+            pStack->SetVar(pRes);   // for knowing the type of the result
+        }
+        else pStack->SetVar(NULL);          // routine returns void
+
+        return inst;
+    }
+    p = pp;
+    delete pStack->TokenStack();
+    return NULL;
+}
+
+bool CBotInstrCall::Execute(CBotStack* &pj)
+{
+    CBotVar*    ppVars[1000];
+    CBotStack*  pile  = pj->AddStack(this);
+    if ( pile->StackOver() ) return pj->Return( pile );
+
+    CBotStack*  pile1 = pile;
+
+    int     i = 0;
+
+    CBotInstr*  p = m_Parameters;
+    // evaluates parameters
+    // and places the values ​​on the stack
+    // for allow of interruption at any time
+    if ( p != NULL) while ( true )
+    {
+        pile = pile->AddStack();                        // place on the stack for the results
+        if ( pile->GivState() == 0 )
+        {
+            if (!p->Execute(pile)) return false;        // interrupted here?
+            pile->SetState(1);                          // mark as special for reknowed parameters \TODO marque spéciale pour reconnaîre parameters
+        }
+        ppVars[i++] = pile->GivVar();
+        p = p->GivNext();
+        if ( p == NULL) break;
+    }
+    ppVars[i] = NULL;
+
+    CBotStack* pile2 = pile->AddStack();
+    if ( pile2->IfStep() ) return false;
+
+    if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return false; // interrupt
+
+    return pj->Return(pile2);   // release the entire stack
+}
+
+void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack*  pile  = pj->RestoreStack(this);
+    if ( pile == NULL ) return;
+
+    CBotStack*  pile1 = pile;
+
+    int         i = 0;
+    CBotVar*    ppVars[1000];
+    CBotInstr*  p = m_Parameters;
+    // evaluate parameters
+    // and place the values on the stack
+    // for allow of interruption at any time
+    if ( p != NULL) while ( true )
+    {
+        pile = pile->RestoreStack();                        // place on the stack for the results
+        if ( pile == NULL ) return;
+        if ( pile->GivState() == 0 )
+        {
+            p->RestoreState(pile, bMain);                   // interrupt here!
+            return;
+        }
+        ppVars[i++] = pile->GivVar();               // constructs the list of parameters
+        p = p->GivNext();
+        if ( p == NULL) break;
+    }
+    ppVars[i] = NULL;
+
+    CBotStack* pile2 = pile->RestoreStack();
+    if ( pile2 == NULL ) return;
+
+    pile2->RestoreCall(m_nFuncIdent, GivToken(), ppVars);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// statement of user classes
+
+// pre-compile a new class
+// analysis is complete except the body of routines
+
+CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
+{
+    if ( !IsOfType(p, ID_PUBLIC) )
+    {
+        pStack->SetError(TX_NOPUBLIC, p);
+        return NULL;
+    }
+    
+    if ( !IsOfType(p, ID_CLASS) ) return NULL;
+
+    CBotString name = p->GivString();
+
+    CBotClass* pOld = CBotClass::Find(name);
+    if ( pOld != NULL && pOld->m_IsDef )
+    {
+        pStack->SetError( TX_REDEFCLASS, p );
+        return NULL;
+    }
+
+    // a name of the class is there?
+    if (IsOfType(p, TokenTypVar))
+    {
+        CBotClass* pPapa = NULL;
+        if ( IsOfType( p, ID_EXTENDS ) )
+        {
+            CBotString name = p->GivString();
+            pPapa = CBotClass::Find(name);
+
+            if (!IsOfType(p, TokenTypVar) || pPapa == NULL )
+            {
+                pStack->SetError( TX_NOCLASS, p );
+                return NULL;
+            }
+        }
+        CBotClass* classe = (pOld == NULL) ? new CBotClass(name, pPapa) : pOld;
+        classe->Purge();                            // emptythe old definitions
+        classe->m_IsDef = false;                    // current definition
+
+        if ( !IsOfType( p, ID_OPBLK) )
+        {
+            pStack->SetError(TX_OPENBLK, p);
+            return NULL;
+        }
+
+        while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
+        {
+            classe->CompileDefItem(p, pStack, false);
+        }
+
+        if (pStack->IsOk()) return classe;
+    }
+    pStack->SetError(TX_ENDOF, p);
+    return NULL;
+}
+
+bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
+{
+    bool    bStatic = false;
+    int     mProtect = PR_PUBLIC;
+    bool    bSynchro = false;
+
+    while (IsOfType(p, ID_SEP)) ;
+
+    CBotTypResult   type( -1 );
+
+    if ( IsOfType(p, ID_SYNCHO) ) bSynchro = true;
+    CBotToken*      pBase = p;
+
+    if ( IsOfType(p, ID_STATIC) ) bStatic = true;
+    if ( IsOfType(p, ID_PUBLIC) ) mProtect = PR_PUBLIC;
+    if ( IsOfType(p, ID_PRIVATE) ) mProtect = PR_PRIVATE;
+    if ( IsOfType(p, ID_PROTECTED) ) mProtect = PR_PROTECT;
+    if ( IsOfType(p, ID_STATIC) ) bStatic = true;
+
+//  CBotClass* pClass = NULL;
+    type = TypeParam(p, pStack);        // type of the result
+
+    if ( type.Eq(-1) )
+    {
+        pStack->SetError(TX_NOTYP, p);
+        return false;
+    }
+
+    while (pStack->IsOk()) 
+    {
+        CBotToken*  pp = p;
+        IsOfType(p, ID_NOT);    // skips ~ eventual (destructor)
+
+        if (IsOfType(p, TokenTypVar))
+        {
+            CBotInstr* limites = NULL;
+            while ( IsOfType( p, ID_OPBRK ) )   // a table?
+            {
+                CBotInstr* i = NULL;
+
+                if ( p->GivType() != ID_CLBRK )
+                    i = CBotExpression::Compile( p, pStack );           // expression for the value
+                else
+                    i = new CBotEmpty();                            // special if not a formula
+
+                type = CBotTypResult(CBotTypArrayPointer, type);
+
+                if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) )
+                {
+                    pStack->SetError(TX_CLBRK, p->GivStart());
+                    return false;
+                }
+
+/*              CBotVar* pv = pStack->GivVar();
+                if ( pv->GivType()>= CBotTypBoolean )
+                {
+                    pStack->SetError(TX_BADTYPE, p->GivStart());
+                    return false;
+                }*/
+
+                if (limites == NULL) limites = i;
+                else limites->AddNext3(i);
+            }
+
+            if ( p->GivType() == ID_OPENPAR )
+            {
+                if ( !bSecond )
+                {
+                    p = pBase;
+                    CBotFunction* f = 
+                    CBotFunction::Compile1(p, pStack, this);
+
+                    if ( f == NULL ) return false;
+
+                    if (m_pMethod == NULL) m_pMethod = f;
+                    else m_pMethod->AddNext(f);
+                }
+                else
+                {
+                    // return a method precompiled in pass 1
+                    CBotFunction*   pf = m_pMethod;
+                    CBotFunction*   prev = NULL;
+                    while ( pf != NULL ) 
+                    {
+                        if (pf->GivName() == pp->GivString()) break;
+                        prev = pf;
+                        pf = pf->Next();
+                    }
+
+                    bool bConstructor = (pp->GivString() == GivName());
+                    CBotCStack* pile = pStack->TokenStack(NULL, true);
+
+                    // make "this" known
+                    CBotToken TokenThis(CBotString("this"), CBotString());
+                    CBotVar* pThis = CBotVar::Create(&TokenThis, CBotTypResult( CBotTypClass, this ) );
+                    pThis->SetUniqNum(-2);
+                    pile->AddVar(pThis);
+
+                    if ( m_pParent )
+                    {
+                        // makes "super" known
+                        CBotToken TokenSuper(CBotString("super"), CBotString());
+                        CBotVar* pThis = CBotVar::Create(&TokenSuper, CBotTypResult( CBotTypClass, m_pParent ) );
+                        pThis->SetUniqNum(-3);
+                        pile->AddVar(pThis);
+                    }
+
+//                  int num = 1;
+                    CBotClass*  my = this;
+                    while (my != NULL)
+                    {
+                        // places a copy of variables of a class (this) on a stack
+                        CBotVar* pv = my->m_pVar;
+                        while (pv != NULL)
+                        {
+                            CBotVar* pcopy = CBotVar::Create(pv);
+                            pcopy->SetInit(!bConstructor || pv->IsStatic());
+                            pcopy->SetUniqNum(pv->GivUniqNum());
+                            pile->AddVar(pcopy);
+                            pv = pv->GivNext();
+                        }
+                        my = my->m_pParent;
+                    }
+
+                    // compiles a method
+                    p = pBase;
+                    CBotFunction* f = 
+                    CBotFunction::Compile(p, pile, NULL/*, false*/);
+
+                    if ( f != NULL )
+                    {
+                        f->m_pProg = pStack->GivBotCall();
+                        f->m_bSynchro = bSynchro;
+                        // replaces the element in the chain
+                        f->m_next = pf->m_next;
+                        pf->m_next = NULL;
+                        delete pf;
+                        if (prev == NULL) m_pMethod = f;
+                        else prev->m_next = f;
+                    }
+                    pStack->Return(NULL, pile);
+                }
+
+                return pStack->IsOk();
+            }
+
+            // definition of an element
+            if (type.Eq(0))
+            {
+                pStack->SetError(TX_ENDOF, p);
+                return false;
+            }
+
+            CBotInstr* i = NULL;
+            if ( IsOfType(p, ID_ASS ) )
+            {
+                if ( type.Eq(CBotTypArrayPointer) )
+                {
+                    i = CBotListArray::Compile(p, pStack, type.GivTypElem());
+                }
+                else
+                {
+                    // it has an assignmet to calculate
+                    i = CBotTwoOpExpr::Compile(p, pStack);
+                }
+                if ( !pStack->IsOk() ) return false;
+            }
+
+
+            if ( !bSecond )
+            {
+                CBotVar*    pv = CBotVar::Create(pp->GivString(), type);
+                pv -> SetStatic( bStatic );
+                pv -> SetPrivate( mProtect );
+
+                AddItem( pv );
+
+                pv->m_InitExpr = i;
+                pv->m_LimExpr = limites;
+
+
+                if ( pv->IsStatic() && pv->m_InitExpr != NULL )
+                {
+                    CBotStack* pile = CBotStack::FirstStack();              // independent stack
+                    while(pile->IsOk() && !pv->m_InitExpr->Execute(pile));  // evaluates the expression without timer
+                    pv->SetVal( pile->GivVar() ) ;
+                    pile->Delete();
+                }
+            }
+            else
+                delete i;
+
+            if ( IsOfType(p, ID_COMMA) ) continue;
+            if ( IsOfType(p, ID_SEP) ) break;
+        }
+        pStack->SetError(TX_ENDOF, p);
+    }
+    return pStack->IsOk();
+}
+
+
+CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    if ( !IsOfType(p, ID_PUBLIC) ) return NULL;
+    if ( !IsOfType(p, ID_CLASS) ) return NULL;
+
+    CBotString name = p->GivString();
+
+    // a name for the class is there?
+    if (IsOfType(p, TokenTypVar))
+    {
+        // the class was created by Compile1
+        CBotClass* pOld = CBotClass::Find(name);
+
+        if ( IsOfType( p, ID_EXTENDS ) )
+        {
+            IsOfType(p, TokenTypVar); // necessarily
+        }
+        IsOfType( p, ID_OPBLK); // necessarily
+
+        while ( pStack->IsOk() && !IsOfType( p, ID_CLBLK ) )
+        {
+            pOld->CompileDefItem(p, pStack, true);
+        }
+
+        pOld->m_IsDef = true;           // complete definition
+        if (pStack->IsOk()) return pOld;
+    }
+    pStack->SetError(TX_ENDOF, p);
+    return NULL;
+}
diff --git a/src/CBot/CBotIf.cpp b/src/CBot/CBotIf.cpp
index 626ef0d..84dbd6a 100644
--- a/src/CBot/CBotIf.cpp
+++ b/src/CBot/CBotIf.cpp
@@ -1,159 +1,161 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////

-// instruction if (condition) opération1 else opération2;

-

-#include "CBot.h"

-

-// les divers constructeurs / destructeurs

-CBotIf::CBotIf()

-{

-	m_Condition =

-	m_Block		=

-	m_BlockElse	= NULL;			// NULL pour pouvoir faire delete directement

-	name = "CBotIf";			// debug

-}

-

-CBotIf::~CBotIf()

-{

-	delete	m_Condition;		// libère la condition

-	delete	m_Block;			// libère le bloc d'instruction1

-	delete	m_BlockElse;		// libère le bloc d'instruction2

-}

-

-// compilation (routine statique)

-// appelé lorsque le token "if" a été trouvé

-

-CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;							// conserve le ^au token (début instruction)

-

-	if (!IsOfType(p, ID_IF)) return NULL;		// ne doit jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-	CBotIf*	inst = new CBotIf();				// crée l'object

-	inst->SetToken( pp );

-

-	if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )

-	{

-		// la condition existe bel et bien

-

-		inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-		if ( pStk->IsOk() )

-		{

-			// le bloc d'instruction est ok (peut être vide)

-

-			// regarde si l'instruction suivante est le token "else"

-			if (IsOfType(p, ID_ELSE))

-			{

-				// si oui, compile le bloc d'instruction qui suit

-				inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-				if (!pStk->IsOk())

-				{

-					// il n'y a pas de bloc correct après le else

-					// libère l'objet, et transmet l'erreur qui est sur la pile

-					delete inst;

-					return pStack->Return(NULL, pStk);

-				}

-			}

-

-			// rend l'object correct à qui le demande.

-			return pStack->Return(inst, pStk);

-		}

-	}

-

-	// erreur, libère l'objet

-	delete inst;

-	// et transmet l'erreur qui se trouve sur la pile.

-	return pStack->Return(NULL, pStk);

-}

-

-

-// exécution de l'instruction

-

-BOOL CBotIf :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this);		// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	// selon la reprise, on peut être dans l'un des 2 états

-	if( pile->GivState() == 0 )

-	{

-		// évalue la condition

-		if ( !m_Condition->Execute(pile) ) return FALSE;	// interrompu ici ?

-

-		// termine s'il y a une erreur

-		if ( !pile->IsOk() )

-		{

-			return pj->Return(pile);						// transmet le résultat et libère la pile

-		}

-

-		// passe dans le second état

-		if (!pile->SetState(1)) return FALSE;				// prêt pour la suite

-	}

-	

-	// second état, évalue les instructions associées

-	// le résultat de la condition est sur la pile

-

-	if ( pile->GivVal() == TRUE )							// condition était vraie ?

-	{

-		if ( m_Block != NULL &&								// bloc peut être absent

-			!m_Block->Execute(pile) ) return FALSE;			// interrompu ici ?

-	}

-	else

-	{

-		if ( m_BlockElse != NULL &&							// s'il existe un bloc alternatif

-			!m_BlockElse->Execute(pile) ) return FALSE;		// interrompu ici

-	}

-

-	// transmet le résultat et libère la pile

-	return pj->Return(pile);

-}

-

-

-void CBotIf :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack* pile = pj->RestoreStack(this);		// ajoute un élément à la pile

-	if ( pile == NULL ) return;

-

-	// selon la reprise, on peut être dans l'un des 2 états

-	if( pile->GivState() == 0 )

-	{

-		// évalue la condition

-		m_Condition->RestoreState(pile, bMain);	// interrompu ici !

-		return;

-	}

-	

-	// second état, évalue les instructions associées

-	// le résultat de la condition est sur la pile

-

-	if ( pile->GivVal() == TRUE )							// condition était vraie ?

-	{

-		if ( m_Block != NULL )								// bloc peut être absent

-			 m_Block->RestoreState(pile, bMain);			// interrompu ici !

-	}

-	else

-	{

-		if ( m_BlockElse != NULL )							// s'il existe un bloc alternatif

-			 m_BlockElse->RestoreState(pile, bMain);		// interrompu ici !

-	}

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////////////////////////
+// instruction if (condition) operation1 else operation2;
+
+#include "CBot.h"
+
+// various constructors / destructors
+CBotIf::CBotIf()
+{
+    m_Condition =
+    m_Block     =
+    m_BlockElse = NULL;         // NULL so that delete is not possible further
+    name = "CBotIf";            // debug
+}
+
+CBotIf::~CBotIf()
+{
+    delete  m_Condition;        // frees the condition
+    delete  m_Block;            // frees the block of instruction1
+    delete  m_BlockElse;        // frees the block of instruction2
+}
+
+// compilation (static routine)
+// called when the token "if" has been found
+
+CBotInstr* CBotIf::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting instruction)
+
+    if (!IsOfType(p, ID_IF)) return NULL;       // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+
+    CBotIf* inst = new CBotIf();                // create the object
+    inst->SetToken( pp );
+
+    if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
+    {
+        // the condition does exist
+
+        inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
+        if ( pStk->IsOk() )
+        {
+            // the statement block is ok (can be empty)
+
+            // see if the next instruction is the token "else"
+            if (IsOfType(p, ID_ELSE))
+            {
+                // if so, compiles the following statement block
+                inst->m_BlockElse = CBotBlock::CompileBlkOrInst( p, pStk, true );
+                if (!pStk->IsOk())
+                {
+                    // there is no correct block after the else
+                    // frees the object, and transmits the error that is on the stack
+                    delete inst;
+                    return pStack->Return(NULL, pStk);
+                }
+            }
+
+            // return the corrent object to the application
+            return pStack->Return(inst, pStk);
+        }
+    }
+
+    // error, frees the object
+    delete inst;
+    // and transmits the error that is on the stack.
+    return pStack->Return(NULL, pStk);
+}
+
+
+// execution of the instruction
+
+bool CBotIf :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this);       // adds an item to the stack
+                                                // or found in case of recovery
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    // according to recovery, it may be in one of two states
+    if( pile->GivState() == 0 )
+    {
+        // evaluates the condition
+        if ( !m_Condition->Execute(pile) ) return false;    // interrupted here?
+
+        // terminates if there is an error
+        if ( !pile->IsOk() )
+        {
+            return pj->Return(pile);                        // returns the results and releases the stack
+        }
+
+        // passes into the second state
+        if (!pile->SetState(1)) return false;               // ready for further
+    }
+    
+    // second state, evaluates the associated instructions
+    // the result of the condition is on the stack
+
+    if ( pile->GivVal() == true )                           // condition was true?
+    {
+        if ( m_Block != NULL &&                             // block may be absent
+            !m_Block->Execute(pile) ) return false;         // interrupted here?
+    }
+    else
+    {
+        if ( m_BlockElse != NULL &&                         // if there is an alternate block
+            !m_BlockElse->Execute(pile) ) return false; // interrupted here
+    }
+
+    // sends the results and releases the stack
+    return pj->Return(pile);
+}
+
+
+void CBotIf :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack* pile = pj->RestoreStack(this);       // adds an item to the stack
+    if ( pile == NULL ) return;
+
+    // according to recovery, it may be in one of two states
+    if( pile->GivState() == 0 )
+    {
+        // evaluates the condition
+        m_Condition->RestoreState(pile, bMain); // interrupted here!
+        return;
+    }
+    
+    // second state, evaluates the associated instructions
+    // the result of the condition is on the stack
+
+    if ( pile->GivVal() == true )                           // condition was true?
+    {
+        if ( m_Block != NULL )                              // block may be absent
+             m_Block->RestoreState(pile, bMain);            // interrupted here!
+    }
+    else
+    {
+        if ( m_BlockElse != NULL )                          // if there is an alternate block
+             m_BlockElse->RestoreState(pile, bMain);        // interrupted here!
+    }
+}
+
diff --git a/src/CBot/CBotProgram.cpp b/src/CBot/CBotProgram.cpp
index f157c4c..d9be052 100644
--- a/src/CBot/CBotProgram.cpp
+++ b/src/CBot/CBotProgram.cpp
@@ -1,1116 +1,1113 @@
-// * 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  http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////////

-// gestion de base d'un programme CBot

-

-#include "CBot.h"

-#include <stdio.h>

-

-CBotProgram::CBotProgram()

-{

-	m_Prog		= NULL;

-	m_pRun		= NULL;

-	m_pClass	= NULL;

-	m_pStack	= NULL;

-	m_pInstance = NULL;

-

-	m_ErrorCode = 0;

-	m_Ident		= 0;

-	m_bDebugDD	= 0;

-}

-

-CBotProgram::CBotProgram(CBotVar* pInstance)

-{

-	m_Prog		= NULL;

-	m_pRun		= NULL;

-	m_pClass	= NULL;

-	m_pStack	= NULL;

-	m_pInstance = pInstance;

-

-	m_ErrorCode = 0;

-	m_Ident		= 0;

-	m_bDebugDD	= 0;

-}

-

-

-CBotProgram::~CBotProgram()

-{

-//	delete	m_pClass;

-	m_pClass->Purge();

-	m_pClass	= NULL;

-

-	CBotClass::FreeLock(this);

-

-	delete	m_Prog;

-#if	STACKMEM

-	m_pStack->Delete();

-#else

-	delete	m_pStack;

-#endif

-}

-

-

-BOOL CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, void* pUser )

-{

-	int			error = 0;

-	Stop();

-

-//	delete		m_pClass;

-	m_pClass->Purge();		// purge les anciennes définitions des classes

-							// mais sans détruire l'object

-	m_pClass	= NULL;

-	delete		m_Prog;		m_Prog= NULL;

-

-	ListFonctions.SetSize(0);

-	m_ErrorCode = 0;

-

-	if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)

-		pUser = m_pInstance->m_pUserPtr;

-

-	// transforme le programme en Tokens

-	CBotToken*	pBaseToken = CBotToken::CompileTokens(program, error);

-	if ( pBaseToken == NULL ) return FALSE;

-

-

-	CBotCStack*	pStack		= new CBotCStack(NULL);

-	CBotToken*	p  = pBaseToken->GivNext();					// saute le 1er token (séparateur)

-

-	pStack->SetBotCall(this);								// défini les routines utilisables

-	CBotCall::SetPUser(pUser);

-

-	// fait une première passe rapide juste pour prendre les entêtes de routines et de classes

-	while ( pStack->IsOk() && p != NULL && p->GivType() != 0)

-	{

-		if ( IsOfType(p, ID_SEP) ) continue;				// des point-virgules qui trainent

-

-		if ( p->GivType() == ID_CLASS || 

-			( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))

-		{

-			CBotClass*	nxt = CBotClass::Compile1(p, pStack);

-			if (m_pClass == NULL ) m_pClass = nxt;

-			else m_pClass->AddNext(nxt);

-		}

-		else

-		{

-			CBotFunction*	next = CBotFunction::Compile1(p, pStack, NULL);

-			if (m_Prog == NULL ) m_Prog = next;

-			else m_Prog->AddNext(next);

-		}

-	}

-	if ( !pStack->IsOk() )

-	{

-		m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); 

-		delete m_Prog;

-		m_Prog = NULL;

-		delete pBaseToken;

-		return FALSE;

-	}

-

-//	CBotFunction*	temp = NULL;

-	CBotFunction*	next = m_Prog;		// reprend la liste

-

-	p  = pBaseToken->GivNext();								// revient au début

-

-	while ( pStack->IsOk() && p != NULL && p->GivType() != 0 )

-	{

-		if ( IsOfType(p, ID_SEP) ) continue;				// des point-virgules qui trainent

-

-		if ( p->GivType() == ID_CLASS || 

-			( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))

-		{

-			m_bCompileClass = TRUE;

-			CBotClass::Compile(p, pStack);					// complète la définition de la classe

-		}

-		else

-		{

-			m_bCompileClass = FALSE;

-			CBotFunction::Compile(p, pStack, next);

-			if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/);

-			next->m_pProg = this;							// garde le pointeur au module

-			next = next->Next();

-		}

-	}

-

-//	delete m_Prog;			// la liste de la 1ère passe

-//	m_Prog = temp;			// la liste de la seconde passe

-

-	if ( !pStack->IsOk() )

-	{

-		m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); 

-		delete m_Prog;

-		m_Prog = NULL;

-	}

-

-	delete pBaseToken;

-	delete pStack;

-

-	return (m_Prog != NULL);

-}

-

-

-BOOL CBotProgram::Start(const char* name)

-{

-#if	STACKMEM

-	m_pStack->Delete();

-#else

-	delete m_pStack;

-#endif

-	m_pStack = NULL;

-

-	m_pRun = m_Prog;

-	while (m_pRun != NULL)

-	{

-		if ( m_pRun->GivName() == name ) break;

-		m_pRun = m_pRun->m_next;

-	}

-

-	if ( m_pRun == NULL )

-	{

-		m_ErrorCode = TX_NORUN;

-		return FALSE;

-	}

-

-#if	STACKMEM

-	m_pStack = CBotStack::FirstStack();

-#else

-	m_pStack = new CBotStack(NULL);					// crée une pile d'exécution

-#endif

-

-	m_pStack->SetBotCall(this);						// bases pour les routines

-

-	return TRUE;									// on est prêt pour un Run()

-}

-

-BOOL CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop)

-{

-	CBotFunction* p = m_Prog;

-	while (p != NULL)

-	{

-		if ( p->GivName() == name ) break;

-		p = p->m_next;

-	}

-

-	if ( p == NULL ) return FALSE;

-

-	p->GetPosition(start, stop, modestart, modestop);

-	return TRUE;

-}

-

-BOOL CBotProgram::Run(void* pUser, int timer)

-{

-	BOOL	ok;

-

-	if (m_pStack == NULL || m_pRun == NULL) goto error;

-

-	m_ErrorCode = 0;

-	if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)

-		pUser = m_pInstance->m_pUserPtr;

-

-	m_pStack->Reset(pUser);							// vide l'éventuelle erreur précédente, et remet le timer

-	if ( timer >= 0 ) m_pStack->SetTimer(timer);

-

-	m_pStack->SetBotCall(this);						// bases pour les routines

-

-#if	STACKRUN

-	// reprend l'exécution sur le haut de la pile

-	ok = m_pStack->Execute();

-	if ( ok ) 

-	{

-#ifdef	_DEBUG

-		CBotVar*	ppVar[3];

-		ppVar[0] = CBotVar::Create("aa", CBotTypInt);

-		ppVar[1] = CBotVar::Create("bb", CBotTypInt);

-		ppVar[2] = NULL;

-		ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance);

-#else

-		// revient sur l'exécution normale

-		ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);

-#endif

-	}

-#else

-	ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);

-#endif

-

-	// terminé sur une erreur ?

-	if (!ok && !m_pStack->IsOk())

-	{

-		m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd);

-#if	STACKMEM

-		m_pStack->Delete();

-#else

-		delete m_pStack;

-#endif

-		m_pStack = NULL;

-		return TRUE;								// exécution terminée !!

-	}

-

-	if ( ok ) m_pRun = NULL;						// plus de fonction en exécution

-	return ok;

-

-error:

-	m_ErrorCode = TX_NORUN;

-	return TRUE;

-}

-

-void CBotProgram::Stop()

-{

-#if	STACKMEM

-	m_pStack->Delete();

-#else

-	delete m_pStack;

-#endif

-	m_pStack = NULL;

-	m_pRun = NULL;

-}

-

-

-

-BOOL CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end)

-{

-	FunctionName = NULL;

-	start = end = 0;

-	if (m_pStack == NULL) return FALSE;

-

-	m_pStack->GetRunPos(FunctionName, start, end);

-	return TRUE;

-}

-

-CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level)

-{

-	FunctionName = NULL;

-	if (m_pStack == NULL) return NULL;

-

-	return m_pStack->GivStackVars(FunctionName, level);

-}

-

-

-

-

-

-

-

-void CBotProgram::SetTimer(int n)

-{

-	CBotStack::SetTimer( n );

-}

-

-int CBotProgram::GivError()

-{

-	return m_ErrorCode;

-}

-

-void CBotProgram::SetIdent(long n)

-{

-	m_Ident = n;

-}

-

-long CBotProgram::GivIdent()

-{

-	return m_Ident;

-}

-

-BOOL CBotProgram::GetError(int& code, int& start, int& end)

-{

-	code  = m_ErrorCode;

-	start = m_ErrorStart;

-	end   = m_ErrorEnd;

-	return code > 0;

-}

-

-BOOL CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg)

-{

-	code	= m_ErrorCode;

-	start	= m_ErrorStart;

-	end		= m_ErrorEnd;

-	pProg	= this;

-	return code > 0;

-}

-

-CBotString CBotProgram::GivErrorText(int code)

-{

-	CBotString TextError;

-

-	TextError.LoadString( code );

-	if (TextError.IsEmpty())

-	{

-		char	buf[100];

-		sprintf(buf, "Exception numéro %d.", code);

-		TextError = buf;

-	}

-	return TextError;

-}

-

-

-CBotFunction* CBotProgram::GivFunctions()

-{

-	return	m_Prog;

-}

-

-BOOL CBotProgram::AddFunction(const char* name, 

-							  BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-							  CBotTypResult rCompile (CBotVar* &pVar, void* pUser))

-{

-	// mémorise les pointeurs aux deux fonctions

-	return CBotCall::AddFunction(name, rExec, rCompile);

-}

-

-

-BOOL WriteWord(FILE* pf, WORD w)

-{

-	size_t	lg;

-

-	lg = fwrite(&w, sizeof( WORD ), 1, pf );

-

-	return (lg == 1);     

-}

-

-BOOL ReadWord(FILE* pf, WORD& w)

-{

-	size_t	lg;

-

-	lg = fread(&w, sizeof( WORD ), 1, pf );

-

-	return (lg == 1);

-}

-

-BOOL WriteFloat(FILE* pf, float w)

-{

-	size_t	lg;

-

-	lg = fwrite(&w, sizeof( float ), 1, pf );

-

-	return (lg == 1);     

-}

-

-BOOL ReadFloat(FILE* pf, float& w)

-{

-	size_t	lg;

-

-	lg = fread(&w, sizeof( float ), 1, pf );

-

-	return (lg == 1);

-}

-

-BOOL WriteLong(FILE* pf, long w)

-{

-	size_t	lg;

-

-	lg = fwrite(&w, sizeof( long ), 1, pf );

-

-	return (lg == 1);     

-}

-

-BOOL ReadLong(FILE* pf, long& w)

-{

-	size_t	lg;

-

-	lg = fread(&w, sizeof( long ), 1, pf );

-

-	return (lg == 1);

-}

-

-BOOL WriteString(FILE* pf, CBotString s)

-{

-	size_t	lg1, lg2;

-

-	lg1 = s.GivLength();

-	if (!WriteWord(pf, lg1)) return FALSE;

-

-	lg2 = fwrite(s, 1, lg1, pf );

-	return (lg1 == lg2);     

-}

-

-BOOL ReadString(FILE* pf, CBotString& s)

-{

-	WORD	w;

-	char	buf[1000];

-	size_t	lg1, lg2;

-

-	if (!ReadWord(pf, w)) return FALSE;

-	lg1 = w;

-	lg2 = fread(buf, 1, lg1, pf );

-	buf[lg2] = 0;

-

-	s = buf;

-	return (lg1 == lg2);

-}

-

-BOOL WriteType(FILE* pf, CBotTypResult type)

-{

-	int	typ = type.GivType();

-	if ( typ == CBotTypIntrinsic ) typ = CBotTypClass;

-	if ( !WriteWord(pf, typ) ) return FALSE;

-	if ( typ == CBotTypClass )

-	{

-		CBotClass* p = type.GivClass();

-		if ( !WriteString(pf, p->GivName()) ) return FALSE;

-	}

-	if ( type.Eq( CBotTypArrayBody ) ||

-		 type.Eq( CBotTypArrayPointer ) )

-	{

-		if ( !WriteWord(pf, type.GivLimite()) ) return FALSE;

-		if ( !WriteType(pf, type.GivTypElem()) ) return FALSE;

-	}

-	return TRUE;

-}

-

-BOOL ReadType(FILE* pf, CBotTypResult& type)

-{

-	WORD	w, ww;

-	if ( !ReadWord(pf, w) ) return FALSE;

-	type.SetType(w);

-

-	if ( type.Eq( CBotTypIntrinsic ) )

-	{

-		type = CBotTypResult( w, "point" );

-	}

-

-	if ( type.Eq( CBotTypClass ) )

-	{

-		CBotString	s;

-		if ( !ReadString(pf, s) ) return FALSE;

-		type = CBotTypResult( w, s );

-	}

-

-	if ( type.Eq( CBotTypArrayPointer ) ||

-		 type.Eq( CBotTypArrayBody ) )

-	{

-		CBotTypResult	r;

-		if ( !ReadWord(pf, ww) ) return FALSE;

-		if ( !ReadType(pf, r) ) return FALSE;

-		type = CBotTypResult( w, r );

-		type.SetLimite((short)ww);

-	}

-	return TRUE;

-}

-

-

-BOOL CBotProgram::DefineNum(const char* name, long val)

-{

-	return CBotToken::DefineNum(name, val);

-}

-

-

-BOOL CBotProgram::SaveState(FILE* pf)

-{

-	if (!WriteWord( pf, CBOTVERSION)) return FALSE;

-

-

-	if ( m_pStack != NULL )

-	{

-		if (!WriteWord( pf, 1)) return FALSE;

-		if (!WriteString( pf, m_pRun->GivName() )) return FALSE;

-		if (!m_pStack->SaveState(pf)) return FALSE;

-	}

-	else 

-	{

-		if (!WriteWord( pf, 0)) return FALSE;

-	}

-	return TRUE;

-}

-

-

-BOOL CBotProgram::RestoreState(FILE* pf)

-{

-	WORD		w;

-	CBotString	s;

-

-	Stop();

-

-	if (!ReadWord( pf, w )) return FALSE;

-	if ( w != CBOTVERSION ) return FALSE;

-

-	if (!ReadWord( pf, w )) return FALSE;

-	if ( w == 0 ) return TRUE;

-

-	if (!ReadString( pf, s )) return FALSE;

-	Start(s);		// point de reprise

-

-#if	STACKMEM

-	m_pStack->Delete();

-#else

-	delete m_pStack;

-#endif

-	m_pStack = NULL;

-

-	// récupère la pile depuis l'enregistrement

-	// utilise un pointeur NULL (m_pStack) mais c'est ok comme ça

-	if (!m_pStack->RestoreState(pf, m_pStack)) return FALSE;

-	m_pStack->SetBotCall(this);						// bases pour les routines

-

-	// rétabli certains états dans la pile selon la structure

-	m_pRun->RestoreState(NULL, m_pStack, m_pInstance);

-	return TRUE;

-}

-

-int CBotProgram::GivVersion()

-{

-	return	CBOTVERSION;

-}

-

-

-//////////////////////////////////////////////////////////////////////////////////////////////////////

-

-CBotCall* CBotCall::m_ListCalls = NULL;

-	

-CBotCall::CBotCall(const char* name, 

-				   BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-				   CBotTypResult rCompile (CBotVar* &pVar, void* pUser))

-{

-	m_name		 = name;

-	m_rExec		 = rExec;

-	m_rComp		 = rCompile;

-	m_next		 = NULL;

-	m_nFuncIdent = CBotVar::NextUniqNum();

-}

-

-CBotCall::~CBotCall()

-{

-	if (m_next) delete m_next;

-	m_next = NULL;

-}

-

-void CBotCall::Free()

-{

-	delete CBotCall::m_ListCalls;

-}

-

-BOOL CBotCall::AddFunction(const char* name, 

-						   BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 

-						   CBotTypResult rCompile (CBotVar* &pVar, void* pUser))

-{

-	CBotCall*	p = m_ListCalls;

-	CBotCall*	pp = NULL;

-

-	if ( p != NULL ) while ( p->m_next != NULL )

-	{

-		if ( p->GivName() == name )

-		{

-			// libère une fonction qu'on redéfini

-			if ( pp ) pp->m_next = p->m_next;

-			else	  m_ListCalls = p->m_next;

-			pp = p;

-			p = p->m_next;

-			pp->m_next = NULL;	// ne pas détruire la suite de la liste

-			delete pp;

-			continue;

-		}

-		pp = p;				// pointeur précédent

-		p = p->m_next;

-	}

-

-	pp = new CBotCall(name, rExec, rCompile);

-	

-	if (p) p->m_next = pp;

-	else m_ListCalls = pp;

-

-	return TRUE;

-}

-

-

-// transforme le tableau de pointeurs aux variables

-// en une liste de variables chaînées

-CBotVar* MakeListVars(CBotVar** ppVars, BOOL bSetVal=FALSE)

-{

-	int		i = 0;

-	CBotVar*	pVar = NULL;

-

-	while( TRUE )

-	{

-		ppVars[i];

-		if ( ppVars[i] == NULL ) break;

-

-		CBotVar*	pp = CBotVar::Create(ppVars[i]);

-		if (bSetVal) pp->Copy(ppVars[i]);

-		else

-			if ( ppVars[i]->GivType() == CBotTypPointer )

-				pp->SetClass( ppVars[i]->GivClass());

-// copier le pointeur selon indirection		

-		if (pVar == NULL) pVar = pp;

-		else pVar->AddNext(pp);

-		i++;

-	}

-	return pVar;

-}

-

-// trouve un appel acceptable selon le nom de la procédure

-// et les paramètres donnés

-

-CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* pStack, long& nIdent)

-{

-	nIdent = 0;

-	CBotCall*	pt = m_ListCalls;

-	CBotString	name = p->GivString();

-

-	while ( pt != NULL )

-	{

-		if ( pt->m_name == name )

-		{

-			CBotVar*	pVar = MakeListVars(ppVar);

-			CBotVar*	pVar2 = pVar;

-			CBotTypResult r = pt->m_rComp(pVar2, m_pUser);

-			int ret = r.GivType();

-			

-			// si une classe est retournée, c'est en fait un pointeur

-			if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer );

-

-			if ( ret > 20 )

-			{

-				if (pVar2) pStack->SetError(ret, p /*pVar2->GivToken()*/ );

-			}

-			delete pVar;

-			nIdent = pt->m_nFuncIdent;

-			return r;

-		}

-		pt = pt->m_next;

-	}

-	return -1;

-}

-

-void* CBotCall::m_pUser = NULL;

-

-void CBotCall::SetPUser(void* pUser)

-{

-	m_pUser = pUser;

-}

-

-int CBotCall::CheckCall(const char* name)

-{

-	CBotCall* p = m_ListCalls;

-

-	while ( p != NULL )

-	{

-		if ( name == p->GivName() ) return TRUE;

-		p = p->m_next;

-	}

-	return FALSE;

-}

-

-

-

-CBotString CBotCall::GivName()

-{

-	return	m_name;

-}

-

-CBotCall* CBotCall::Next()

-{

-	return	m_next;

-}

-

-

-int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack, CBotTypResult& rettype)

-{

-	CBotCall*	pt = m_ListCalls;

-

-	if ( nIdent ) while ( pt != NULL )

-	{

-		if ( pt->m_nFuncIdent == nIdent )

-		{

-			goto fund;

-		}

-		pt = pt->m_next;

-	}

-

-	pt = m_ListCalls;

-

-	if ( token != NULL )

-	{

-		CBotString name = token->GivString();

-		while ( pt != NULL )

-		{

-			if ( pt->m_name == name )

-			{

-				nIdent = pt->m_nFuncIdent;

-				goto fund;

-			}

-			pt = pt->m_next;

-		}

-	}

-

-	return -1;

-

-fund:

-#if !STACKRUN

-	// fait la liste des paramètres selon le contenu de la pile (pStackVar)

-

-	CBotVar*	pVar = MakeListVars(ppVar, TRUE);

-	CBotVar*	pVarToDelete = pVar;

-

-	// crée une variable pour le résultat

-	CBotVar*	pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);

-

-	CBotVar*	pRes = pResult;

-	int			Exception = 0;

-	int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser());

-

-	if ( pResult != pRes ) delete pRes;	// si résultat différent rendu

-	delete pVarToDelete;

-

-	if (res == FALSE)

-	{

-		if (Exception!=0)

-		{

-			pStack->SetError(Exception, token);

-		}

-		delete pResult;

-		return FALSE;

-	}

-	pStack->SetVar(pResult);

-

-	if ( rettype.GivType() > 0 && pResult == NULL )

-	{

-		pStack->SetError(TX_NORETVAL, token);

-	}

-	nIdent = pt->m_nFuncIdent;

-	return TRUE;

-

-#else

-

-	CBotStack*	pile = pStack->AddStackEOX(pt);

-	if ( pile == EOX ) return TRUE;

-

-	// fait la liste des paramètres selon le contenu de la pile (pStackVar)

-

-	CBotVar*	pVar = MakeListVars(ppVar, TRUE);

-	CBotVar*	pVarToDelete = pVar;

-

-	// crée une variable pour le résultat

-	CBotVar*	pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);

-

-	pile->SetVar( pVar );

-

-	CBotStack*	pile2 = pile->AddStack();

-	pile2->SetVar( pResult );

-

-	pile->SetError(0, token);			// pour la position en cas d'erreur + loin

-	return pt->Run( pStack );

-

-#endif

-

-}

-

-#if	STACKRUN

-

-BOOL CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack)

-{

-	CBotCall*	pt = m_ListCalls;

-

-	{

-		CBotString name = token->GivString();

-		while ( pt != NULL )

-		{

-			if ( pt->m_name == name )

-			{

-				nIdent = pt->m_nFuncIdent;

-

-				CBotStack*	pile = pStack->RestoreStackEOX(pt);

-				if ( pile == NULL ) return TRUE;

-

-				CBotStack*	pile2 = pile->RestoreStack();

-				return TRUE;

-			}

-			pt = pt->m_next;

-		}

-	}

-

-	return FALSE;

-}

-

-BOOL CBotCall::Run(CBotStack* pStack)

-{

-	CBotStack*	pile = pStack->AddStackEOX(this);

-	if ( pile == EOX ) return TRUE;

-	CBotVar*	pVar = pile->GivVar();

-

-	CBotStack*	pile2 = pile->AddStack();

-	CBotVar*	pResult = pile2->GivVar();

-	CBotVar*	pRes = pResult;

-

-	int			Exception = 0;

-	int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser());

-

-	if (res == FALSE)

-	{

-		if (Exception!=0)

-		{

-			pStack->SetError(Exception);

-		}

-		if ( pResult != pRes ) delete pResult;	// si résultat différent rendu

-		return FALSE;

-	}

-

-	if ( pResult != NULL ) pStack->SetCopyVar( pResult );

-	if ( pResult != pRes ) delete pResult;	// si résultat différent rendu

-

-	return TRUE;

-}

-

-#endif

-

-///////////////////////////////////////////////////////////////////////////////////////

-

-CBotCallMethode::CBotCallMethode(const char* name, 

-				   BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 

-				   CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))

-{

-	m_name		 = name;

-	m_rExec		 = rExec;

-	m_rComp		 = rCompile;

-	m_next		 = NULL;

-	m_nFuncIdent = CBotVar::NextUniqNum();

-}

-

-CBotCallMethode::~CBotCallMethode()

-{

-	delete m_next;

-	m_next = NULL;

-}

-

-// trouve un appel acceptable selon le nom de la procédure

-// et les paramètres donnés

-

-CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis, 

-										   CBotVar** ppVar, CBotCStack* pStack,

-										   long& nIdent)

-{

-	CBotCallMethode*	pt = this;

-	nIdent = 0;

-

-	while ( pt != NULL )

-	{

-		if ( pt->m_name == name )

-		{

-			CBotVar*	pVar = MakeListVars(ppVar, TRUE);

-			CBotVar*	pVar2 = pVar;

-			CBotTypResult r = pt->m_rComp(pThis, pVar2);

-			int	ret = r.GivType();

-			if ( ret > 20 )

-			{

-				if (pVar2) pStack->SetError(ret, pVar2->GivToken());

-			}

-			delete pVar;

-			nIdent = pt->m_nFuncIdent;

-			return r;

-		}

-		pt = pt->m_next;

-	}

-	return CBotTypResult(-1);

-}

-

-

-CBotString CBotCallMethode::GivName()

-{

-	return	m_name;

-}

-

-CBotCallMethode* CBotCallMethode::Next()

-{

-	return	m_next;

-}

-

-void CBotCallMethode::AddNext(CBotCallMethode* pt)

-{

-	CBotCallMethode* p = this;

-	while ( p->m_next != NULL ) p = p->m_next;

-

-	p->m_next = pt;

-}

-

-

-int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pToken)

-{

-	CBotCallMethode*	pt = this;

-

-	// recherche selon l'identificateur

-

-	if ( nIdent ) while ( pt != NULL )

-	{

-		if ( pt->m_nFuncIdent == nIdent )

-		{

-			// fait la liste des paramètres selon le contenu de la pile (pStackVar)

-

-			CBotVar*	pVar = MakeListVars(ppVars, TRUE);

-			CBotVar*	pVarToDelete = pVar;

-

-			// puis appelle la routine externe au module

-

-			int			Exception = 0;

-			int res = pt->m_rExec(pThis, pVar, pResult, Exception);

-			pStack->SetVar(pResult);

-

-			if (res == FALSE)

-			{

-				if (Exception!=0)

-				{

-//					pStack->SetError(Exception, pVar->GivToken());

-					pStack->SetError(Exception, pToken);

-				}

-				delete pVarToDelete;

-				return FALSE;

-			}

-			delete pVarToDelete;

-			return TRUE;

-		}

-		pt = pt->m_next;

-	}

-

-	// recherche selon le nom

-

-	while ( pt != NULL )

-	{

-		if ( pt->m_name == name )

-		{

-			// fait la liste des paramètres selon le contenu de la pile (pStackVar)

-

-			CBotVar*	pVar = MakeListVars(ppVars, TRUE);

-			CBotVar*	pVarToDelete = pVar;

-

-			int			Exception = 0;

-			int res = pt->m_rExec(pThis, pVar, pResult, Exception);

-			pStack->SetVar(pResult);

-

-			if (res == FALSE)

-			{

-				if (Exception!=0)

-				{

-//					pStack->SetError(Exception, pVar->GivToken());

-					pStack->SetError(Exception, pToken);

-				}

-				delete pVarToDelete;

-				return FALSE;

-			}

-			delete pVarToDelete;

-			nIdent = pt->m_nFuncIdent;

-			return TRUE;

-		}

-		pt = pt->m_next;

-	}

-

-	return -1;

-}

-

-BOOL rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	if ( pVar == NULL ) return TX_LOWPARAM;

-

-	int	i = 0;

-	pVar = pVar->GivItemList();

-

-	while ( pVar != NULL )

-	{

-		i++; 

-		pVar = pVar->GivNext();

-	}

-

-	pResult->SetValInt(i);

-	return TRUE;

-}

-

-CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )

-{

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-	if ( pVar->GivType() != CBotTypArrayPointer )

-						return CBotTypResult( TX_BADPARAM );

-	return CBotTypResult( CBotTypInt );

-}

-

-

-CBotString CBotProgram::m_DebugVarStr = "";

-

-BOOL rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	pResult->SetValString( CBotProgram::m_DebugVarStr );

-

-	return TRUE;

-}

-

-CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )

-{

-	// pas de paramètre

-	if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// la fonction retourne un résultat "string"

-	return CBotTypResult( CBotTypString );

-}

-

-

-#include "StringFunctions.cpp"

-

-void CBotProgram::Init()

-{

-	CBotToken::DefineNum( "CBotErrOpenPar", 5000) ;		// manque la parenthèse ouvrante

-	CBotToken::DefineNum( "CBotErrClosePar", 5001) ;	// manque la parenthèse fermante

-	CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ;	// l'expression doit être un boolean

-	CBotToken::DefineNum( "CBotErrUndefVar", 5003) ;	// variable non déclarée

-	CBotToken::DefineNum( "CBotErrBadLeft", 5004) ;		// assignation impossible ( 5 = ... )

-	CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// point-virgule attendu

-	CBotToken::DefineNum( "CBotErrCaseOut", 5006) ;		// case en dehors d'un switch

-	CBotToken::DefineNum( "CBotErrCloseBlock", 5008) ;	// manque " } "

-	CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else sans if correspondant

-	CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ;	// manque " { "

-	CBotToken::DefineNum( "CBotErrBadType1", 5011) ;	// mauvais type pour l'assignation

-	CBotToken::DefineNum( "CBotErrRedefVar", 5012) ;	// redéfinition de la variable

-	CBotToken::DefineNum( "CBotErrBadType2", 5013) ;	// 2 opérandes de type incompatibles

-	CBotToken::DefineNum( "CBotErrUndefCall", 5014) ;	// routine inconnue

-	CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " attendu

-	CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break en dehors d'une boucle

-	CBotToken::DefineNum( "CBotErrUndefLabel", 5019) ;	// label inconnu

-	CBotToken::DefineNum( "CBotErrLabel", 5018) ;		// label ne peut se mettre ici

-	CBotToken::DefineNum( "CBotErrNoCase", 5020) ;		// manque " case "

-	CBotToken::DefineNum( "CBotErrBadNum", 5021) ;		// nombre attendu

-	CBotToken::DefineNum( "CBotErrVoid", 5022) ;		// " void " pas possible ici

-	CBotToken::DefineNum( "CBotErrNoType", 5023) ;		// déclaration de type attendue

-	CBotToken::DefineNum( "CBotErrNoVar", 5024) ;		// nom de variable attendu

-	CBotToken::DefineNum( "CBotErrNoFunc", 5025) ;		// nom de fonction attendu

-	CBotToken::DefineNum( "CBotErrOverParam", 5026) ;	// trop de paramètres

-	CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ;	// cette fonction existe déjà

-	CBotToken::DefineNum( "CBotErrLowParam", 5028) ;	// pas assez de paramètres

-	CBotToken::DefineNum( "CBotErrBadParam", 5029) ;	// mauvais types de paramètres

-	CBotToken::DefineNum( "CBotErrNbParam", 5030) ;		// mauvais nombre de paramètres

-	CBotToken::DefineNum( "CBotErrUndefItem", 5031) ;	// élément n'existe pas dans la classe

-	CBotToken::DefineNum( "CBotErrUndefClass", 5032) ;	// variable n'est pas une classe

-	CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ;	// pas de constructeur approprié

-	CBotToken::DefineNum( "CBotErrRedefClass", 5034) ;	// classe existe déjà

-	CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ;	// " ] " attendu

-	CBotToken::DefineNum( "CBotErrReserved", 5036) ;	// mot réservé (par un DefineNum)

-

-// voici la liste des erreurs pouvant être retournées par le module

-// pour l'exécution

-

-	CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ;		// division par zéro

-	CBotToken::DefineNum( "CBotErrNotInit", 6001) ;		// variable non initialisée

-	CBotToken::DefineNum( "CBotErrBadThrow", 6002) ;	// throw d'une valeur négative

-	CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ;	// fonction n'a pas retourné de résultat

-	CBotToken::DefineNum( "CBotErrNoRun", 6004) ;		// Run() sans fonction active

-	CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ;	// appel d'une fonction qui n'existe plus

-

-	CBotProgram::AddFunction("sizeof", rSizeOf, cSizeOf );

-

-	InitStringFunctions();

-

-	// une fonction juste pour les debug divers

-	CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug);

-	DeleteFile("CbotDebug.txt");

-

-}

-

-void CBotProgram::Free()

-{

-	CBotToken::Free() ; 

-	CBotCall ::Free() ;

-	CBotClass::Free() ;

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+//////////////////////////////////////////////////////////////////////
+// database management of CBoT program
+
+#include "CBot.h"
+#include <stdio.h>
+
+CBotProgram::CBotProgram()
+{
+    m_Prog      = NULL;
+    m_pRun      = NULL;
+    m_pClass    = NULL;
+    m_pStack    = NULL;
+    m_pInstance = NULL;
+
+    m_ErrorCode = 0;
+    m_Ident     = 0;
+    m_bDebugDD  = 0;
+}
+
+CBotProgram::CBotProgram(CBotVar* pInstance)
+{
+    m_Prog      = NULL;
+    m_pRun      = NULL;
+    m_pClass    = NULL;
+    m_pStack    = NULL;
+    m_pInstance = pInstance;
+
+    m_ErrorCode = 0;
+    m_Ident     = 0;
+    m_bDebugDD  = 0;
+}
+
+
+CBotProgram::~CBotProgram()
+{
+//  delete  m_pClass;
+    m_pClass->Purge();
+    m_pClass    = NULL;
+
+    CBotClass::FreeLock(this);
+
+    delete  m_Prog;
+#if STACKMEM
+    m_pStack->Delete();
+#else
+    delete  m_pStack;
+#endif
+}
+
+
+bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions, void* pUser )
+{
+    int         error = 0;
+    Stop();
+
+//  delete      m_pClass;
+    m_pClass->Purge();      // purge the old definitions of classes
+                            // but without destroying the object
+    m_pClass    = NULL;
+    delete      m_Prog;     m_Prog= NULL;
+
+    ListFonctions.SetSize(0);
+    m_ErrorCode = 0;
+
+    if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)
+        pUser = m_pInstance->m_pUserPtr;
+
+    // transforms the program in Tokens
+    CBotToken*  pBaseToken = CBotToken::CompileTokens(program, error);
+    if ( pBaseToken == NULL ) return false;
+
+
+    CBotCStack* pStack      = new CBotCStack(NULL);
+    CBotToken*  p  = pBaseToken->GivNext();                 // skips the first token (separator)
+
+    pStack->SetBotCall(this);                               // defined used routines
+    CBotCall::SetPUser(pUser);
+
+    // first made a quick pass just to take the headers of routines and classes
+    while ( pStack->IsOk() && p != NULL && p->GivType() != 0)
+    {
+        if ( IsOfType(p, ID_SEP) ) continue;                // semicolons lurking
+
+        if ( p->GivType() == ID_CLASS || 
+            ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
+        {
+            CBotClass*  nxt = CBotClass::Compile1(p, pStack);
+            if (m_pClass == NULL ) m_pClass = nxt;
+            else m_pClass->AddNext(nxt);
+        }
+        else
+        {
+            CBotFunction*   next = CBotFunction::Compile1(p, pStack, NULL);
+            if (m_Prog == NULL ) m_Prog = next;
+            else m_Prog->AddNext(next);
+        }
+    }
+    if ( !pStack->IsOk() )
+    {
+        m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); 
+        delete m_Prog;
+        m_Prog = NULL;
+        delete pBaseToken;
+        return false;
+    }
+
+//  CBotFunction*   temp = NULL;
+    CBotFunction*   next = m_Prog;      // rewind the list
+
+    p  = pBaseToken->GivNext();                             // returns to the beginning
+
+    while ( pStack->IsOk() && p != NULL && p->GivType() != 0 )
+    {
+        if ( IsOfType(p, ID_SEP) ) continue;                // semicolons lurking
+
+        if ( p->GivType() == ID_CLASS || 
+            ( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
+        {
+            m_bCompileClass = true;
+            CBotClass::Compile(p, pStack);                  // completes the definition of the class
+        }
+        else
+        {
+            m_bCompileClass = false;
+            CBotFunction::Compile(p, pStack, next);
+            if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/);
+            next->m_pProg = this;                           // keeps pointers to the module
+            next = next->Next();
+        }
+    }
+
+//  delete m_Prog;          // the list of first pass
+//  m_Prog = temp;          // list of the second pass
+
+    if ( !pStack->IsOk() )
+    {
+        m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd); 
+        delete m_Prog;
+        m_Prog = NULL;
+    }
+
+    delete pBaseToken;
+    delete pStack;
+
+    return (m_Prog != NULL);
+}
+
+
+bool CBotProgram::Start(const char* name)
+{
+#if STACKMEM
+    m_pStack->Delete();
+#else
+    delete m_pStack;
+#endif
+    m_pStack = NULL;
+
+    m_pRun = m_Prog;
+    while (m_pRun != NULL)
+    {
+        if ( m_pRun->GivName() == name ) break;
+        m_pRun = m_pRun->m_next;
+    }
+
+    if ( m_pRun == NULL )
+    {
+        m_ErrorCode = TX_NORUN;
+        return false;
+    }
+
+#if STACKMEM
+    m_pStack = CBotStack::FirstStack();
+#else
+    m_pStack = new CBotStack(NULL);                 // creates an execution stack
+#endif
+
+    m_pStack->SetBotCall(this);                     // bases for routines
+
+    return true;                                    // we are ready for Run ()
+}
+
+bool CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet modestart, CBotGet modestop)
+{
+    CBotFunction* p = m_Prog;
+    while (p != NULL)
+    {
+        if ( p->GivName() == name ) break;
+        p = p->m_next;
+    }
+
+    if ( p == NULL ) return false;
+
+    p->GetPosition(start, stop, modestart, modestop);
+    return true;
+}
+
+bool CBotProgram::Run(void* pUser, int timer)
+{
+    bool    ok;
+
+    if (m_pStack == NULL || m_pRun == NULL) goto error;
+
+    m_ErrorCode = 0;
+    if (m_pInstance != NULL && m_pInstance->m_pUserPtr != NULL)
+        pUser = m_pInstance->m_pUserPtr;
+
+    m_pStack->Reset(pUser);                         // empty the possible previous error, and resets the timer
+    if ( timer >= 0 ) m_pStack->SetTimer(timer);
+
+    m_pStack->SetBotCall(this);                     // bases for routines
+
+#if STACKRUN
+    // resumes execution on the top of the stack
+    ok = m_pStack->Execute();
+    if ( ok ) 
+    {
+#ifdef  _DEBUG
+        CBotVar*    ppVar[3];
+        ppVar[0] = CBotVar::Create("aa", CBotTypInt);
+        ppVar[1] = CBotVar::Create("bb", CBotTypInt);
+        ppVar[2] = NULL;
+        ok = m_pRun->Execute(ppVar, m_pStack, m_pInstance);
+#else
+        // returns to normal execution
+        ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
+#endif
+    }
+#else
+    ok = m_pRun->Execute(NULL, m_pStack, m_pInstance);
+#endif
+
+    // completed on a mistake?
+    if (!ok && !m_pStack->IsOk())
+    {
+        m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd);
+#if STACKMEM
+        m_pStack->Delete();
+#else
+        delete m_pStack;
+#endif
+        m_pStack = NULL;
+        return true;                                // execution is finished!
+    }
+
+    if ( ok ) m_pRun = NULL;                        // more function in execution
+    return ok;
+
+error:
+    m_ErrorCode = TX_NORUN;
+    return true;
+}
+
+void CBotProgram::Stop()
+{
+#if STACKMEM
+    m_pStack->Delete();
+#else
+    delete m_pStack;
+#endif
+    m_pStack = NULL;
+    m_pRun = NULL;
+}
+
+
+
+bool CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end)
+{
+    FunctionName = NULL;
+    start = end = 0;
+    if (m_pStack == NULL) return false;
+
+    m_pStack->GetRunPos(FunctionName, start, end);
+    return true;
+}
+
+CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level)
+{
+    FunctionName = NULL;
+    if (m_pStack == NULL) return NULL;
+
+    return m_pStack->GivStackVars(FunctionName, level);
+}
+
+void CBotProgram::SetTimer(int n)
+{
+    CBotStack::SetTimer( n );
+}
+
+int CBotProgram::GivError()
+{
+    return m_ErrorCode;
+}
+
+void CBotProgram::SetIdent(long n)
+{
+    m_Ident = n;
+}
+
+long CBotProgram::GivIdent()
+{
+    return m_Ident;
+}
+
+bool CBotProgram::GetError(int& code, int& start, int& end)
+{
+    code  = m_ErrorCode;
+    start = m_ErrorStart;
+    end   = m_ErrorEnd;
+    return code > 0;
+}
+
+bool CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg)
+{
+    code    = m_ErrorCode;
+    start   = m_ErrorStart;
+    end     = m_ErrorEnd;
+    pProg   = this;
+    return code > 0;
+}
+
+CBotString CBotProgram::GivErrorText(int code)
+{
+    CBotString TextError;
+
+    TextError.LoadString( code );
+    if (TextError.IsEmpty())
+    {
+        char    buf[100];
+        sprintf(buf, "Exception numéro %d.", code);
+        TextError = buf;
+    }
+    return TextError;
+}
+
+
+CBotFunction* CBotProgram::GivFunctions()
+{
+    return  m_Prog;
+}
+
+bool CBotProgram::AddFunction(const char* name, 
+                              bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                              CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
+{
+    // stores pointers to the two functions
+    return CBotCall::AddFunction(name, rExec, rCompile);
+}
+
+
+bool WriteWord(FILE* pf, unsigned short w)
+{
+    size_t  lg;
+
+    lg = fwrite(&w, sizeof( unsigned short ), 1, pf );
+
+    return (lg == 1);     
+}
+
+bool ReadWord(FILE* pf, unsigned short& w)
+{
+    size_t  lg;
+
+    lg = fread(&w, sizeof( unsigned short ), 1, pf );
+
+    return (lg == 1);
+}
+
+bool WriteFloat(FILE* pf, float w)
+{
+    size_t  lg;
+
+    lg = fwrite(&w, sizeof( float ), 1, pf );
+
+    return (lg == 1);     
+}
+
+bool ReadFloat(FILE* pf, float& w)
+{
+    size_t  lg;
+
+    lg = fread(&w, sizeof( float ), 1, pf );
+
+    return (lg == 1);
+}
+
+bool WriteLong(FILE* pf, long w)
+{
+    size_t  lg;
+
+    lg = fwrite(&w, sizeof( long ), 1, pf );
+
+    return (lg == 1);     
+}
+
+bool ReadLong(FILE* pf, long& w)
+{
+    size_t  lg;
+
+    lg = fread(&w, sizeof( long ), 1, pf );
+
+    return (lg == 1);
+}
+
+bool WriteString(FILE* pf, CBotString s)
+{
+    size_t  lg1, lg2;
+
+    lg1 = s.GivLength();
+    if (!WriteWord(pf, lg1)) return false;
+
+    lg2 = fwrite(s, 1, lg1, pf );
+    return (lg1 == lg2);     
+}
+
+bool ReadString(FILE* pf, CBotString& s)
+{
+    unsigned short  w;
+    char    buf[1000];
+    size_t  lg1, lg2;
+
+    if (!ReadWord(pf, w)) return false;
+    lg1 = w;
+    lg2 = fread(buf, 1, lg1, pf );
+    buf[lg2] = 0;
+
+    s = buf;
+    return (lg1 == lg2);
+}
+
+bool WriteType(FILE* pf, CBotTypResult type)
+{
+    int typ = type.GivType();
+    if ( typ == CBotTypIntrinsic ) typ = CBotTypClass;
+    if ( !WriteWord(pf, typ) ) return false;
+    if ( typ == CBotTypClass )
+    {
+        CBotClass* p = type.GivClass();
+        if ( !WriteString(pf, p->GivName()) ) return false;
+    }
+    if ( type.Eq( CBotTypArrayBody ) ||
+         type.Eq( CBotTypArrayPointer ) )
+    {
+        if ( !WriteWord(pf, type.GivLimite()) ) return false;
+        if ( !WriteType(pf, type.GivTypElem()) ) return false;
+    }
+    return true;
+}
+
+bool ReadType(FILE* pf, CBotTypResult& type)
+{
+    unsigned short  w, ww;
+    if ( !ReadWord(pf, w) ) return false;
+    type.SetType(w);
+
+    if ( type.Eq( CBotTypIntrinsic ) )
+    {
+        type = CBotTypResult( w, "point" );
+    }
+
+    if ( type.Eq( CBotTypClass ) )
+    {
+        CBotString  s;
+        if ( !ReadString(pf, s) ) return false;
+        type = CBotTypResult( w, s );
+    }
+
+    if ( type.Eq( CBotTypArrayPointer ) ||
+         type.Eq( CBotTypArrayBody ) )
+    {
+        CBotTypResult   r;
+        if ( !ReadWord(pf, ww) ) return false;
+        if ( !ReadType(pf, r) ) return false;
+        type = CBotTypResult( w, r );
+        type.SetLimite((short)ww);
+    }
+    return true;
+}
+
+
+bool CBotProgram::DefineNum(const char* name, long val)
+{
+    return CBotToken::DefineNum(name, val);
+}
+
+
+bool CBotProgram::SaveState(FILE* pf)
+{
+    if (!WriteWord( pf, CBOTVERSION)) return false;
+
+
+    if ( m_pStack != NULL )
+    {
+        if (!WriteWord( pf, 1)) return false;
+        if (!WriteString( pf, m_pRun->GivName() )) return false;
+        if (!m_pStack->SaveState(pf)) return false;
+    }
+    else 
+    {
+        if (!WriteWord( pf, 0)) return false;
+    }
+    return true;
+}
+
+
+bool CBotProgram::RestoreState(FILE* pf)
+{
+    unsigned short  w;
+    CBotString      s;
+
+    Stop();
+
+    if (!ReadWord( pf, w )) return false;
+    if ( w != CBOTVERSION ) return false;
+
+    if (!ReadWord( pf, w )) return false;
+    if ( w == 0 ) return true;
+
+    if (!ReadString( pf, s )) return false;
+    Start(s);       // point de reprise
+
+#if STACKMEM
+    m_pStack->Delete();
+#else
+    delete m_pStack;
+#endif
+    m_pStack = NULL;
+
+    // retrieves the stack from the memory
+    // uses a NULL pointer (m_pStack) but it's ok like that
+    if (!m_pStack->RestoreState(pf, m_pStack)) return false;
+    m_pStack->SetBotCall(this);                     // bases for routines
+
+    // restored some states in the stack according to the structure
+    m_pRun->RestoreState(NULL, m_pStack, m_pInstance);
+    return true;
+}
+
+int CBotProgram::GivVersion()
+{
+    return  CBOTVERSION;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+CBotCall* CBotCall::m_ListCalls = NULL;
+    
+CBotCall::CBotCall(const char* name, 
+                   bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                   CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
+{
+    m_name       = name;
+    m_rExec      = rExec;
+    m_rComp      = rCompile;
+    m_next       = NULL;
+    m_nFuncIdent = CBotVar::NextUniqNum();
+}
+
+CBotCall::~CBotCall()
+{
+    if (m_next) delete m_next;
+    m_next = NULL;
+}
+
+void CBotCall::Free()
+{
+    delete CBotCall::m_ListCalls;
+}
+
+bool CBotCall::AddFunction(const char* name, 
+                           bool rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser), 
+                           CBotTypResult rCompile (CBotVar* &pVar, void* pUser))
+{
+    CBotCall*   p = m_ListCalls;
+    CBotCall*   pp = NULL;
+
+    if ( p != NULL ) while ( p->m_next != NULL )
+    {
+        if ( p->GivName() == name )
+        {
+            // frees redefined function
+            if ( pp ) pp->m_next = p->m_next;
+            else      m_ListCalls = p->m_next;
+            pp = p;
+            p = p->m_next;
+            pp->m_next = NULL;  // not to destroy the following list
+            delete pp;
+            continue;
+        }
+        pp = p;             // previous pointer
+        p = p->m_next;
+    }
+
+    pp = new CBotCall(name, rExec, rCompile);
+    
+    if (p) p->m_next = pp;
+    else m_ListCalls = pp;
+
+    return true;
+}
+
+
+// transforms the array of pointers to variables
+// in a chained list of variables
+CBotVar* MakeListVars(CBotVar** ppVars, bool bSetVal=false)
+{
+    int     i = 0;
+    CBotVar*    pVar = NULL;
+
+    while( true )
+    {
+        ppVars[i];
+        if ( ppVars[i] == NULL ) break;
+
+        CBotVar*    pp = CBotVar::Create(ppVars[i]);
+        if (bSetVal) pp->Copy(ppVars[i]);
+        else
+            if ( ppVars[i]->GivType() == CBotTypPointer )
+                pp->SetClass( ppVars[i]->GivClass());
+// copy the pointer according to indirections
+        if (pVar == NULL) pVar = pp;
+        else pVar->AddNext(pp);
+        i++;
+    }
+    return pVar;
+}
+
+// is acceptable by a call procedure name
+// and given parameters
+
+CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack* pStack, long& nIdent)
+{
+    nIdent = 0;
+    CBotCall*   pt = m_ListCalls;
+    CBotString  name = p->GivString();
+
+    while ( pt != NULL )
+    {
+        if ( pt->m_name == name )
+        {
+            CBotVar*    pVar = MakeListVars(ppVar);
+            CBotVar*    pVar2 = pVar;
+            CBotTypResult r = pt->m_rComp(pVar2, m_pUser);
+            int ret = r.GivType();
+            
+            // if a class is returned, it is actually a pointer
+            if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer );
+
+            if ( ret > 20 )
+            {
+                if (pVar2) pStack->SetError(ret, p /*pVar2->GivToken()*/ );
+            }
+            delete pVar;
+            nIdent = pt->m_nFuncIdent;
+            return r;
+        }
+        pt = pt->m_next;
+    }
+    return -1;
+}
+
+void* CBotCall::m_pUser = NULL;
+
+void CBotCall::SetPUser(void* pUser)
+{
+    m_pUser = pUser;
+}
+
+bool CBotCall::CheckCall(const char* name)
+{
+    CBotCall* p = m_ListCalls;
+
+    while ( p != NULL )
+    {
+        if ( name == p->GivName() ) return true;
+        p = p->m_next;
+    }
+    return false;
+}
+
+
+
+CBotString CBotCall::GivName()
+{
+    return  m_name;
+}
+
+CBotCall* CBotCall::Next()
+{
+    return  m_next;
+}
+
+
+int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack, CBotTypResult& rettype)
+{
+    CBotCall*   pt = m_ListCalls;
+
+    if ( nIdent ) while ( pt != NULL )
+    {
+        if ( pt->m_nFuncIdent == nIdent )
+        {
+            goto fund;
+        }
+        pt = pt->m_next;
+    }
+
+    pt = m_ListCalls;
+
+    if ( token != NULL )
+    {
+        CBotString name = token->GivString();
+        while ( pt != NULL )
+        {
+            if ( pt->m_name == name )
+            {
+                nIdent = pt->m_nFuncIdent;
+                goto fund;
+            }
+            pt = pt->m_next;
+        }
+    }
+
+    return -1;
+
+fund:
+#if !STACKRUN
+    // lists the parameters depending on the contents of the stack (pStackVar)
+
+    CBotVar*    pVar = MakeListVars(ppVar, true);
+    CBotVar*    pVarToDelete = pVar;
+
+    // creates a variable to the result
+    CBotVar*    pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
+
+    CBotVar*    pRes = pResult;
+    int         Exception = 0;
+    int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser());
+
+    if ( pResult != pRes ) delete pRes; // different result if made
+    delete pVarToDelete;
+
+    if (res == false)
+    {
+        if (Exception!=0)
+        {
+            pStack->SetError(Exception, token);
+        }
+        delete pResult;
+        return false;
+    }
+    pStack->SetVar(pResult);
+
+    if ( rettype.GivType() > 0 && pResult == NULL )
+    {
+        pStack->SetError(TX_NORETVAL, token);
+    }
+    nIdent = pt->m_nFuncIdent;
+    return true;
+
+#else
+
+    CBotStack*  pile = pStack->AddStackEOX(pt);
+    if ( pile == EOX ) return true;
+
+    // lists the parameters depending on the contents of the stack (pStackVar)
+
+    CBotVar*    pVar = MakeListVars(ppVar, true);
+    CBotVar*    pVarToDelete = pVar;
+
+    // creates a variable to the result
+    CBotVar*    pResult = rettype.Eq(0) ? NULL : CBotVar::Create("", rettype);
+
+    pile->SetVar( pVar );
+
+    CBotStack*  pile2 = pile->AddStack();
+    pile2->SetVar( pResult );
+
+    pile->SetError(0, token);           // for the position on error + away
+    return pt->Run( pStack );
+
+#endif
+
+}
+
+#if STACKRUN
+
+bool CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack)
+{
+    CBotCall*   pt = m_ListCalls;
+
+    {
+        CBotString name = token->GivString();
+        while ( pt != NULL )
+        {
+            if ( pt->m_name == name )
+            {
+                nIdent = pt->m_nFuncIdent;
+
+                CBotStack*  pile = pStack->RestoreStackEOX(pt);
+                if ( pile == NULL ) return true;
+
+                CBotStack*  pile2 = pile->RestoreStack();
+                return true;
+            }
+            pt = pt->m_next;
+        }
+    }
+
+    return false;
+}
+
+bool CBotCall::Run(CBotStack* pStack)
+{
+    CBotStack*  pile = pStack->AddStackEOX(this);
+    if ( pile == EOX ) return true;
+    CBotVar*    pVar = pile->GivVar();
+
+    CBotStack*  pile2 = pile->AddStack();
+    CBotVar*    pResult = pile2->GivVar();
+    CBotVar*    pRes = pResult;
+
+    int         Exception = 0;
+    int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser());
+
+    if (res == false)
+    {
+        if (Exception!=0)
+        {
+            pStack->SetError(Exception);
+        }
+        if ( pResult != pRes ) delete pResult;  // different result if made
+        return false;
+    }
+
+    if ( pResult != NULL ) pStack->SetCopyVar( pResult );
+    if ( pResult != pRes ) delete pResult;  // different result if made
+
+    return true;
+}
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+CBotCallMethode::CBotCallMethode(const char* name, 
+                   bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception), 
+                   CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar))
+{
+    m_name       = name;
+    m_rExec      = rExec;
+    m_rComp      = rCompile;
+    m_next       = NULL;
+    m_nFuncIdent = CBotVar::NextUniqNum();
+}
+
+CBotCallMethode::~CBotCallMethode()
+{
+    delete m_next;
+    m_next = NULL;
+}
+
+// is acceptable by a call procedure name
+// and given parameters
+
+CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis, 
+                                           CBotVar** ppVar, CBotCStack* pStack,
+                                           long& nIdent)
+{
+    CBotCallMethode*    pt = this;
+    nIdent = 0;
+
+    while ( pt != NULL )
+    {
+        if ( pt->m_name == name )
+        {
+            CBotVar*    pVar = MakeListVars(ppVar, true);
+            CBotVar*    pVar2 = pVar;
+            CBotTypResult r = pt->m_rComp(pThis, pVar2);
+            int ret = r.GivType();
+            if ( ret > 20 )
+            {
+                if (pVar2) pStack->SetError(ret, pVar2->GivToken());
+            }
+            delete pVar;
+            nIdent = pt->m_nFuncIdent;
+            return r;
+        }
+        pt = pt->m_next;
+    }
+    return CBotTypResult(-1);
+}
+
+
+CBotString CBotCallMethode::GivName()
+{
+    return  m_name;
+}
+
+CBotCallMethode* CBotCallMethode::Next()
+{
+    return  m_next;
+}
+
+void CBotCallMethode::AddNext(CBotCallMethode* pt)
+{
+    CBotCallMethode* p = this;
+    while ( p->m_next != NULL ) p = p->m_next;
+
+    p->m_next = pt;
+}
+
+
+int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pToken)
+{
+    CBotCallMethode*    pt = this;
+
+    // search by the identifier
+
+    if ( nIdent ) while ( pt != NULL )
+    {
+        if ( pt->m_nFuncIdent == nIdent )
+        {
+            // lists the parameters depending on the contents of the stack (pStackVar)
+
+            CBotVar*    pVar = MakeListVars(ppVars, true);
+            CBotVar*    pVarToDelete = pVar;
+
+            // then calls the routine external to the module
+
+            int         Exception = 0;
+            int res = pt->m_rExec(pThis, pVar, pResult, Exception);
+            pStack->SetVar(pResult);
+
+            if (res == false)
+            {
+                if (Exception!=0)
+                {
+//                  pStack->SetError(Exception, pVar->GivToken());
+                    pStack->SetError(Exception, pToken);
+                }
+                delete pVarToDelete;
+                return false;
+            }
+            delete pVarToDelete;
+            return true;
+        }
+        pt = pt->m_next;
+    }
+
+    // search by name
+
+    while ( pt != NULL )
+    {
+        if ( pt->m_name == name )
+        {
+            // lists the parameters depending on the contents of the stack (pStackVar)
+
+            CBotVar*    pVar = MakeListVars(ppVars, true);
+            CBotVar*    pVarToDelete = pVar;
+
+            int         Exception = 0;
+            int res = pt->m_rExec(pThis, pVar, pResult, Exception);
+            pStack->SetVar(pResult);
+
+            if (res == false)
+            {
+                if (Exception!=0)
+                {
+//                  pStack->SetError(Exception, pVar->GivToken());
+                    pStack->SetError(Exception, pToken);
+                }
+                delete pVarToDelete;
+                return false;
+            }
+            delete pVarToDelete;
+            nIdent = pt->m_nFuncIdent;
+            return true;
+        }
+        pt = pt->m_next;
+    }
+
+    return -1;
+}
+
+bool rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    if ( pVar == NULL ) return TX_LOWPARAM;
+
+    int i = 0;
+    pVar = pVar->GivItemList();
+
+    while ( pVar != NULL )
+    {
+        i++; 
+        pVar = pVar->GivNext();
+    }
+
+    pResult->SetValInt(i);
+    return true;
+}
+
+CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
+{
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+    if ( pVar->GivType() != CBotTypArrayPointer )
+                        return CBotTypResult( TX_BADPARAM );
+    return CBotTypResult( CBotTypInt );
+}
+
+
+CBotString CBotProgram::m_DebugVarStr = "";
+
+bool rCBotDebug( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    pResult->SetValString( CBotProgram::m_DebugVarStr );
+
+    return true;
+}
+
+CBotTypResult cCBotDebug( CBotVar* &pVar, void* pUser )
+{
+    // no parameter
+    if ( pVar != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // function returns a result "string"
+    return CBotTypResult( CBotTypString );
+}
+
+
+#include "StringFunctions.cpp"
+
+void CBotProgram::Init()
+{
+    CBotToken::DefineNum( "CBotErrOpenPar", 5000) ;     // missing the opening parenthesis
+    CBotToken::DefineNum( "CBotErrClosePar", 5001) ;    // missing the closing parenthesis
+    CBotToken::DefineNum( "CBotErrNotBoolean", 5002) ;  // expression must be a boolean
+    CBotToken::DefineNum( "CBotErrUndefVar", 5003) ;    // undeclared variable
+    CBotToken::DefineNum( "CBotErrBadLeft", 5004) ;     // impossible assignment (5 = ...)
+    CBotToken::DefineNum( "CBotErrNoTerminator", 5005) ;// semicolon expected
+    CBotToken::DefineNum( "CBotErrCaseOut", 5006) ;     // case outside a switch
+    CBotToken::DefineNum( "CBotErrCloseBlock", 5008) ;  // missing " } "
+    CBotToken::DefineNum( "CBotErrElseWhitoutIf", 5009) ;// else without matching if
+    CBotToken::DefineNum( "CBotErrOpenBlock", 5010) ;   // missing " { "
+    CBotToken::DefineNum( "CBotErrBadType1", 5011) ;    // wrong type for the assignment
+    CBotToken::DefineNum( "CBotErrRedefVar", 5012) ;    // redefinition of the variable
+    CBotToken::DefineNum( "CBotErrBadType2", 5013) ;    // two operands are incompatible
+    CBotToken::DefineNum( "CBotErrUndefCall", 5014) ;   // routine unknown
+    CBotToken::DefineNum( "CBotErrNoDoubleDots", 5015) ;// " : " expected
+    CBotToken::DefineNum( "CBotErrBreakOutside", 5017) ;// break outside of a loop
+    CBotToken::DefineNum( "CBotErrUndefLabel", 5019) ;  // unknown label
+    CBotToken::DefineNum( "CBotErrLabel", 5018) ;       // label can not get here
+    CBotToken::DefineNum( "CBotErrNoCase", 5020) ;      // missing " case "
+    CBotToken::DefineNum( "CBotErrBadNum", 5021) ;      // expected number
+    CBotToken::DefineNum( "CBotErrVoid", 5022) ;        // " void " not possble here
+    CBotToken::DefineNum( "CBotErrNoType", 5023) ;      // type declaration expected
+    CBotToken::DefineNum( "CBotErrNoVar", 5024) ;       // variable name expected
+    CBotToken::DefineNum( "CBotErrNoFunc", 5025) ;      // expected function name
+    CBotToken::DefineNum( "CBotErrOverParam", 5026) ;   // too many parameters
+    CBotToken::DefineNum( "CBotErrRedefFunc", 5027) ;   // this function already exists
+    CBotToken::DefineNum( "CBotErrLowParam", 5028) ;    // not enough parameters
+    CBotToken::DefineNum( "CBotErrBadParam", 5029) ;    // mauvais types de paramètres
+    CBotToken::DefineNum( "CBotErrNbParam", 5030) ;     // wrong number of parameters
+    CBotToken::DefineNum( "CBotErrUndefItem", 5031) ;   // element does not exist in the class
+    CBotToken::DefineNum( "CBotErrUndefClass", 5032) ;  // variable is not a class
+    CBotToken::DefineNum( "CBotErrNoConstruct", 5033) ; // no appropriate constructor
+    CBotToken::DefineNum( "CBotErrRedefClass", 5034) ;  // Class already exists
+    CBotToken::DefineNum( "CBotErrCloseIndex", 5035) ;  // " ] " expected
+    CBotToken::DefineNum( "CBotErrReserved", 5036) ;    // reserved word (for a DefineNum)
+
+// Here are the list of errors that can be returned by the module
+// for the execution
+
+    CBotToken::DefineNum( "CBotErrZeroDiv", 6000) ;     // division by zero
+    CBotToken::DefineNum( "CBotErrNotInit", 6001) ;     // uninitialized variable
+    CBotToken::DefineNum( "CBotErrBadThrow", 6002) ;    // throw a negative value
+    CBotToken::DefineNum( "CBotErrNoRetVal", 6003) ;    // function did not return results
+    CBotToken::DefineNum( "CBotErrNoRun", 6004) ;       // active Run () without a function
+    CBotToken::DefineNum( "CBotErrUndefFunc", 6005) ;   // Calling a function that no longer exists
+
+    CBotProgram::AddFunction("sizeof", rSizeOf, cSizeOf );
+
+    InitStringFunctions();
+
+    // just a function for various debug
+    CBotProgram::AddFunction("CBOTDEBUGDD", rCBotDebug, cCBotDebug);
+    //TODO implement this deletion
+    // DeleteFile("CbotDebug.txt");
+
+}
+
+void CBotProgram::Free()
+{
+    CBotToken::Free() ; 
+    CBotCall ::Free() ;
+    CBotClass::Free() ;
+}
+
diff --git a/src/CBot/CBotStack.cpp b/src/CBot/CBotStack.cpp
index b5aaba0..ddb26c6 100644
--- a/src/CBot/CBotStack.cpp
+++ b/src/CBot/CBotStack.cpp
@@ -1,1475 +1,1471 @@
-// * 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  http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////////

-// gestion de la pile (stack)

-

-#include "CBot.h"

-

-

-#define	ITIMER	100

-

-////////////////////////////////////////////////////////////////////////////

-// gestion de la pile d'exécution

-////////////////////////////////////////////////////////////////////////////

-

-int				CBotStack::m_initimer = ITIMER;		// init la variable statique

-int				CBotStack::m_timer = 0;				// init la variable statique

-CBotVar*		CBotStack::m_retvar = NULL;			// init la variable statique

-int				CBotStack::m_error = 0;				// init la variable statique

-int				CBotStack::m_start = 0;				// init la variable statique

-int				CBotStack::m_end   = 0;				// init la variable statique

-CBotString		CBotStack::m_labelBreak="";			// init la variable statique

-void*			CBotStack::m_pUser = NULL;

-

-#if	STACKMEM

-

-CBotStack* CBotStack::FirstStack()

-{

-	CBotStack*	p;

-

-	long	size = sizeof(CBotStack);

-	size	*= (MAXSTACK+10);

-

-	// demande une tranche mémoire pour la pile

-	p = (CBotStack*)malloc(size);

-

-	// la vide totalement

-	memset(p, 0, size);

-

-	p-> m_bBlock = TRUE;

-	m_timer = m_initimer;				// met le timer au début

-

-	CBotStack* pp = p;

-	pp += MAXSTACK;

-	int i;

-	for ( i = 0 ; i< 10 ; i++ )

-	{

-		pp->m_bOver = TRUE;

-		pp ++;

-	}

-#ifdef	_DEBUG 

-	int	n = 1;

-	pp = p;

-	for ( i = 0 ; i< MAXSTACK+10 ; i++ )

-	{

-		pp->m_index = n++;

-		pp ++;

-	}

-#endif

-

-	m_error = 0;	// évite des blocages car m_error est static

-	return p;

-}

-

-CBotStack::CBotStack(CBotStack* ppapa)

-{

-	// constructeur doit exister, sinon le destructeur n'est jamais appelé !

-	ASM_TRAP();

-}

-

-CBotStack::~CBotStack()

-{

-	ASM_TRAP();	// utiliser	Delete() à la place

-}

-

-void CBotStack::Delete()

-{

-	if ( this == NULL || this == EOX ) return;

-

-	m_next->Delete();

-	m_next2->Delete();

-

-	if (m_prev != NULL)

-	{

-		if ( m_prev->m_next == this )

-			m_prev->m_next = NULL;		// enlève de la chaîne

-

-		if ( m_prev->m_next2 == this )

-			m_prev->m_next2 = NULL;		// enlève de la chaîne

-	}

-

-	delete m_var;

-	delete m_listVar;

-

-	CBotStack*	p = m_prev;

-	BOOL		bOver = m_bOver;

-#ifdef	_DEBUG

-	int			n = m_index;

-#endif

-

-	// efface le bloc libéré

-	memset(this, 0, sizeof(CBotStack));

-	m_bOver	= bOver;

-#ifdef	_DEBUG

-	m_index = n;

-#endif

-

-	if ( p == NULL ) 

-		free( this );

-}

-

-

-// routine optimisée

-CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)

-{

-	if (m_next != NULL) 

-	{

-		return m_next;				// reprise dans une pile existante

-	}

-

-#ifdef	_DEBUG

-	int		n = 0;

-#endif

-	CBotStack*	p = this;

-	do

-	{

-		p ++;

-#ifdef	_DEBUG

-		n ++;

-#endif

-	}

-	while ( p->m_prev != NULL );

-

-	m_next = p;									// chaîne l'élément

-	p->m_bBlock		 = bBlock;

-	p->m_instr		 = instr;

-	p->m_prog		 = m_prog;

-	p->m_step		 = 0;

-    p->m_prev		 = this;

-    p->m_state		 = 0;

-	p->m_call	     = NULL;

-	p->m_bFunc		 = FALSE;

-	return	p;

-}

-

-CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)

-{

-	if (m_next != NULL) 

-	{

-		if ( m_next == EOX )

-		{

-			m_next = NULL;

-			return EOX;

-		}

-		return m_next;				// reprise dans une pile existante

-	}

-	CBotStack*	p = AddStack(NULL, bBlock);

-	p->m_call = instr;

-	p->m_bFunc = 2;	// spécial

-	return	p;

-}

-

-CBotStack* CBotStack::AddStack2(BOOL bBlock)

-{

-	if (m_next2 != NULL) 

-	{

-		m_next2->m_prog = m_prog;		// spécial évite un RestoreStack2

-		return m_next2;					// reprise dans une pile existante

-	}

-

-	CBotStack*	p = this;

-	do

-	{

-		p ++;

-	}

-	while ( p->m_prev != NULL );

-

-	m_next2 = p;								// chaîne l'élément

-	p->m_prev = this;

-	p->m_bBlock = bBlock;

-	p->m_prog = m_prog;

-	p->m_step = 0;

-	return	p;

-}

-

-BOOL CBotStack::GivBlock()

-{

-	return	m_bBlock;

-}

-

-BOOL CBotStack::Return(CBotStack* pfils)

-{

-	if ( pfils == this ) return TRUE;	// spécial

-

-	if (m_var != NULL) delete m_var;			// valeur remplacée ?

-	m_var = pfils->m_var;						// résultat transmis

-	pfils->m_var = NULL;						// ne pas détruire la variable

-

-	m_next->Delete();m_next = NULL;				// libère la pile au dessus

-	m_next2->Delete();m_next2 = NULL;			// aussi la seconde pile (catch)

-

-	return (m_error == 0);						// interrompu si erreur

-}

-

-BOOL CBotStack::ReturnKeep(CBotStack* pfils)

-{

-	if ( pfils == this ) return TRUE;	// spécial

-

-	if (m_var != NULL) delete m_var;			// valeur remplacée ?

-	m_var = pfils->m_var;						// résultat transmis

-	pfils->m_var = NULL;						// ne pas détruire la variable

-

-	return (m_error == 0);						// interrompu si erreur

-}

-

-BOOL CBotStack::StackOver()

-{

-	if (!m_bOver) return FALSE;

-	m_error = TX_STACKOVER;

-	return TRUE;

-}

-

-#else

-

-CBotStack::CBotStack(CBotStack* ppapa)

-{

-    m_next  = NULL;

-    m_next2 = NULL;

-    m_prev  = ppapa;

-

-	m_bBlock = (ppapa == NULL) ? TRUE : FALSE;

-

-    m_state = 0;

-	m_step = 1;

-

-	if (ppapa == NULL) m_timer = m_initimer;				// met le timer au début

-

-	m_listVar = NULL;

-	m_bDontDelete = FALSE; 

-	

-	m_var	  = NULL;

-	m_prog	  = NULL;

-	m_instr	  = NULL;

-	m_call	  = NULL;

-	m_bFunc	  = FALSE;

-}

-

-// destructeur

-CBotStack::~CBotStack()

-{

-	if ( m_next != EOX) delete m_next;

-	delete m_next2;

-	if (m_prev != NULL && m_prev->m_next == this )

-			m_prev->m_next = NULL;		// enlève de la chaîne

-

-	delete m_var;

-	if ( !m_bDontDelete ) delete m_listVar;

-}

-

-// routine à optimiser

-CBotStack* CBotStack::AddStack(CBotInstr* instr, BOOL bBlock)

-{

-	if (m_next != NULL) 

-	{

-		return m_next;				// reprise dans une pile existante

-	}

-	CBotStack*	p = new CBotStack(this);

-	m_next = p;									// chaîne l'élément

-	p->m_bBlock = bBlock;

-	p->m_instr = instr;

-	p->m_prog = m_prog;

-	p->m_step = 0;

-	return	p;

-}

-

-CBotStack* CBotStack::AddStackEOX(CBotCall* instr, BOOL bBlock)

-{

-	if (m_next != NULL) 

-	{

-		if ( m_next == EOX )

-		{

-			m_next = NULL;

-			return EOX;

-		}

-		return m_next;				// reprise dans une pile existante

-	}

-	CBotStack*	p = new CBotStack(this);

-	m_next = p;									// chaîne l'élément

-	p->m_bBlock = bBlock;

-	p->m_call = instr;

-	p->m_prog = m_prog;

-	p->m_step = 0;

-	p->m_bFunc = 2;	// spécial

-	return	p;

-}

-

-CBotStack* CBotStack::AddStack2(BOOL bBlock)

-{

-	if (m_next2 != NULL) 

-	{

-		m_next2->m_prog = m_prog;		// spécial évite un RestoreStack2

-		return m_next2;					// reprise dans une pile existante

-	}

-

-	CBotStack*	p = new CBotStack(this);

-	m_next2 = p;								// chaîne l'élément

-	p->m_bBlock = bBlock;

-	p->m_prog = m_prog;

-	p->m_step = 0;

-

-	return	p;

-}

-

-BOOL CBotStack::Return(CBotStack* pfils)

-{

-	if ( pfils == this ) return TRUE;	// spécial

-

-	if (m_var != NULL) delete m_var;			// valeur remplacée ?

-	m_var = pfils->m_var;						// résultat transmis

-	pfils->m_var = NULL;						// ne pas détruite la variable

-

-	if ( m_next != EOX ) delete m_next;			// libère la pile au dessus

-	delete m_next2;m_next2 = NULL;				// aussi la seconde pile (catch)

-

-	return (m_error == 0);						// interrompu si erreur

-}

-

-BOOL CBotStack::StackOver()

-{

-	return FALSE;			// pas de test de débordement dans cette version

-}

-

-#endif

-

-void CBotStack::Reset(void* pUser)

-{

-	m_timer = m_initimer;		// remet le timer

-	m_error	= 0;

-//	m_start = 0;

-//	m_end	= 0;

-	m_labelBreak.Empty();

-	m_pUser = pUser;

-}

-

-

-

-

-CBotStack* CBotStack::RestoreStack(CBotInstr* instr)

-{

-	if (m_next != NULL) 

-	{

-		m_next->m_instr = instr;	// réinit (si reprise après restitution)

-		m_next->m_prog = m_prog;

-		return m_next;				// reprise dans une pile existante

-	}

-	return	NULL;

-}

-

-CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr)

-{

-	CBotStack*	 p = RestoreStack();

-	p->m_call = instr;

-	return p;

-}

-

-

-

-// routine pour l'exécution pas à pas

-BOOL CBotStack::IfStep()

-{

-	if ( m_initimer > 0 || m_step++ > 0 ) return FALSE;

-	return TRUE;

-}

-

-

-BOOL CBotStack::BreakReturn(CBotStack* pfils, const char* name)

-{

-	if ( m_error>=0 ) return FALSE;				// sortie normale

-	if ( m_error==-3 ) return FALSE;			// sortie normale (return en cours)

-

-	if (!m_labelBreak.IsEmpty() && (name[0] == 0 || m_labelBreak != name))

-		return FALSE;							// c'est pas pour moi

-

-	m_error = 0;

-	m_labelBreak.Empty();

-	return Return(pfils);

-}

-

-BOOL CBotStack::IfContinue(int state, const char* name)

-{

-	if ( m_error != -2 ) return FALSE;

-

-	if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name))

-		return FALSE;							// c'est pas pour moi

-

-	m_state = state;							// où reprendre ?

-	m_error = 0;

-	m_labelBreak.Empty();

-	if ( m_next != EOX ) m_next->Delete();			// purge la pile au dessus

-	return TRUE;

-}

-

-void CBotStack::SetBreak(int val, const char* name)

-{

-	m_error = -val;								// réagit comme une Exception

-	m_labelBreak = name;

-	if (val == 3)	// pour un return

-	{

-		m_retvar = m_var;

-		m_var = NULL;

-	}

-}

-

-// remet sur la pile la valeur calculée par le dernier CBotReturn

-

-BOOL CBotStack::GivRetVar(BOOL bRet)

-{

-	if (m_error == -3)

-	{

-		if ( m_var ) delete m_var;

-		m_var		= m_retvar;

-		m_retvar	= NULL;

-		m_error		= 0;

-		return		TRUE;

-	}

-	return bRet;						// interrompu par autre chose que return

-}

-

-int CBotStack::GivError(int& start, int& end)

-{

-	start = m_start;

-	end	  = m_end;

-	return m_error;

-}

-

-

-// type d'instruction sur la pile

-int CBotStack::GivType(int mode)

-{

-	if (m_var == NULL) return -1;

-	return m_var->GivType(mode);

-}

-

-// type d'instruction sur la pile

-CBotTypResult CBotStack::GivTypResult(int mode)

-{

-	if (m_var == NULL) return -1;

-	return m_var->GivTypResult(mode);

-}

-

-// type d'instruction sur la pile

-void CBotStack::SetType(CBotTypResult& type)

-{

-	if (m_var == NULL) return;

-	m_var->SetType( type );

-}

-

-

-// trouve une variable par son token

-// ce peut être une variable composée avec un point

-CBotVar* CBotStack::FindVar(CBotToken* &pToken, BOOL bUpdate, BOOL bModif)

-{

-	CBotStack*	p = this;

-	CBotString	name = pToken->GivString();

-

-	while (p != NULL)

-	{

-		CBotVar*	pp = p->m_listVar;

-		while ( pp != NULL)

-		{

-			if (pp->GivName() == name)

-			{

-				if ( bUpdate ) 

-					pp->Maj(m_pUser, FALSE);

-

-				return pp;

-			}

-			pp = pp->m_next;

-		}

-		p = p->m_prev;

-	}

-	return NULL;

-}

-

-CBotVar* CBotStack::FindVar(const char* name)

-{

-	CBotStack*	p = this;

-	while (p != NULL)

-	{

-		CBotVar*	pp = p->m_listVar;

-		while ( pp != NULL)

-		{

-			if (pp->GivName() == name)

-			{

-				return pp;

-			}

-			pp = pp->m_next;

-		}

-		p = p->m_prev;

-	}

-	return NULL;

-}

-

-// retrouve une variable sur la pile selon son numéro d'identification

-// ce qui va plus vite que de comparer les noms.

-

-CBotVar* CBotStack::FindVar(long ident, BOOL bUpdate, BOOL bModif)

-{

-	CBotStack*	p = this;

-	while (p != NULL)

-	{

-		CBotVar*	pp = p->m_listVar;

-		while ( pp != NULL)

-		{

-			if (pp->GivUniqNum() == ident)

-			{

-				if ( bUpdate ) 

-					pp->Maj(m_pUser, FALSE);

-

-				return pp;

-			}

-			pp = pp->m_next;

-		}

-		p = p->m_prev;

-	}

-	return NULL;

-}

-

-

-CBotVar* CBotStack::FindVar(CBotToken& Token, BOOL bUpdate, BOOL bModif)

-{

-	CBotToken*	pt = &Token;

-	return FindVar(pt, bUpdate, bModif);

-}

-

-

-CBotVar* CBotStack::CopyVar(CBotToken& Token, BOOL bUpdate)

-{

-	CBotVar*	pVar = FindVar( Token, bUpdate );

-

-	if ( pVar == NULL) return NULL;

-

-	CBotVar*	pCopy = CBotVar::Create(pVar);

-	pCopy->Copy(pVar);

-	return	pCopy;

-}

-

- 

-BOOL CBotStack::SetState(int n, int limite)

-{

-    m_state = n;

-

-	m_timer--;									// décompte les opérations

-	return ( m_timer > limite );					// interrompu si timer passé

-}

-

-BOOL CBotStack::IncState(int limite)

-{

-	m_state++;

-

-	m_timer--;									// décompte les opérations

-	return ( m_timer > limite );					// interrompu si timer passé

-}

-

-

-void CBotStack::SetError(int n, CBotToken* token)

-{

-	if ( n!= 0 && m_error != 0) return;	// ne change pas une erreur déjà existante

-	m_error = n;

-	if (token != NULL)

-	{

-		m_start = token->GivStart();

-		m_end   = token->GivEnd();

-	}

-}

-

-void CBotStack::ResetError(int n, int start, int end)

-{

-	m_error = n;

-	m_start	= start;

-	m_end	= end;

-}

-

-void CBotStack::SetPosError(CBotToken* token)

-{

-	m_start = token->GivStart();

-	m_end   = token->GivEnd();

-}

-

-void CBotStack::SetTimer(int n)

-{

-	m_initimer = n;

-}

-

-BOOL CBotStack::Execute()

-{

-	CBotCall*		instr = NULL;						// instruction la plus élevée

-	CBotStack*		pile;

-

-	CBotStack*		p = this;

-

-	while (p != NULL)

-	{

-		if ( p->m_next2 != NULL ) break;

-		if ( p->m_call != NULL ) 

-		{

-			instr = p->m_call;

-			pile  = p->m_prev ;

-		}

-		p = p->m_next;

-	}

-

-	if ( instr == NULL ) return TRUE;				// exécution normale demandée

-

-	if (!instr->Run(pile)) return FALSE;			// exécution à partir de là

-

-#if	STACKMEM

-	pile->m_next->Delete();

-#else

-	delete pile->m_next;

-#endif

-

-	pile->m_next = EOX;			// spécial pour reprise

-	return TRUE;

-}

-

-// met sur le stack le pointeur à une variable

-void CBotStack::SetVar( CBotVar* var )

-{

-	if (m_var) delete m_var;	// remplacement d'une variable

-	m_var = var;

-}

-

-// met sur le stack une copie d'une variable

-void CBotStack::SetCopyVar( CBotVar* var )

-{

-	if (m_var) delete m_var;	// remplacement d'une variable

-

-	m_var = CBotVar::Create("", var->GivTypResult(2));

-	m_var->Copy( var );

-}

-

-CBotVar* CBotStack::GivVar()

-{

-	return m_var;

-}

-

-CBotVar* CBotStack::GivPtVar()

-{

-	CBotVar*	p = m_var;

-	m_var = NULL;				// ne sera pas détruit donc

-	return p;

-}

-

-CBotVar* CBotStack::GivCopyVar()

-{

-	if (m_var == NULL) return NULL;

-	CBotVar*	v = CBotVar::Create("", m_var->GivType());

-	v->Copy( m_var );

-	return v;

-}

-

-long CBotStack::GivVal()

-{

-	if (m_var == NULL) return 0;

-	return m_var->GivValInt();

-}

-

-

-

-

-void CBotStack::AddVar(CBotVar* pVar)

-{

-	CBotStack*	p = this;

-

-	// revient sur l'élement père

-	while (p != NULL && p->m_bBlock == 0) p = p->m_prev;

-

-	if ( p == NULL ) return;

-	

-///	p->m_bDontDelete = bDontDelete;

-

-	CBotVar**	pp = &p->m_listVar;

-	while ( *pp != NULL ) pp = &(*pp)->m_next;

-

-	*pp = pVar;					// ajoute à la suite

-

-#ifdef	_DEBUG

-	if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();

-#endif

-}

-

-/*void CBotStack::RestoreVar(CBotVar* pVar)

-{

-	if ( !m_bDontDelete ) __asm int 3;

-	delete	m_listVar;

-	m_listVar = pVar;		// remplace directement

-}*/

-

-void CBotStack::SetBotCall(CBotProgram* p)

-{

-	m_prog  = p;

-	m_bFunc = TRUE;

-}

-

-CBotProgram*  CBotStack::GivBotCall(BOOL bFirst)

-{

-	if ( ! bFirst )	return m_prog;

-	CBotStack*	p = this;

-	while ( p->m_prev != NULL ) p = p->m_prev;

-	return p->m_prog;

-}

-

-void* CBotStack::GivPUser()

-{

-	return m_pUser;

-}

-

-

-BOOL CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype)

-{

-	CBotTypResult		res;

-

-	// cherche d'abord selon l'identificateur

-

-	res = CBotCall::DoCall(nIdent, NULL, ppVar, this, rettype );

-	if (res.GivType() >= 0) return res.GivType();

-

-	res = m_prog->GivFunctions()->DoCall(nIdent, NULL, ppVar, this, token );

-	if (res.GivType() >= 0) return res.GivType();

-

-	// si pas trouvé (recompilé ?) cherche selon le nom

-

-	nIdent = 0;

-	res = CBotCall::DoCall(nIdent, token, ppVar, this, rettype );

-	if (res.GivType() >= 0) return res.GivType();

-

-	res = m_prog->GivFunctions()->DoCall(nIdent, token->GivString(), ppVar, this, token );

-	if (res.GivType() >= 0) return res.GivType();

-

-	SetError(TX_NOCALL, token);

-	return TRUE;

-}

-

-void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)

-{

-	if ( m_next == NULL ) return;

-

-	if ( !CBotCall::RestoreCall(nIdent, token, ppVar, this) )

-		m_prog->GivFunctions()->RestoreCall(nIdent, token->GivString(), ppVar, this );

-}

-

-

-BOOL SaveVar(FILE* pf, CBotVar* pVar)

-{

-	while ( TRUE )

-	{

-		if ( pVar == NULL )

-		{

-			return WriteWord(pf, 0);							// met un terminateur

-		}

-

-		if ( !pVar->Save0State(pf)) return FALSE;				// entête commune

-		if ( !pVar->Save1State(pf) ) return FALSE;				// sauve selon la classe fille

-

-		pVar = pVar->GivNext();

-	}

-}

-

-void CBotStack::GetRunPos(const char* &FunctionName, int &start, int &end)

-{

-	CBotProgram*	prog = m_prog;						// programme courrant

-

-	CBotInstr*		funct = NULL;						// fonction trouvée

-	CBotInstr*		instr = NULL;						// instruction la plus élevée

-

-	CBotStack*		p = this;

-

-	while (p->m_next != NULL)

-	{

-		if ( p->m_instr != NULL ) instr = p->m_instr;

-		if ( p->m_bFunc == 1 ) funct = p->m_instr;

-		if ( p->m_next->m_prog != prog ) break ; 

-

-		if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;

-		else										p = p->m_next;

-	}

-

-	if ( p->m_instr != NULL ) instr = p->m_instr;

-	if ( p->m_bFunc == 1 ) funct = p->m_instr;

-

-	if ( funct == NULL ) return;

-

-	CBotToken* t = funct->GivToken();

-	FunctionName = t->GivString();

-

-//	if ( p->m_instr != NULL ) instr = p->m_instr;

-

-	t = instr->GivToken();

-	start = t->GivStart();

-	end	  = t->GivEnd();

-}

-

-CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)

-{

-	CBotProgram*	prog = m_prog;						// programme courrant

-	FunctionName	= NULL;

-

-	// remonte la pile dans le module courant

-	CBotStack*		p = this;

-

-	while (p->m_next != NULL)

-	{

-		if ( p->m_next->m_prog != prog ) break ; 

-

-		if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;

-		else										p = p->m_next;

-	}

-

-

-	// descend sur les éléments de block

-	while ( p != NULL && !p->m_bBlock )	p = p->m_prev;

-

-	while ( p != NULL && level++ < 0 )

-	{

-		p = p->m_prev;

-		while ( p != NULL && !p->m_bBlock )	p = p->m_prev;

-	}

-

-	if ( p == NULL ) return NULL;

-

-	// recherche le nom de la fonction courante

-	CBotStack* pp = p;

-	while ( pp != NULL )

-	{

-		if ( pp->m_bFunc == 1 ) break;

-		pp = pp->m_prev;

-	}

-

-	if ( pp == NULL || pp->m_instr == NULL ) return NULL;

-

-	CBotToken* t = pp->m_instr->GivToken();

-	FunctionName = t->GivString();

-	

-	return p->m_listVar;

-}

-

-BOOL CBotStack::SaveState(FILE* pf)

-{

-	if ( this == NULL )									// fin de l'arbre ?

-	{

-		return WriteWord(pf, 0);						// met un terminateur

-	}

-

-	if ( m_next2 != NULL )

-	{

-		if (!WriteWord(pf, 2)) return FALSE;				// une marque de poursuite

-		if (!m_next2->SaveState(pf)) return FALSE;

-	}

-	else

-	{

-		if (!WriteWord(pf, 1)) return FALSE;				// une marque de poursuite

-	}

-	if (!WriteWord(pf, m_bBlock)) return FALSE;			// est-ce un bloc local

-	if (!WriteWord(pf, m_state)) return FALSE;			// dans quel état

-	if (!WriteWord(pf, 0)) return FALSE;				// par compatibilité m_bDontDelete

-	if (!WriteWord(pf, m_step)) return FALSE;			// dans quel état

-	

-	

-	if (!SaveVar(pf, m_var)) return FALSE;			// le résultat courant

-	if (!SaveVar(pf, m_listVar)) return FALSE;		// les variables locales

-

-	return m_next->SaveState(pf);						// enregistre la suite

-}

-

-

-BOOL CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)

-{

-	WORD	w;

-

-	pStack = NULL;

-	if (!ReadWord(pf, w)) return FALSE;

-	if ( w == 0 ) return TRUE;

-

-#if	STACKMEM

-	if ( this == NULL ) pStack = FirstStack();

-	else pStack = AddStack();

-#else

-	pStack = new CBotStack(this);

-#endif

-

-	if ( w == 2 )

-	{

-		if (!pStack->RestoreState(pf, pStack->m_next2)) return FALSE;

-	}

-

-	if (!ReadWord(pf, w)) return FALSE;			// est-ce un bloc local

-	pStack->m_bBlock = w;

-

-	if (!ReadWord(pf, w)) return FALSE;			// dans quel état j'ère ?

-	pStack->SetState((short)w);					// dans le bon état

-

-	if (!ReadWord(pf, w)) return FALSE;			// dont delete ?

-												// plus utilisé

-

-	if (!ReadWord(pf, w)) return FALSE;			// pas à pas

-	pStack->m_step = w;

-

-	if (!CBotVar::RestoreState(pf, pStack->m_var)) return FALSE;	// la variable temp

-	if (!CBotVar::RestoreState(pf, pStack->m_listVar)) return FALSE;// les variables locales

-

-	return pStack->RestoreState(pf, pStack->m_next);

-}

-

-

-BOOL CBotVar::Save0State(FILE* pf)

-{	

-	if (!WriteWord(pf, 100+m_mPrivate))return FALSE;		// variable privée ?

-	if (!WriteWord(pf, m_bStatic))return FALSE;				// variable static ?

-	if (!WriteWord(pf, m_type.GivType()))return FALSE;		// enregiste le type (toujours non nul)

-	if (!WriteWord(pf, m_binit))return FALSE;				// variable définie ?

-	return WriteString(pf, m_token->GivString());			// et le nom de la variable

-}

-

-BOOL CBotVarInt::Save0State(FILE* pf)

-{	

-	if ( !m_defnum.IsEmpty() )

-	{

-		if(!WriteWord(pf, 200 )) return FALSE;			// marqueur spécial

-		if(!WriteString(pf, m_defnum)) return FALSE;	// nom de la valeur

-	}

-

-	return CBotVar::Save0State(pf);

-}

-

-BOOL CBotVarInt::Save1State(FILE* pf)

-{

-	return WriteWord(pf, m_val);							// la valeur de la variable

-}

-

-BOOL CBotVarBoolean::Save1State(FILE* pf)

-{

-	return WriteWord(pf, m_val);							// la valeur de la variable

-}

-

-BOOL CBotVarFloat::Save1State(FILE* pf)

-{

-	return WriteFloat(pf, m_val);							// la valeur de la variable

-}

-

-BOOL CBotVarString::Save1State(FILE* pf)

-{

-	return WriteString(pf, m_val);							// la valeur de la variable

-}

-

-

-

-BOOL CBotVarClass::Save1State(FILE* pf)

-{

-	if ( !WriteType(pf, m_type) ) return FALSE;

-	if ( !WriteLong(pf, m_ItemIdent) ) return FALSE;

-

-	return SaveVar(pf, m_pVar);								// contenu de l'objet

-}

-

-BOOL CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)

-{

-	WORD		w, wi, prv, st;

-	float		ww;

-	CBotString	name, s;

-

-	delete pVar;

-

-				pVar	= NULL;

-	CBotVar*	pNew    = NULL;

-	CBotVar*	pPrev	= NULL;

-

-	while ( TRUE )			// recupère toute une liste

-	{

-		if (!ReadWord(pf, w)) return FALSE;						// privé ou type ?

-		if ( w == 0 ) return TRUE;

-

-		CBotString defnum;

-		if ( w == 200 )

-		{

-			if (!ReadString(pf, defnum)) return FALSE;			// nombre avec un identifiant

-			if (!ReadWord(pf, w)) return FALSE;					// type

-		}

-

-		prv = 100; st = 0;

-		if ( w >= 100 )

-		{

-			prv = w;

-			if (!ReadWord(pf, st)) return FALSE;				// statique

-			if (!ReadWord(pf, w)) return FALSE;					// type

-		}

-

-		if ( w == CBotTypClass ) w = CBotTypIntrinsic;			// forcément intrinsèque

-

-		if (!ReadWord(pf, wi)) return FALSE;					// init ?

-

-		if (!ReadString(pf, name)) return FALSE;				// nom de la variable

-

-		CBotToken token(name, CBotString());

-

-		switch (w)

-		{

-		case CBotTypInt:

-		case CBotTypBoolean:

-			pNew = CBotVar::Create(&token, w);						// crée une variable

-			if (!ReadWord(pf, w)) return FALSE;

-			pNew->SetValInt((short)w, defnum);

-			break;

-		case CBotTypFloat:

-			pNew = CBotVar::Create(&token, w);						// crée une variable

-			if (!ReadFloat(pf, ww)) return FALSE;

-			pNew->SetValFloat(ww);

-			break;

-		case CBotTypString:

-			pNew = CBotVar::Create(&token, w);						// crée une variable

-			if (!ReadString(pf, s)) return FALSE;

-			pNew->SetValString(s);

-			break;

-

-		// restitue un objet intrinsic ou un élément d'un array

-		case CBotTypIntrinsic:

-		case CBotTypArrayBody:

-			{

-				CBotTypResult	r;

-				long			id;

-				if (!ReadType(pf, r))  return FALSE;				// type complet

-				if (!ReadLong(pf, id) ) return FALSE;

-

-//				if (!ReadString(pf, s)) return FALSE;

-				{

-					CBotVar* p = NULL;

-					if ( id ) p = CBotVarClass::Find(id) ;

-

-					pNew = new CBotVarClass(&token, r);				// crée directement une instance

-																	// attention cptuse = 0

-					if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return FALSE;

-					pNew->SetIdent(id);

-

-					if ( p != NULL )

-					{

-						delete pNew;

-						pNew = p;			// reprend l'élément connu

-					}

-				}

-			}

-			break;

-

-		case CBotTypPointer:

-		case CBotTypNullPointer:

-			if (!ReadString(pf, s)) return FALSE;

-			{

-				pNew = CBotVar::Create(&token, CBotTypResult(w, s));// crée une variable

-				CBotVarClass* p = NULL;

-				long id;

-				ReadLong(pf, id);

-//				if ( id ) p = CBotVarClass::Find(id);		// retrouve l'instance ( fait par RestoreInstance )

-

-				// restitue une copie de l'instance d'origine

-				CBotVar* pInstance = NULL;

-				if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE;

-				((CBotVarPointer*)pNew)->SetPointer( pInstance );			// et pointe dessus

-

-//				if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p );	// plutôt celui-ci !

-

-			}

-			break;

-

-		case CBotTypArrayPointer:

-			{

-				CBotTypResult	r;

-				if (!ReadType(pf, r))  return FALSE;

-

-				pNew = CBotVar::Create(&token, r);						// crée une variable

-

-				// restitue une copie de l'instance d'origine

-				CBotVar* pInstance = NULL;

-				if ( !CBotVar::RestoreState( pf, pInstance ) ) return FALSE;

-				((CBotVarPointer*)pNew)->SetPointer( pInstance );			// et pointe dessus

-			}

-			break;

-		default:

-			ASM_TRAP();

-		}

-

-		if ( pPrev != NULL ) pPrev->m_next = pNew;

-		if ( pVar == NULL  ) pVar = pNew;

-

-		pNew->m_binit = wi;		//		pNew->SetInit(wi);

-		pNew->SetStatic(st);

-		pNew->SetPrivate(prv-100);

-		pPrev = pNew;

-	}

-	return TRUE;

-}

-

-

-

-

-////////////////////////////////////////////////////////////////////////////

-// gestion de la pile à la compilation

-////////////////////////////////////////////////////////////////////////////

-

-CBotProgram*	CBotCStack::m_prog    = NULL;			// init la variable statique

-int				CBotCStack::m_error   = 0;

-int				CBotCStack::m_end	  = 0;

-CBotTypResult	CBotCStack::m_retTyp  = CBotTypResult(0);

-//CBotToken*		CBotCStack::m_retClass= NULL;

-

-

-CBotCStack::CBotCStack(CBotCStack* ppapa)

-{

-    m_next = NULL;

-    m_prev = ppapa;

-

-	if (ppapa == NULL)

-	{

-		m_error = 0;

-		m_start = 0;

-		m_end	= 0;

-		m_bBlock = TRUE;

-	}

-	else

-	{

-		m_start = ppapa->m_start;

-		m_bBlock = FALSE;

-	}

-

-	m_listVar = NULL;

-	m_var	  = NULL;

-}

-

-// destructeur

-CBotCStack::~CBotCStack()

-{

-	if (m_next != NULL) delete m_next;

-	if (m_prev != NULL) m_prev->m_next = NULL;		// enlève de la chaîne

-

-	delete m_var;

-	delete m_listVar;

-}

-

-// utilisé uniquement à la compilation

-CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, BOOL bBlock)

-{

-	if (m_next != NULL) return m_next;			// reprise dans une pile existante

-

-	CBotCStack*	p = new CBotCStack(this);

-	m_next = p;									// chaîne l'élément

-	p->m_bBlock = bBlock;

-

-	if (pToken != NULL) p->SetStartError(pToken->GivStart());

-

-	return	p;

-}

-

-

-CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils)

-{		

-	if ( pfils == this ) return inst;

-

-	if (m_var != NULL) delete m_var;			// valeur remplacée ?

-	m_var = pfils->m_var;						// résultat transmis

-	pfils->m_var = NULL;						// ne pas détruire la variable

-

-	if (m_error)

-	{

-		m_start = pfils->m_start;				// récupère la position de l'erreur

-		m_end	= pfils->m_end;

-	}

-

-	delete pfils;

-	return inst;

-}

-

-CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)

-{		

-	if (m_var != NULL) delete m_var;			// valeur remplacée ?

-	m_var = pfils->m_var;						// résultat transmis

-	pfils->m_var = NULL;						// ne pas détruire la variable

-

-	if (m_error)

-	{

-		m_start = pfils->m_start;				// récupère la position de l'erreur

-		m_end	= pfils->m_end;

-	}

-

-	delete pfils;

-	return inst;

-}

-

-int CBotCStack::GivError(int& start, int& end)

-{

-	start = m_start;

-	end	  = m_end;

-	return m_error;

-}

-

-int CBotCStack::GivError()

-{

-	return m_error;

-}

-

-// type d'instruction sur la pile

-CBotTypResult CBotCStack::GivTypResult(int mode)

-{

-	if (m_var == NULL)

-		return CBotTypResult(99);

-	return	m_var->GivTypResult(mode);

-}

-

-// type d'instruction sur la pile

-int CBotCStack::GivType(int mode)

-{

-	if (m_var == NULL)

-		return 99;

-	return	m_var->GivType(mode);

-}

-

-// pointeur sur la pile est de quelle classe ?

-CBotClass* CBotCStack::GivClass()

-{

-	if ( m_var == NULL )

-		return NULL;

-	if ( m_var->GivType(1) != CBotTypPointer ) return NULL;

-

-	return m_var->GivClass();

-}

-

-// type d'instruction sur la pile

-void CBotCStack::SetType(CBotTypResult& type)

-{

-	if (m_var == NULL) return;

-	m_var->SetType( type );

-}

-

-// cherche une variable sur la pile

-// le token peut être une suite de TokenTypVar (objet d'une classe)

-// ou un pointeur dans le source

-

-CBotVar* CBotCStack::FindVar(CBotToken* &pToken)

-{

-	CBotCStack*	p = this;

-	CBotString	name = pToken->GivString();

-

-	while (p != NULL)

-	{

-		CBotVar*	pp = p->m_listVar;

-		while ( pp != NULL)

-		{

-			if (name == pp->GivName())

-			{

-				return pp;

-			}

-			pp = pp->m_next;

-		}

-		p = p->m_prev;

-	}

-	return NULL;

-}

-

-CBotVar* CBotCStack::FindVar(CBotToken& Token)

-{

-	CBotToken*	pt = &Token;

-	return FindVar(pt);

-}

-

-CBotVar* CBotCStack::CopyVar(CBotToken& Token)

-{

-	CBotVar*	pVar = FindVar( Token );

-

-	if ( pVar == NULL) return NULL;

-

-	CBotVar*	pCopy = CBotVar::Create( "", pVar->GivType() );

-	pCopy->Copy(pVar);

-	return	pCopy;

-}

-

-BOOL CBotCStack::IsOk()

-{

-    return (m_error == 0);

-}

-

- 

-void CBotCStack::SetStartError( int pos )

-{

-	if ( m_error != 0) return;			// ne change pas une erreur déjà existante

-	m_start = pos;

-}

-

-void CBotCStack::SetError(int n, int pos)

-{

-	if ( n!= 0 && m_error != 0) return;	// ne change pas une erreur déjà existante

-	m_error = n;

-	m_end	= pos;

-}

-

-void CBotCStack::SetError(int n, CBotToken* p)

-{

-	if (m_error) return;	// ne change pas une erreur déjà existante

-	m_error = n;

-	m_start	= p->GivStart();

-	m_end	= p->GivEnd();

-}

-

-void CBotCStack::ResetError(int n, int start, int end)

-{

-	m_error = n;

-	m_start	= start;

-	m_end	= end;

-}

-

-BOOL CBotCStack::NextToken(CBotToken* &p)

-{

-	CBotToken*	pp = p;

-

-	p = p->GivNext();

-	if (p!=NULL) return TRUE;

-

-	SetError(TX_ENDOF, pp->GivEnd());

-	return FALSE;

-}

-

-void CBotCStack::SetBotCall(CBotProgram* p)

-{

-	m_prog = p;

-}

-

-CBotProgram* CBotCStack::GivBotCall()

-{

-	return m_prog;

-}

-

-void CBotCStack::SetRetType(CBotTypResult& type)

-{

-	m_retTyp = type;

-}

-

-CBotTypResult CBotCStack::GivRetType()

-{

-	return m_retTyp;

-}

-

-void CBotCStack::SetVar( CBotVar* var )

-{

-	if (m_var) delete m_var;	// remplacement d'une variable

-	m_var = var;

-}

-

-// met sur le stack une copie d'une variable

-void CBotCStack::SetCopyVar( CBotVar* var )

-{

-	if (m_var) delete m_var;	// remplacement d'une variable

-

-	if ( var == NULL ) return;

-	m_var = CBotVar::Create("", var->GivTypResult(2));

-	m_var->Copy( var );

-}

-

-CBotVar* CBotCStack::GivVar()

-{

-	return m_var;

-}

-

-void CBotCStack::AddVar(CBotVar* pVar)

-{

-	CBotCStack*	p = this;

-

-	// revient sur l'élement père

-	while (p != NULL && p->m_bBlock == 0) p = p->m_prev;

-

-	if ( p == NULL ) return;

-

-	CBotVar**	pp = &p->m_listVar;

-	while ( *pp != NULL ) pp = &(*pp)->m_next;

-

-	*pp = pVar;					// ajoute à la suite

-

-#ifdef	_DEBUG

-	if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();

-#endif

-}

-

-// test si une variable est déjà définie localement

-

-BOOL CBotCStack::CheckVarLocal(CBotToken* &pToken)

-{

-	CBotCStack*	p = this;

-	CBotString	name = pToken->GivString();

-

-	while (p != NULL)

-	{

-		CBotVar*	pp = p->m_listVar;

-		while ( pp != NULL)

-		{

-			if (name == pp->GivName())

-				return TRUE;

-			pp = pp->m_next;

-		}

-		if ( p->m_bBlock ) return FALSE;

-		p = p->m_prev;

-	}

-	return FALSE;

-}

-

-CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent)

-{

-	nIdent = 0;

-	CBotTypResult val(-1);

-

-	val = CBotCall::CompileCall(p, ppVars, this, nIdent);

-	if (val.GivType() < 0)

-	{

-		val = m_prog->GivFunctions()->CompileCall(p->GivString(), ppVars, nIdent);

-		if ( val.GivType() < 0 )

-		{

-	//		pVar = NULL;					// l'erreur n'est pas sur un paramètre en particulier

-			SetError( -val.GivType(), p );

-			val.SetType(-val.GivType());

-			return val;

-		}

-	}

-	return val;

-}

-

-// test si un nom de procédure est déjà défini quelque part

-

-BOOL CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)

-{

-	CBotString	name = pToken->GivString();

-

-	if ( CBotCall::CheckCall(name) ) return TRUE;

-

-	CBotFunction*	pp = m_prog->GivFunctions();

-	while ( pp != NULL )

-	{

-		if ( pToken->GivString() == pp->GivName() )

-		{

-			// les paramètres sont-ils exactement les mêmes ?

-			if ( pp->CheckParam( pParam ) )

-				return TRUE;

-		}

-		pp = pp->Next();

-	}

-

-	pp = CBotFunction::m_listPublic;

-	while ( pp != NULL )

-	{

-		if ( pToken->GivString() == pp->GivName() )

-		{

-			// les paramètres sont-ils exactement les mêmes ?

-			if ( pp->CheckParam( pParam ) )

-				return TRUE;

-		}

-		pp = pp->m_nextpublic;

-	}

-

-	return FALSE;

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+//Management of the stack
+
+
+#include "CBot.h"
+#include <cstdlib>
+#include <cstring>
+
+
+#define    ITIMER    100
+
+////////////////////////////////////////////////////////////////////////////
+// management of a execution of a stack
+////////////////////////////////////////////////////////////////////////////
+
+int         CBotStack::m_initimer = ITIMER;
+int         CBotStack::m_timer = 0;
+CBotVar*    CBotStack::m_retvar = NULL;
+int         CBotStack::m_error = 0;
+int         CBotStack::m_start = 0;
+int         CBotStack::m_end   = 0;
+CBotString  CBotStack::m_labelBreak="";
+void*       CBotStack::m_pUser = NULL;
+
+#if    STACKMEM
+
+CBotStack* CBotStack::FirstStack()
+{
+    CBotStack*    p;
+
+    long    size = sizeof(CBotStack);
+    size    *= (MAXSTACK+10);
+
+    // request a slice of memory for the stack
+    p = (CBotStack*)malloc(size);
+
+    // completely empty
+    memset(p, 0, size);
+
+    p-> m_bBlock = true;
+    m_timer = m_initimer;                // sets the timer at the beginning
+
+    CBotStack* pp = p;
+    pp += MAXSTACK;
+    int i;
+    for ( i = 0 ; i< 10 ; i++ )
+    {
+        pp->m_bOver = true;
+        pp ++;
+    }
+#ifdef    _DEBUG 
+    int    n = 1;
+    pp = p;
+    for ( i = 0 ; i< MAXSTACK+10 ; i++ )
+    {
+        pp->m_index = n++;
+        pp ++;
+    }
+#endif
+
+    m_error = 0;    // avoids deadlocks because m_error is static
+    return p;
+}
+
+CBotStack::CBotStack(CBotStack* ppapa)
+{
+    // constructor must exist or the destructor is never called!
+    ASM_TRAP();
+}
+
+CBotStack::~CBotStack()
+{
+    ASM_TRAP();    // use Delete () instead
+}
+
+void CBotStack::Delete()
+{
+    if ( this == NULL || this == EOX ) return;
+
+    m_next->Delete();
+    m_next2->Delete();
+
+    if (m_prev != NULL)
+    {
+        if ( m_prev->m_next == this )
+            m_prev->m_next = NULL;        // removes chain
+
+        if ( m_prev->m_next2 == this )
+            m_prev->m_next2 = NULL;        // removes chain
+    }
+
+    delete m_var;
+    delete m_listVar;
+
+    CBotStack*    p = m_prev;
+    bool        bOver = m_bOver;
+#ifdef    _DEBUG
+    int            n = m_index;
+#endif
+
+    // clears the freed block
+    memset(this, 0, sizeof(CBotStack));
+    m_bOver    = bOver;
+#ifdef    _DEBUG
+    m_index = n;
+#endif
+
+    if ( p == NULL ) 
+        free( this );
+}
+
+
+// routine improved
+CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
+{
+    if (m_next != NULL) 
+    {
+        return m_next;                // included in an existing stack
+    }
+
+#ifdef    _DEBUG
+    int        n = 0;
+#endif
+    CBotStack*    p = this;
+    do
+    {
+        p ++;
+#ifdef    _DEBUG
+        n ++;
+#endif
+    }
+    while ( p->m_prev != NULL );
+
+    m_next = p;                                    // chain an element
+    p->m_bBlock         = bBlock;
+    p->m_instr         = instr;
+    p->m_prog         = m_prog;
+    p->m_step         = 0;
+    p->m_prev         = this;
+    p->m_state         = 0;
+    p->m_call         = NULL;
+    p->m_bFunc         = false;
+    return    p;
+}
+
+CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
+{
+    if (m_next != NULL) 
+    {
+        if ( m_next == EOX )
+        {
+            m_next = NULL;
+            return EOX;
+        }
+        return m_next;                // included in an existing stack
+    }
+    CBotStack*    p = AddStack(NULL, bBlock);
+    p->m_call = instr;
+    p->m_bFunc = 2;    // special
+    return    p;
+}
+
+CBotStack* CBotStack::AddStack2(bool bBlock)
+{
+    if (m_next2 != NULL) 
+    {
+        m_next2->m_prog = m_prog;        // special avoids RestoreStack2
+        return m_next2;                    // included in an existing stack
+    }
+
+    CBotStack*    p = this;
+    do
+    {
+        p ++;
+    }
+    while ( p->m_prev != NULL );
+
+    m_next2 = p;                                // chain an element
+    p->m_prev = this;
+    p->m_bBlock = bBlock;
+    p->m_prog = m_prog;
+    p->m_step = 0;
+    return    p;
+}
+
+bool CBotStack::GivBlock()
+{
+    return    m_bBlock;
+}
+
+bool CBotStack::Return(CBotStack* pfils)
+{
+    if ( pfils == this ) return true;    // special
+
+    if (m_var != NULL) delete m_var;            // value replaced?
+    m_var = pfils->m_var;                        // result transmitted
+    pfils->m_var = NULL;                        // not to destroy the variable
+
+    m_next->Delete();m_next = NULL;                // releases the stack above
+    m_next2->Delete();m_next2 = NULL;            // also the second stack (catch)
+
+    return (m_error == 0);                        // interrupted if error
+}
+
+bool CBotStack::ReturnKeep(CBotStack* pfils)
+{
+    if ( pfils == this ) return true;    // special
+
+    if (m_var != NULL) delete m_var;            // value replaced?
+    m_var = pfils->m_var;                        // result transmitted
+    pfils->m_var = NULL;                        // not to destroy the variable
+
+    return (m_error == 0);                        // interrupted if error
+}
+
+bool CBotStack::StackOver()
+{
+    if (!m_bOver) return false;
+    m_error = TX_STACKOVER;
+    return true;
+}
+
+#else
+
+CBotStack::CBotStack(CBotStack* ppapa)
+{
+    m_next  = NULL;
+    m_next2 = NULL;
+    m_prev  = ppapa;
+
+    m_bBlock = (ppapa == NULL) ? true : false;
+
+    m_state = 0;
+    m_step = 1;
+
+    if (ppapa == NULL) m_timer = m_initimer;                // sets the timer at the beginning
+
+    m_listVar = NULL;
+    m_bDontDelete = false; 
+    
+    m_var      = NULL;
+    m_prog      = NULL;
+    m_instr      = NULL;
+    m_call      = NULL;
+    m_bFunc      = false;
+}
+
+// destructor
+CBotStack::~CBotStack()
+{
+    if ( m_next != EOX) delete m_next;
+    delete m_next2;
+    if (m_prev != NULL && m_prev->m_next == this )
+            m_prev->m_next = NULL;        // removes chain
+
+    delete m_var;
+    if ( !m_bDontDelete ) delete m_listVar;
+}
+
+// \TODO routine has/to optimize
+CBotStack* CBotStack::AddStack(CBotInstr* instr, bool bBlock)
+{
+    if (m_next != NULL) 
+    {
+        return m_next;                // included in an existing stack
+    }
+    CBotStack*    p = new CBotStack(this);
+    m_next = p;                                    // chain an element
+    p->m_bBlock = bBlock;
+    p->m_instr = instr;
+    p->m_prog = m_prog;
+    p->m_step = 0;
+    return    p;
+}
+
+CBotStack* CBotStack::AddStackEOX(CBotCall* instr, bool bBlock)
+{
+    if (m_next != NULL) 
+    {
+        if ( m_next == EOX )
+        {
+            m_next = NULL;
+            return EOX;
+        }
+        return m_next;                // included in an existing stack
+    }
+    CBotStack*    p = new CBotStack(this);
+    m_next = p;                                    // chain an element
+    p->m_bBlock = bBlock;
+    p->m_call = instr;
+    p->m_prog = m_prog;
+    p->m_step = 0;
+    p->m_bFunc = 2;    // special
+    return    p;
+}
+
+CBotStack* CBotStack::AddStack2(bool bBlock)
+{
+    if (m_next2 != NULL) 
+    {
+        m_next2->m_prog = m_prog;        // special avoids RestoreStack2
+        return m_next2;                    // included in an existing stack
+    }
+
+    CBotStack*    p = new CBotStack(this);
+    m_next2 = p;                                // chain an element
+    p->m_bBlock = bBlock;
+    p->m_prog = m_prog;
+    p->m_step = 0;
+
+    return    p;
+}
+
+bool CBotStack::Return(CBotStack* pfils)
+{
+    if ( pfils == this ) return true;    // special
+
+    if (m_var != NULL) delete m_var;            // value replaced?
+    m_var = pfils->m_var;                        // result transmitted
+    pfils->m_var = NULL;                        // do not destroy the variable
+
+    if ( m_next != EOX ) delete m_next;            // releases the stack above
+    delete m_next2;m_next2 = NULL;                // also the second stack (catch)
+
+    return (m_error == 0);                        // interrupted if error
+}
+
+bool CBotStack::StackOver()
+{
+    return false;            // no overflow check in this version
+}
+
+#endif
+
+void CBotStack::Reset(void* pUser)
+{
+    m_timer = m_initimer;        // resets the timer
+    m_error    = 0;
+//    m_start = 0;
+//    m_end    = 0;
+    m_labelBreak.Empty();
+    m_pUser = pUser;
+}
+
+
+
+
+CBotStack* CBotStack::RestoreStack(CBotInstr* instr)
+{
+    if (m_next != NULL) 
+    {
+        m_next->m_instr = instr;    // reset (if recovery after )
+        m_next->m_prog = m_prog;
+        return m_next;                // included in an existing stack
+    }
+    return    NULL;
+}
+
+CBotStack* CBotStack::RestoreStackEOX(CBotCall* instr)
+{
+    CBotStack*     p = RestoreStack();
+    p->m_call = instr;
+    return p;
+}
+
+
+
+// routine for execution step by step
+bool CBotStack::IfStep()
+{
+    if ( m_initimer > 0 || m_step++ > 0 ) return false;
+    return true;
+}
+
+
+bool CBotStack::BreakReturn(CBotStack* pfils, const char* name)
+{
+    if ( m_error>=0 ) return false;                // normal output
+    if ( m_error==-3 ) return false;            // normal output (return current)
+
+    if (!m_labelBreak.IsEmpty() && (name[0] == 0 || m_labelBreak != name))
+        return false;                            // it's not for me
+
+    m_error = 0;
+    m_labelBreak.Empty();
+    return Return(pfils);
+}
+
+bool CBotStack::IfContinue(int state, const char* name)
+{
+    if ( m_error != -2 ) return false;
+
+    if (!m_labelBreak.IsEmpty() && (name == NULL || m_labelBreak != name))
+        return false;                            // it's not for me
+
+    m_state = state;                            // where again?
+    m_error = 0;
+    m_labelBreak.Empty();
+    if ( m_next != EOX ) m_next->Delete();            // purge above stack
+    return true;
+}
+
+void CBotStack::SetBreak(int val, const char* name)
+{
+    m_error = -val;                                // reacts as an Exception
+    m_labelBreak = name;
+    if (val == 3)    // for a return
+    {
+        m_retvar = m_var;
+        m_var = NULL;
+    }
+}
+
+// gives on the stack value calculated by the last CBotReturn
+
+bool CBotStack::GivRetVar(bool bRet)
+{
+    if (m_error == -3)
+    {
+        if ( m_var ) delete m_var;
+        m_var        = m_retvar;
+        m_retvar    = NULL;
+        m_error        = 0;
+        return        true;
+    }
+    return bRet;                        // interrupted by something other than return
+}
+
+int CBotStack::GivError(int& start, int& end)
+{
+    start = m_start;
+    end      = m_end;
+    return m_error;
+}
+
+
+int CBotStack::GivType(int mode)
+{
+    if (m_var == NULL) return -1;
+    return m_var->GivType(mode);
+}
+
+CBotTypResult CBotStack::GivTypResult(int mode)
+{
+    if (m_var == NULL) return -1;
+    return m_var->GivTypResult(mode);
+}
+
+void CBotStack::SetType(CBotTypResult& type)
+{
+    if (m_var == NULL) return;
+    m_var->SetType( type );
+}
+
+
+CBotVar* CBotStack::FindVar(CBotToken* &pToken, bool bUpdate, bool bModif)
+{
+    CBotStack*    p = this;
+    CBotString    name = pToken->GivString();
+
+    while (p != NULL)
+    {
+        CBotVar*    pp = p->m_listVar;
+        while ( pp != NULL)
+        {
+            if (pp->GivName() == name)
+            {
+                if ( bUpdate ) 
+                    pp->Maj(m_pUser, false);
+
+                return pp;
+            }
+            pp = pp->m_next;
+        }
+        p = p->m_prev;
+    }
+    return NULL;
+}
+
+CBotVar* CBotStack::FindVar(const char* name)
+{
+    CBotStack*    p = this;
+    while (p != NULL)
+    {
+        CBotVar*    pp = p->m_listVar;
+        while ( pp != NULL)
+        {
+            if (pp->GivName() == name)
+            {
+                return pp;
+            }
+            pp = pp->m_next;
+        }
+        p = p->m_prev;
+    }
+    return NULL;
+}
+
+CBotVar* CBotStack::FindVar(long ident, bool bUpdate, bool bModif)
+{
+    CBotStack*    p = this;
+    while (p != NULL)
+    {
+        CBotVar*    pp = p->m_listVar;
+        while ( pp != NULL)
+        {
+            if (pp->GivUniqNum() == ident)
+            {
+                if ( bUpdate ) 
+                    pp->Maj(m_pUser, false);
+
+                return pp;
+            }
+            pp = pp->m_next;
+        }
+        p = p->m_prev;
+    }
+    return NULL;
+}
+
+
+CBotVar* CBotStack::FindVar(CBotToken& Token, bool bUpdate, bool bModif)
+{
+    CBotToken*    pt = &Token;
+    return FindVar(pt, bUpdate, bModif);
+}
+
+
+CBotVar* CBotStack::CopyVar(CBotToken& Token, bool bUpdate)
+{
+    CBotVar*    pVar = FindVar( Token, bUpdate );
+
+    if ( pVar == NULL) return NULL;
+
+    CBotVar*    pCopy = CBotVar::Create(pVar);
+    pCopy->Copy(pVar);
+    return    pCopy;
+}
+
+ 
+bool CBotStack::SetState(int n, int limite)
+{
+    m_state = n;
+
+    m_timer--;                                    // decrement the operations \TODO decrement the operations
+    return ( m_timer > limite );                    // interrupted if timer pass
+}
+
+bool CBotStack::IncState(int limite)
+{
+    m_state++;
+
+    m_timer--;                                    // decrement the operations \TODO decompte les operations
+    return ( m_timer > limite );                    // interrupted if timer pass
+}
+
+
+void CBotStack::SetError(int n, CBotToken* token)
+{
+    if ( n!= 0 && m_error != 0) return;    // does not change existing error
+    m_error = n;
+    if (token != NULL)
+    {
+        m_start = token->GivStart();
+        m_end   = token->GivEnd();
+    }
+}
+
+void CBotStack::ResetError(int n, int start, int end)
+{
+    m_error = n;
+    m_start    = start;
+    m_end    = end;
+}
+
+void CBotStack::SetPosError(CBotToken* token)
+{
+    m_start = token->GivStart();
+    m_end   = token->GivEnd();
+}
+
+void CBotStack::SetTimer(int n)
+{
+    m_initimer = n;
+}
+
+bool CBotStack::Execute()
+{
+    CBotCall*        instr = NULL;                        // the most highest instruction
+    CBotStack*        pile;
+
+    CBotStack*        p = this;
+
+    while (p != NULL)
+    {
+        if ( p->m_next2 != NULL ) break;
+        if ( p->m_call != NULL ) 
+        {
+            instr = p->m_call;
+            pile  = p->m_prev ;
+        }
+        p = p->m_next;
+    }
+
+    if ( instr == NULL ) return true;                // normal execution request
+
+    if (!instr->Run(pile)) return false;            // \TODO exécution à partir de là
+
+#if    STACKMEM
+    pile->m_next->Delete();
+#else
+    delete pile->m_next;
+#endif
+
+    pile->m_next = EOX;            // special for recovery
+    return true;
+}
+
+// puts on the stack pointer to a variable
+void CBotStack::SetVar( CBotVar* var )
+{
+    if (m_var) delete m_var;    // replacement of a variable
+    m_var = var;
+}
+
+// puts on the stack a copy of a variable
+void CBotStack::SetCopyVar( CBotVar* var )
+{
+    if (m_var) delete m_var;    // replacement of a variable
+
+    m_var = CBotVar::Create("", var->GivTypResult(2));
+    m_var->Copy( var );
+}
+
+CBotVar* CBotStack::GivVar()
+{
+    return m_var;
+}
+
+CBotVar* CBotStack::GivPtVar()
+{
+    CBotVar*    p = m_var;
+    m_var = NULL;                // therefore will not be destroyed
+    return p;
+}
+
+CBotVar* CBotStack::GivCopyVar()
+{
+    if (m_var == NULL) return NULL;
+    CBotVar*    v = CBotVar::Create("", m_var->GivType());
+    v->Copy( m_var );
+    return v;
+}
+
+long CBotStack::GivVal()
+{
+    if (m_var == NULL) return 0;
+    return m_var->GivValInt();
+}
+
+
+
+
+void CBotStack::AddVar(CBotVar* pVar)
+{
+    CBotStack*    p = this;
+
+    // returns to the father element
+    while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
+
+    if ( p == NULL ) return;
+    
+///    p->m_bDontDelete = bDontDelete;
+
+    CBotVar**    pp = &p->m_listVar;
+    while ( *pp != NULL ) pp = &(*pp)->m_next;
+
+    *pp = pVar;                    // added after
+
+#ifdef    _DEBUG
+    if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();
+#endif
+}
+
+/*void CBotStack::RestoreVar(CBotVar* pVar)
+{
+    if ( !m_bDontDelete ) __asm int 3;
+    delete    m_listVar;
+    m_listVar = pVar;        // direct replacement
+}*/
+
+void CBotStack::SetBotCall(CBotProgram* p)
+{
+    m_prog  = p;
+    m_bFunc = true;
+}
+
+CBotProgram*  CBotStack::GivBotCall(bool bFirst)
+{
+    if ( ! bFirst )    return m_prog;
+    CBotStack*    p = this;
+    while ( p->m_prev != NULL ) p = p->m_prev;
+    return p->m_prog;
+}
+
+void* CBotStack::GivPUser()
+{
+    return m_pUser;
+}
+
+
+bool CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype)
+{
+    CBotTypResult        res;
+
+    // first looks by the identifier
+
+    res = CBotCall::DoCall(nIdent, NULL, ppVar, this, rettype );
+    if (res.GivType() >= 0) return res.GivType();
+
+    res = m_prog->GivFunctions()->DoCall(nIdent, NULL, ppVar, this, token );
+    if (res.GivType() >= 0) return res.GivType();
+
+    // if not found (recompile?) seeks by name
+
+    nIdent = 0;
+    res = CBotCall::DoCall(nIdent, token, ppVar, this, rettype );
+    if (res.GivType() >= 0) return res.GivType();
+
+    res = m_prog->GivFunctions()->DoCall(nIdent, token->GivString(), ppVar, this, token );
+    if (res.GivType() >= 0) return res.GivType();
+
+    SetError(TX_NOCALL, token);
+    return true;
+}
+
+void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
+{
+    if ( m_next == NULL ) return;
+
+    if ( !CBotCall::RestoreCall(nIdent, token, ppVar, this) )
+        m_prog->GivFunctions()->RestoreCall(nIdent, token->GivString(), ppVar, this );
+}
+
+
+bool SaveVar(FILE* pf, CBotVar* pVar)
+{
+    while ( true )
+    {
+        if ( pVar == NULL )
+        {
+            return WriteWord(pf, 0);                            // is a terminator
+        }
+
+        if ( !pVar->Save0State(pf)) return false;                // common header
+        if ( !pVar->Save1State(pf) ) return false;                // saves as the child class
+
+        pVar = pVar->GivNext();
+    }
+}
+
+void CBotStack::GetRunPos(const char* &FunctionName, int &start, int &end)
+{
+    CBotProgram*    prog = m_prog;                        // Current program
+
+    CBotInstr*        funct = NULL;                        // function found
+    CBotInstr*        instr = NULL;                        // the highest intruction
+
+    CBotStack*        p = this;
+
+    while (p->m_next != NULL)
+    {
+        if ( p->m_instr != NULL ) instr = p->m_instr;
+        if ( p->m_bFunc == 1 ) funct = p->m_instr;
+        if ( p->m_next->m_prog != prog ) break ; 
+
+        if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;
+        else                                        p = p->m_next;
+    }
+
+    if ( p->m_instr != NULL ) instr = p->m_instr;
+    if ( p->m_bFunc == 1 ) funct = p->m_instr;
+
+    if ( funct == NULL ) return;
+
+    CBotToken* t = funct->GivToken();
+    FunctionName = t->GivString();
+
+//    if ( p->m_instr != NULL ) instr = p->m_instr;
+
+    t = instr->GivToken();
+    start = t->GivStart();
+    end      = t->GivEnd();
+}
+
+CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)
+{
+    CBotProgram*    prog = m_prog;                        // current program
+    FunctionName    = NULL;
+
+    // back the stack in the current module
+    CBotStack*        p = this;
+
+    while (p->m_next != NULL)
+    {
+        if ( p->m_next->m_prog != prog ) break ; 
+
+        if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;
+        else                                        p = p->m_next;
+    }
+
+
+    // descends upon the elements of block
+    while ( p != NULL && !p->m_bBlock )    p = p->m_prev;
+
+    while ( p != NULL && level++ < 0 )
+    {
+        p = p->m_prev;
+        while ( p != NULL && !p->m_bBlock )    p = p->m_prev;
+    }
+
+    if ( p == NULL ) return NULL;
+
+    // search the name of the current function
+    CBotStack* pp = p;
+    while ( pp != NULL )
+    {
+        if ( pp->m_bFunc == 1 ) break;
+        pp = pp->m_prev;
+    }
+
+    if ( pp == NULL || pp->m_instr == NULL ) return NULL;
+
+    CBotToken* t = pp->m_instr->GivToken();
+    FunctionName = t->GivString();
+    
+    return p->m_listVar;
+}
+
+bool CBotStack::SaveState(FILE* pf)
+{
+    if ( this == NULL )                                    // end of the tree?
+    {
+        return WriteWord(pf, 0);                        // is a terminator
+    }
+
+    if ( m_next2 != NULL )
+    {
+        if (!WriteWord(pf, 2)) return false;                // a mark of pursuit
+        if (!m_next2->SaveState(pf)) return false;
+    }
+    else
+    {
+        if (!WriteWord(pf, 1)) return false;                // a mark of pursuit
+    }
+    if (!WriteWord(pf, m_bBlock)) return false;            // is a local block
+    if (!WriteWord(pf, m_state)) return false;            // in what state?
+    if (!WriteWord(pf, 0)) return false;                // by compatibility m_bDontDelete
+    if (!WriteWord(pf, m_step)) return false;            // in what state?
+    
+    
+    if (!SaveVar(pf, m_var)) return false;            // current result
+    if (!SaveVar(pf, m_listVar)) return false;        // local variables
+
+    return m_next->SaveState(pf);                        // saves the following
+}
+
+
+bool CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)
+{
+    unsigned short    w;
+
+    pStack = NULL;
+    if (!ReadWord(pf, w)) return false;
+    if ( w == 0 ) return true;
+
+#if    STACKMEM
+    if ( this == NULL ) pStack = FirstStack();
+    else pStack = AddStack();
+#else
+    pStack = new CBotStack(this);
+#endif
+
+    if ( w == 2 )
+    {
+        if (!pStack->RestoreState(pf, pStack->m_next2)) return false;
+    }
+
+    if (!ReadWord(pf, w)) return false;            // is a local block
+    pStack->m_bBlock = w;
+
+    if (!ReadWord(pf, w)) return false;            // in what state ?
+    pStack->SetState((short)w);                    // in a good state
+
+    if (!ReadWord(pf, w)) return false;            // dont delete?
+                                                // uses more
+
+    if (!ReadWord(pf, w)) return false;            // step by step
+    pStack->m_step = w;
+
+    if (!CBotVar::RestoreState(pf, pStack->m_var)) return false;    // temp variable
+    if (!CBotVar::RestoreState(pf, pStack->m_listVar)) return false;// local variables
+
+    return pStack->RestoreState(pf, pStack->m_next);
+}
+
+
+bool CBotVar::Save0State(FILE* pf)
+{    
+    if (!WriteWord(pf, 100+m_mPrivate))return false;        // private variable?
+    if (!WriteWord(pf, m_bStatic))return false;                // static variable?
+    if (!WriteWord(pf, m_type.GivType()))return false;        // saves the type (always non-zero)
+    if (!WriteWord(pf, m_binit))return false;                // variable defined?
+    return WriteString(pf, m_token->GivString());            // and variable name
+}
+
+bool CBotVarInt::Save0State(FILE* pf)
+{    
+    if ( !m_defnum.IsEmpty() )
+    {
+        if(!WriteWord(pf, 200 )) return false;            // special marker
+        if(!WriteString(pf, m_defnum)) return false;    // name of the value 
+    }
+
+    return CBotVar::Save0State(pf);
+}
+
+bool CBotVarInt::Save1State(FILE* pf)
+{
+    return WriteWord(pf, m_val);                            // the value of the variable
+}
+
+bool CBotVarBoolean::Save1State(FILE* pf)
+{
+    return WriteWord(pf, m_val);                            // the value of the variable
+}
+
+bool CBotVarFloat::Save1State(FILE* pf)
+{
+    return WriteFloat(pf, m_val);                            // the value of the variable
+}
+
+bool CBotVarString::Save1State(FILE* pf)
+{
+    return WriteString(pf, m_val);                            // the value of the variable
+}
+
+
+
+bool CBotVarClass::Save1State(FILE* pf)
+{
+    if ( !WriteType(pf, m_type) ) return false;
+    if ( !WriteLong(pf, m_ItemIdent) ) return false;
+
+    return SaveVar(pf, m_pVar);                                // content of the object
+}
+
+bool CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
+{
+    unsigned short        w, wi, prv, st;
+    float        ww;
+    CBotString    name, s;
+
+    delete pVar;
+
+                pVar    = NULL;
+    CBotVar*    pNew    = NULL;
+    CBotVar*    pPrev    = NULL;
+
+    while ( true )            // retrieves a list
+    {
+        if (!ReadWord(pf, w)) return false;                        // private or type?
+        if ( w == 0 ) return true;
+
+        CBotString defnum;
+        if ( w == 200 )
+        {
+            if (!ReadString(pf, defnum)) return false;            // number with identifier
+            if (!ReadWord(pf, w)) return false;                    // type
+        }
+
+        prv = 100; st = 0;
+        if ( w >= 100 )
+        {
+            prv = w;
+            if (!ReadWord(pf, st)) return false;                // static
+            if (!ReadWord(pf, w)) return false;                    // type
+        }
+
+        if ( w == CBotTypClass ) w = CBotTypIntrinsic;            // necessarily intrinsic
+
+        if (!ReadWord(pf, wi)) return false;                    // init ?
+
+        if (!ReadString(pf, name)) return false;                // variable name
+
+        CBotToken token(name, CBotString());
+
+        switch (w)
+        {
+        case CBotTypInt:
+        case CBotTypBoolean:
+            pNew = CBotVar::Create(&token, w);                        // creates a variable
+            if (!ReadWord(pf, w)) return false;
+            pNew->SetValInt((short)w, defnum);
+            break;
+        case CBotTypFloat:
+            pNew = CBotVar::Create(&token, w);                        // creates a variable
+            if (!ReadFloat(pf, ww)) return false;
+            pNew->SetValFloat(ww);
+            break;
+        case CBotTypString:
+            pNew = CBotVar::Create(&token, w);                        // creates a variable
+            if (!ReadString(pf, s)) return false;
+            pNew->SetValString(s);
+            break;
+
+        // returns an intrinsic object or element of an array
+        case CBotTypIntrinsic:
+        case CBotTypArrayBody:
+            {
+                CBotTypResult    r;
+                long            id;
+                if (!ReadType(pf, r))  return false;                // complete type
+                if (!ReadLong(pf, id) ) return false;
+
+//                if (!ReadString(pf, s)) return false;
+                {
+                    CBotVar* p = NULL;
+                    if ( id ) p = CBotVarClass::Find(id) ;
+
+                    pNew = new CBotVarClass(&token, r);                // directly creates an instance
+                                                                    // attention cptuse = 0
+                    if ( !RestoreState(pf, ((CBotVarClass*)pNew)->m_pVar)) return false;
+                    pNew->SetIdent(id);
+
+                    if ( p != NULL )
+                    {
+                        delete pNew;
+                        pNew = p;            // resume known element 
+                    }
+                }
+            }
+            break;
+
+        case CBotTypPointer:
+        case CBotTypNullPointer:
+            if (!ReadString(pf, s)) return false;
+            {
+                pNew = CBotVar::Create(&token, CBotTypResult(w, s));// creates a variable
+                CBotVarClass* p = NULL;
+                long id;
+                ReadLong(pf, id);
+//                if ( id ) p = CBotVarClass::Find(id);        // found the instance (made by RestoreInstance)
+
+                // returns a copy of the original instance
+                CBotVar* pInstance = NULL;
+                if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
+                ((CBotVarPointer*)pNew)->SetPointer( pInstance );            // and point over
+
+//                if ( p != NULL ) ((CBotVarPointer*)pNew)->SetPointer( p );    // rather this one
+
+            }
+            break;
+
+        case CBotTypArrayPointer:
+            {
+                CBotTypResult    r;
+                if (!ReadType(pf, r))  return false;
+
+                pNew = CBotVar::Create(&token, r);                        // creates a variable
+
+                // returns a copy of the original instance
+                CBotVar* pInstance = NULL;
+                if ( !CBotVar::RestoreState( pf, pInstance ) ) return false;
+                ((CBotVarPointer*)pNew)->SetPointer( pInstance );            // and point over
+            }
+            break;
+        default:
+            ASM_TRAP();
+        }
+
+        if ( pPrev != NULL ) pPrev->m_next = pNew;
+        if ( pVar == NULL  ) pVar = pNew;
+
+        pNew->m_binit = wi;        //        pNew->SetInit(wi);
+        pNew->SetStatic(st);
+        pNew->SetPrivate(prv-100);
+        pPrev = pNew;
+    }
+    return true;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// management of the compile stack
+////////////////////////////////////////////////////////////////////////////
+
+CBotProgram*    CBotCStack::m_prog    = NULL;            // init the static variable
+int                CBotCStack::m_error   = 0;
+int                CBotCStack::m_end      = 0;
+CBotTypResult    CBotCStack::m_retTyp  = CBotTypResult(0);
+//CBotToken*        CBotCStack::m_retClass= NULL;
+
+
+CBotCStack::CBotCStack(CBotCStack* ppapa)
+{
+    m_next = NULL;
+    m_prev = ppapa;
+
+    if (ppapa == NULL)
+    {
+        m_error = 0;
+        m_start = 0;
+        m_end    = 0;
+        m_bBlock = true;
+    }
+    else
+    {
+        m_start = ppapa->m_start;
+        m_bBlock = false;
+    }
+
+    m_listVar = NULL;
+    m_var      = NULL;
+}
+
+// destructor
+CBotCStack::~CBotCStack()
+{
+    if (m_next != NULL) delete m_next;
+    if (m_prev != NULL) m_prev->m_next = NULL;        // removes chain
+
+    delete m_var;
+    delete m_listVar;
+}
+
+// used only at compile
+CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, bool bBlock)
+{
+    if (m_next != NULL) return m_next;            // include on an existing stack
+
+    CBotCStack*    p = new CBotCStack(this);
+    m_next = p;                                    // channel element
+    p->m_bBlock = bBlock;
+
+    if (pToken != NULL) p->SetStartError(pToken->GivStart());
+
+    return    p;
+}
+
+
+CBotInstr* CBotCStack::Return(CBotInstr* inst, CBotCStack* pfils)
+{        
+    if ( pfils == this ) return inst;
+
+    if (m_var != NULL) delete m_var;            // value replaced?
+    m_var = pfils->m_var;                        // result transmitted
+    pfils->m_var = NULL;                        // not to destroy the variable
+
+    if (m_error)
+    {
+        m_start = pfils->m_start;                // retrieves the position of the error
+        m_end    = pfils->m_end;
+    }
+
+    delete pfils;
+    return inst;
+}
+
+CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)
+{        
+    if (m_var != NULL) delete m_var;            // value replaced?
+    m_var = pfils->m_var;                        // result transmitted
+    pfils->m_var = NULL;                        // not to destroy the variable
+
+    if (m_error)
+    {
+        m_start = pfils->m_start;                // retrieves the position of the error
+        m_end    = pfils->m_end;
+    }
+
+    delete pfils;
+    return inst;
+}
+
+int CBotCStack::GivError(int& start, int& end)
+{
+    start = m_start;
+    end      = m_end;
+    return m_error;
+}
+
+int CBotCStack::GivError()
+{
+    return m_error;
+}
+
+// type of instruction on the stack
+CBotTypResult CBotCStack::GivTypResult(int mode)
+{
+    if (m_var == NULL)
+        return CBotTypResult(99);
+    return    m_var->GivTypResult(mode);
+}
+
+// type of instruction on the stack
+int CBotCStack::GivType(int mode)
+{
+    if (m_var == NULL)
+        return 99;
+    return    m_var->GivType(mode);
+}
+
+// pointer on the stack is in what class?
+CBotClass* CBotCStack::GivClass()
+{
+    if ( m_var == NULL )
+        return NULL;
+    if ( m_var->GivType(1) != CBotTypPointer ) return NULL;
+
+    return m_var->GivClass();
+}
+
+// type of instruction on the stack
+void CBotCStack::SetType(CBotTypResult& type)
+{
+    if (m_var == NULL) return;
+    m_var->SetType( type );
+}
+
+// seeks a variable on the stack
+// the token may be a result of TokenTypVar (object of a class)
+// or a pointer in the source
+
+CBotVar* CBotCStack::FindVar(CBotToken* &pToken)
+{
+    CBotCStack*    p = this;
+    CBotString    name = pToken->GivString();
+
+    while (p != NULL)
+    {
+        CBotVar*    pp = p->m_listVar;
+        while ( pp != NULL)
+        {
+            if (name == pp->GivName())
+            {
+                return pp;
+            }
+            pp = pp->m_next;
+        }
+        p = p->m_prev;
+    }
+    return NULL;
+}
+
+CBotVar* CBotCStack::FindVar(CBotToken& Token)
+{
+    CBotToken*    pt = &Token;
+    return FindVar(pt);
+}
+
+CBotVar* CBotCStack::CopyVar(CBotToken& Token)
+{
+    CBotVar*    pVar = FindVar( Token );
+
+    if ( pVar == NULL) return NULL;
+
+    CBotVar*    pCopy = CBotVar::Create( "", pVar->GivType() );
+    pCopy->Copy(pVar);
+    return    pCopy;
+}
+
+bool CBotCStack::IsOk()
+{
+    return (m_error == 0);
+}
+
+ 
+void CBotCStack::SetStartError( int pos )
+{
+    if ( m_error != 0) return;            // does not change existing error
+    m_start = pos;
+}
+
+void CBotCStack::SetError(int n, int pos)
+{
+    if ( n!= 0 && m_error != 0) return;    // does not change existing error
+    m_error = n;
+    m_end    = pos;
+}
+
+void CBotCStack::SetError(int n, CBotToken* p)
+{
+    if (m_error) return;    // does not change existing error
+    m_error = n;
+    m_start    = p->GivStart();
+    m_end    = p->GivEnd();
+}
+
+void CBotCStack::ResetError(int n, int start, int end)
+{
+    m_error = n;
+    m_start    = start;
+    m_end    = end;
+}
+
+bool CBotCStack::NextToken(CBotToken* &p)
+{
+    CBotToken*    pp = p;
+
+    p = p->GivNext();
+    if (p!=NULL) return true;
+
+    SetError(TX_ENDOF, pp->GivEnd());
+    return false;
+}
+
+void CBotCStack::SetBotCall(CBotProgram* p)
+{
+    m_prog = p;
+}
+
+CBotProgram* CBotCStack::GivBotCall()
+{
+    return m_prog;
+}
+
+void CBotCStack::SetRetType(CBotTypResult& type)
+{
+    m_retTyp = type;
+}
+
+CBotTypResult CBotCStack::GivRetType()
+{
+    return m_retTyp;
+}
+
+void CBotCStack::SetVar( CBotVar* var )
+{
+    if (m_var) delete m_var;    // replacement of a variable
+    m_var = var;
+}
+
+// puts on the stack a copy of a variable
+void CBotCStack::SetCopyVar( CBotVar* var )
+{
+    if (m_var) delete m_var;    // replacement of a variable
+
+    if ( var == NULL ) return;
+    m_var = CBotVar::Create("", var->GivTypResult(2));
+    m_var->Copy( var );
+}
+
+CBotVar* CBotCStack::GivVar()
+{
+    return m_var;
+}
+
+void CBotCStack::AddVar(CBotVar* pVar)
+{
+    CBotCStack*    p = this;
+
+    // returns to the father element
+    while (p != NULL && p->m_bBlock == 0) p = p->m_prev;
+
+    if ( p == NULL ) return;
+
+    CBotVar**    pp = &p->m_listVar;
+    while ( *pp != NULL ) pp = &(*pp)->m_next;
+
+    *pp = pVar;                    // added after
+
+#ifdef    _DEBUG
+    if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();
+#endif
+}
+
+// test whether a variable is already defined locally
+
+bool CBotCStack::CheckVarLocal(CBotToken* &pToken)
+{
+    CBotCStack*    p = this;
+    CBotString    name = pToken->GivString();
+
+    while (p != NULL)
+    {
+        CBotVar*    pp = p->m_listVar;
+        while ( pp != NULL)
+        {
+            if (name == pp->GivName())
+                return true;
+            pp = pp->m_next;
+        }
+        if ( p->m_bBlock ) return false;
+        p = p->m_prev;
+    }
+    return false;
+}
+
+CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent)
+{
+    nIdent = 0;
+    CBotTypResult val(-1);
+
+    val = CBotCall::CompileCall(p, ppVars, this, nIdent);
+    if (val.GivType() < 0)
+    {
+        val = m_prog->GivFunctions()->CompileCall(p->GivString(), ppVars, nIdent);
+        if ( val.GivType() < 0 )
+        {
+    //        pVar = NULL;                    // the error is not on a particular parameter
+            SetError( -val.GivType(), p );
+            val.SetType(-val.GivType());
+            return val;
+        }
+    }
+    return val;
+}
+
+// test if a procedure name is already defined somewhere
+
+bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
+{
+    CBotString    name = pToken->GivString();
+
+    if ( CBotCall::CheckCall(name) ) return true;
+
+    CBotFunction*    pp = m_prog->GivFunctions();
+    while ( pp != NULL )
+    {
+        if ( pToken->GivString() == pp->GivName() )
+        {
+            // are parameters exactly the same?
+            if ( pp->CheckParam( pParam ) )
+                return true;
+        }
+        pp = pp->Next();
+    }
+
+    pp = CBotFunction::m_listPublic;
+    while ( pp != NULL )
+    {
+        if ( pToken->GivString() == pp->GivName() )
+        {
+            // are parameters exactly the same?
+            if ( pp->CheckParam( pParam ) )
+                return true;
+        }
+        pp = pp->m_nextpublic;
+    }
+
+    return false;
+}
+
diff --git a/src/CBot/CBotString.cpp b/src/CBot/CBotString.cpp
index 53b0f27..1b42c23 100644
--- a/src/CBot/CBotString.cpp
+++ b/src/CBot/CBotString.cpp
@@ -1,603 +1,692 @@
-// * 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  http://www.gnu.org/licenses/./////////////////////////////////////////////////////

-// gestion de chaine

-// basé sur le CString de MFC

-// mais moins complet

-

-#include "CBot.h"

-

-#include <string.h>

-

-HINSTANCE CBotString::m_hInstance = (HINSTANCE)LoadLibrary("libCbot.dll");	// comment le récupérer autrement ??

-

-

-CBotString::CBotString()

-{

-	m_ptr = NULL;				// chaine vide

-	m_lg  = 0;

-}

-

-CBotString::~CBotString()

-{

-	if (m_ptr != NULL) free(m_ptr);

-}

-

-

-CBotString::CBotString(const char* p)

-{

-	m_lg = lstrlen( p );

-

-	m_ptr = NULL;

-	if (m_lg>0)

-	{

-		m_ptr = (char*)malloc(m_lg+1);

-		lstrcpy(m_ptr, p);

-	}

-}

-

-CBotString::CBotString(const CBotString& srcString)

-{

-	m_lg = srcString.m_lg;

-

-	m_ptr = NULL;

-	if (m_lg>0)

-	{

-		m_ptr = (char*)malloc(m_lg+1);

-		lstrcpy(m_ptr, srcString.m_ptr);

-	}

-}

-

-

-

-

-int CBotString::GivLength()

-{

-	if ( m_ptr == NULL ) return 0;

-	return lstrlen( m_ptr ); 

-}

-

-

-

-CBotString CBotString::Left(int nCount) const

-{

-	char	chaine[2000];

-	

-	int		i;

-	for (i = 0; i < m_lg && i < nCount && i < 1999; i++)

-	{

-		chaine[i] = m_ptr[i];

-	}

-	chaine[i] = 0 ;

-

-	return CBotString( chaine );

-}

-

-CBotString CBotString::Right(int nCount) const

-{

-	char	chaine[2000];

-	

-	int		i = m_lg - nCount;

-	if ( i < 0 ) i = 0;

-

-	int j;

-	for ( j = 0 ; i < m_lg && i < 1999; i++)

-	{

-		chaine[j++] = m_ptr[i];

-	}

-	chaine[j] = 0 ;

-

-	return CBotString( chaine );

-}

-

-CBotString CBotString::Mid(int nFirst, int nCount) const

-{

-	char	chaine[2000];

-	

-	int		i;

-

-	for ( i = nFirst; i < m_lg && i < 1999 && i <= nFirst + nCount; i++)

-	{

-		chaine[i] = m_ptr[i];

-	}

-	chaine[i] = 0 ;

-

-	return CBotString( chaine );

-}

-

-CBotString CBotString::Mid(int nFirst) const

-{

-	char	chaine[2000];

-	

-	int		i;

-

-	for ( i = nFirst; i < m_lg && i < 1999 ; i++)

-	{

-		chaine[i] = m_ptr[i];

-	}

-	chaine[i] = 0 ;

-

-	return CBotString( chaine );

-}

-

-

-int CBotString::Find(const char c)

-{

-	int		i;

-	for (i = 0; i < m_lg; i++)

-	{

-		if (m_ptr[i] == c) return i;

-	}

-	return -1;

-}

-

-int CBotString::Find(LPCTSTR lpsz)

-{

-	int		i, j;

-	int		l = lstrlen(lpsz);

-

-	for (i = 0; i <= m_lg-l; i++)

-	{

-		for (j = 0; j < l; j++)

-		{

-			if (m_ptr[i+j] != lpsz[j]) goto bad;

-		}

-		return i;

-bad:;

-	}

-	return -1;

-}

-

-int CBotString::ReverseFind(const char c)

-{

-	int		i;

-	for (i = m_lg-1; i >= 0; i--)

-	{

-		if (m_ptr[i] == c) return i;

-	}

-	return -1;

-}

-

-int CBotString::ReverseFind(LPCTSTR lpsz)

-{

-	int		i, j;

-	int		l = lstrlen(lpsz);

-

-	for (i = m_lg-l; i >= 0; i--)

-	{

-		for (j = 0; j < l; j++)

-		{

-			if (m_ptr[i+j] != lpsz[j]) goto bad;

-		}

-		return i;

-bad:;

-	}

-	return -1;

-}

-

-CBotString CBotString::Mid(int start, int lg)

-{

-	CBotString	res;

-	if (start >= m_lg) return res;

-

-	if ( lg < 0 ) lg = m_lg - start;

-

-	char* p = (char*)malloc(m_lg+1);

-	lstrcpy(p, m_ptr+start);

-	p[lg] = 0;

-

-	res = p;

-	free(p);

-	return res;

-}

-

-void CBotString::MakeUpper()

-{

-	int		i;

-

-	for ( i = 0; i < m_lg && i < 1999 ; i++)

-	{

-		char	c = m_ptr[i];

-		if ( c >= 'a' && c <= 'z' ) m_ptr[i] = c - 'a' + 'A';

-	}

-}

-

-void CBotString::MakeLower()

-{

-	int		i;

-

-	for ( i = 0; i < m_lg && i < 1999 ; i++)

-	{

-		char	c = m_ptr[i];

-		if ( c >= 'A' && c <= 'Z' ) m_ptr[i] = c - 'A' + 'a';

-	}

-}

-

-

-

-#define MAXSTRING	256

-

-BOOL CBotString::LoadString(UINT id)

-{

-	char	buffer[MAXSTRING];

-

-	m_lg = ::LoadString( m_hInstance, id, buffer, MAXSTRING ); 

-

-	if (m_ptr != NULL) free(m_ptr);

-

- 	m_ptr = NULL;

-	if (m_lg > 0)

-	{

-		m_ptr = (char*)malloc(m_lg+1);

-		lstrcpy(m_ptr, buffer);

-		return TRUE;

-	}

-	return FALSE;

-}

- 

-

-const CBotString& CBotString::operator=(const CBotString& stringSrc)

-{

-	if (m_ptr != NULL) free(m_ptr);

-

-	m_lg = stringSrc.m_lg; 

-	m_ptr = NULL;

-

-	if (m_lg > 0)

-	{

-		m_ptr = (char*)malloc(m_lg+1);

-		lstrcpy(m_ptr, stringSrc.m_ptr);

-	}

-

-	return *this;

-}

-

-CBotString operator+(const CBotString& string, LPCTSTR lpsz)

-{

-	CBotString s ( string );

-	s += lpsz;

-	return s;

-}

-

-const CBotString& CBotString::operator+(const CBotString& stringSrc)

-{

-	char*	p = (char*)malloc(m_lg+stringSrc.m_lg+1);

-

-	lstrcpy(p, m_ptr);

-	char*	pp = p + m_lg;

-	lstrcpy(pp, stringSrc.m_ptr);

-

-	if (m_ptr != NULL) free(m_ptr);

-	m_ptr = p;

-	m_lg += stringSrc.m_lg;

-

-	return *this;

-}

-

-const CBotString& CBotString::operator=(const char ch)

-{

-	if (m_ptr != NULL) free(m_ptr);

-

-	m_lg = 1; 

-

-	m_ptr = (char*)malloc(2);

-	m_ptr[0] = ch;

-	m_ptr[1] = 0;

-	

-	return *this;

-}

-

-const CBotString& CBotString::operator=(const char* pString)

-{

-	if (m_ptr != NULL) free(m_ptr);

-	m_ptr = NULL;

-

-	if ( pString != NULL )

-	{

-		m_lg = lstrlen(pString); 

-

-		if (m_lg != 0)

-		{

-			m_ptr = (char*)malloc(m_lg+1);

-			lstrcpy(m_ptr, pString);

-		}

-	}

-	

-	return *this;

-}

-

-

-const CBotString& CBotString::operator+=(const char ch)

-{

-	char*	p = (char*)malloc(m_lg+2);

-

-	if (m_ptr!=NULL) lstrcpy(p, m_ptr);

-	p[m_lg++] = ch;

-	p[m_lg]   = 0;

-

-	if (m_ptr != NULL) free(m_ptr);

-

-	m_ptr = p;

-

-	return *this;

-}

-

-const CBotString& CBotString::operator+=(const CBotString& str)

-{

-	char*	p = (char*)malloc(m_lg+str.m_lg+1);

-

-	lstrcpy(p, m_ptr);

-	char*	pp = p + m_lg;

-	lstrcpy(pp, str.m_ptr);

-

-	m_lg = m_lg + str.m_lg;

-

-	if (m_ptr != NULL) free(m_ptr);

-

-	m_ptr = p;

-

-	return *this;

-}

-

-BOOL CBotString::operator==(const CBotString& str)

-{

-	return Compare(str) == 0;

-}

-

-BOOL CBotString::operator==(const char* p)

-{

-	return Compare(p) == 0;

-}

-

-BOOL CBotString::operator!=(const CBotString& str)

-{

-	return Compare(str) != 0;

-}

-

-BOOL CBotString::operator!=(const char* p)

-{

-	return Compare(p) != 0;

-}

-

-BOOL CBotString::operator>(const CBotString& str)

-{

-	return Compare(str) > 0;

-}

-

-BOOL CBotString::operator>(const char* p)

-{

-	return Compare(p) > 0;

-}

-

-BOOL CBotString::operator>=(const CBotString& str)

-{

-	return Compare(str) >= 0;

-}

-

-BOOL CBotString::operator>=(const char* p)

-{

-	return Compare(p) >= 0;

-}

-

-BOOL CBotString::operator<(const CBotString& str)

-{

-	return Compare(str) < 0;

-}

-

-BOOL CBotString::operator<(const char* p)

-{

-	return Compare(p) < 0;

-}

-

-BOOL CBotString::operator<=(const CBotString& str)

-{

-	return Compare(str) <= 0;

-}

-

-BOOL CBotString::operator<=(const char* p)

-{

-	return Compare(p) <= 0;

-}

-

-BOOL CBotString::IsEmpty() const

-{

-	return (m_lg == 0);

-}

-

-void CBotString::Empty()

-{

-	if (m_ptr != NULL) free(m_ptr);

-	m_ptr = NULL;

-	m_lg = 0;

-}

-

-static char	nilstring[] = {0};

-

-CBotString::operator LPCTSTR() const

-{

-	if (this == NULL || m_ptr == NULL) return nilstring;

-	return m_ptr;

-}

-

-

-int CBotString::Compare(LPCTSTR lpsz) const

-{

-	char*	p = m_ptr;

-	if (lpsz  == NULL) lpsz = nilstring;

-	if (m_ptr == NULL) p = nilstring;

-	return strcmp(p, lpsz);	// wcscmp 

-}

-

-

-

-///////////////////////////////////////////////////////////////////////////////////////////

-// tableaux de chaines

-

-CBotStringArray::CBotStringArray()

-{

-	m_pData = NULL;

-	m_nSize = m_nMaxSize = 0;

-}

-

-CBotStringArray::~CBotStringArray()

-{

-	SetSize(0);					// détruit les données !

-}

-

-

-int CBotStringArray::GivSize()

-{

-	return	m_nSize;

-}

-

-void CBotStringArray::Add(const CBotString& str)

-{

-	SetSize(m_nSize+1);

-

-	m_pData[m_nSize-1] = str;

-}

-

-

-///////////////////////////////////////////////////////////////////////

-// routines utilitaires

-

-static inline void ConstructElement(CBotString* pNewData)

-{

-	memset(pNewData, 0, sizeof(CBotString));

-}

-

-static inline void DestructElement(CBotString* pOldData)

-{

-	pOldData->~CBotString();

-}

-

-static inline void CopyElement(CBotString* pSrc, CBotString* pDest)

-{

-	*pSrc = *pDest;

-}

-

-static void ConstructElements(CBotString* pNewData, int nCount)

-{

-	while (nCount--)

-	{

-		ConstructElement(pNewData);

-		pNewData++;

-	}

-}

-

-static void DestructElements(CBotString* pOldData, int nCount)

-{

-	while (nCount--)

-	{

-		DestructElement(pOldData);

-		pOldData++;

-	}

-}

-

-static void CopyElements(CBotString* pDest, CBotString* pSrc, int nCount)

-{

-	while (nCount--)

-	{

-		*pDest = *pSrc;

-		++pDest;

-		++pSrc;

-	}

-}

-

-

-

-// sélect la taille du tableau

-

-void CBotStringArray::SetSize(int nNewSize)

-{

-	if (nNewSize == 0)

-	{

-		// shrink to nothing

-

-		DestructElements(m_pData, m_nSize);

-		delete[] (BYTE*)m_pData;

-		m_pData = NULL;

-		m_nSize = m_nMaxSize = 0;

-	}

-	else if (m_pData == NULL)

-	{

-		// create one with exact size

-		m_pData = (CBotString*) new BYTE[nNewSize * sizeof(CBotString)];

-

-		ConstructElements(m_pData, nNewSize);

-

-		m_nSize = m_nMaxSize = nNewSize;

-	}

-	else if (nNewSize <= m_nMaxSize)

-	{

-		// it fits

-		if (nNewSize > m_nSize)

-		{

-			// initialize the new elements

-

-			ConstructElements(&m_pData[m_nSize], nNewSize-m_nSize);

-

-		}

-

-		else if (m_nSize > nNewSize)  // destroy the old elements

-			DestructElements(&m_pData[nNewSize], m_nSize-nNewSize);

-

-		m_nSize = nNewSize;

-	}

-	else

-	{

-		// otherwise, grow array

-		int nGrowBy;

-		{

-			// heuristically determine growth when nGrowBy == 0

-			//  (this avoids heap fragmentation in many situations)

-			nGrowBy = min(1024, max(4, m_nSize / 8));

-		}

-		int nNewMax;

-		if (nNewSize < m_nMaxSize + nGrowBy)

-			nNewMax = m_nMaxSize + nGrowBy;  // granularity

-		else

-			nNewMax = nNewSize;  // no slush

-

-		CBotString* pNewData = (CBotString*) new BYTE[nNewMax * sizeof(CBotString)];

-

-		// copy new data from old

-		memcpy(pNewData, m_pData, m_nSize * sizeof(CBotString));

-

-		// construct remaining elements

-		ConstructElements(&pNewData[m_nSize], nNewSize-m_nSize);

-

-

-		// Ret rid of old stuff (note: no destructors called)

-		delete[] (BYTE*)m_pData;

-		m_pData = pNewData;

-		m_nSize = nNewSize;

-		m_nMaxSize = nNewMax;

-	}

-}

-

-

-CBotString& CBotStringArray::operator[](int nIndex)

-{

-	return ElementAt(nIndex);

-}

-

-CBotString& CBotStringArray::ElementAt(int nIndex)

-{

-	return m_pData[nIndex];

-}

-

-

-

+// * 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  http://www.gnu.org/licenses/.
+/////////////////////////////////////////////////////
+
+//strings management
+
+#include "CBot.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+
+//Map is filled with id-string pars that are needed for CBot language parsing
+const std::map<EID, char *> CBotString::s_keywordString =
+{
+    {ID_IF,         "if"},
+    {ID_ELSE,       "else"},
+    {ID_WHILE,      "while"},
+    {ID_DO,         "do"},
+    {ID_FOR,        "for"},
+    {ID_BREAK,      "break"},
+    {ID_CONTINUE,   "continue"},
+    {ID_SWITCH,     "switch"},
+    {ID_CASE,       "case"},
+    {ID_DEFAULT,    "default"},
+    {ID_TRY,        "try"},
+    {ID_THROW,      "throw"},
+    {ID_CATCH,      "catch"},
+    {ID_FINALLY,    "finally"},
+    {ID_TXT_AND,    "and"},
+    {ID_TXT_OR,     "or"},
+    {ID_TXT_NOT,    "not"},
+    {ID_RETURN,     "return"},
+    {ID_CLASS,      "class"},
+    {ID_EXTENDS,    "extends"},
+    {ID_SYNCHO,     "synchronized"},
+    {ID_NEW,        "new"},
+    {ID_PUBLIC,     "public"},
+    {ID_EXTERN,     "extern"},
+    {ID_FINAL,      "final"},
+    {ID_STATIC,     "static"},
+    {ID_PROTECTED,  "protected"},
+    {ID_PRIVATE,    "private"},
+    {ID_REPEAT,     "repeat"},
+    {ID_DEBUGDD,    "STARTDEBUGDD"},
+    {ID_INT,        "int"},
+    {ID_FLOAT,      "float"},
+    {ID_BOOLEAN,    "boolean"},
+    {ID_STRING,     "string"},
+    {ID_VOID,       "void"},
+    {ID_BOOL,       "bool"},
+    {ID_TRUE,       "true"},
+    {ID_FALSE,      "false"},
+    {ID_NULL,       "null"},
+    {ID_NAN,        "nan"},
+    {ID_OPENPAR,    "("},
+    {ID_CLOSEPAR,   ")"},
+    {ID_OPBLK,      "{"},
+    {ID_CLBLK,      "}"},
+    {ID_SEP,        "},"},
+    {ID_COMMA,      ","},
+    {ID_DOTS,       ":"},
+    {ID_DOT,        "."},
+    {ID_OPBRK,      "["},
+    {ID_CLBRK,      "]"},
+    {ID_DBLDOTS,    "::"},
+    {ID_LOGIC,      "?"},
+    {ID_ADD,        "+"},
+    {ID_SUB,        "-"},
+    {ID_MUL,        "*"},
+    {ID_DIV,        "/"},
+    {ID_ASS,        "="},
+    {ID_ASSADD,     "+="},
+    {ID_ASSSUB,     "-="},
+    {ID_ASSMUL,     "*="},
+    {ID_ASSDIV,     "/="},
+    {ID_ASSOR,      "|="},
+    {ID_ASSAND,     "&="},
+    {ID_ASSXOR,     "^="},
+    {ID_ASSSL,      "<<="},
+    {ID_ASSSR,      ">>>="},
+    {ID_ASSASR,     ">>="},
+    {ID_SL,         "<<"},
+    {ID_SR,         ">>"},
+    {ID_ASR,        ">>"},
+    {ID_INC,        "++"},
+    {ID_DEC,        "--"},
+    {ID_LO,         "<"},
+    {ID_HI,         ">"},
+    {ID_LS,         "<<"},
+    {ID_HS,         ">="},
+    {ID_EQ,         "=="},
+    {ID_NE,         "!="},
+    {ID_AND,        "&"},
+    {ID_XOR,        "^"},
+    {ID_OR,         "|"},
+    {ID_LOG_AND,    "&&"},
+    {ID_LOG_OR,     "||"},
+    {ID_LOG_NOT,    "!"},
+    {ID_NOT,        "~"},
+    {ID_MODULO,     "%"},
+    {ID_POWER,      "**"},
+    {ID_ASSMODULO,  "%="},
+    {ID_SUPER,      "super"},
+    {TX_UNDEF,      "undefined"},
+    {TX_NAN,        "not a number"}
+};
+
+CBotString::CBotString()
+{
+    m_ptr = NULL;
+    m_lg  = 0;
+}
+
+CBotString::~CBotString()
+{
+    free(m_ptr);            //we can call free on null pointer as it's save
+}
+
+
+CBotString::CBotString(const char* p)
+{
+    m_lg = strlen(p);
+
+    m_ptr = NULL;
+    if (m_lg>0)
+    {
+        m_ptr = (char*)malloc(m_lg+1);
+        strcpy(m_ptr, p);
+    }
+}
+
+CBotString::CBotString(const CBotString& srcString)
+{
+    m_lg = srcString.m_lg;
+
+    m_ptr = NULL;
+    if (m_lg>0)
+    {
+        m_ptr = (char*)malloc(m_lg+1);
+        strcpy(m_ptr, srcString.m_ptr);
+    }
+}
+
+
+
+
+int CBotString::GivLength()
+{
+    if (m_ptr == NULL) return 0;
+    return strlen( m_ptr ); 
+}
+
+
+
+CBotString CBotString::Left(int nCount) const
+{
+    char    chain[2000];
+
+    size_t i;
+    for (i = 0; i < m_lg && i < nCount && i < 1999; ++i)
+    {
+        chain[i] = m_ptr[i];
+    }
+    chain[i] = 0 ;
+
+    return CBotString(chain);
+}
+
+CBotString CBotString::Right(int nCount) const
+{
+    char chain[2000];
+
+    int i = m_lg - nCount;
+    if ( i < 0 ) i = 0;
+
+    size_t j;
+    for (size_t j = 0 ; i < m_lg && i < 1999; ++i)
+    {
+        chain[j++] = m_ptr[i];
+    }
+    chain[j] = 0 ;
+
+    return CBotString(chain);
+}
+
+CBotString CBotString::Mid(int nFirst, int nCount) const
+{
+    char chain[2000];
+
+    size_t i;
+    for (i = nFirst; i < m_lg && i < 1999 && i <= nFirst + nCount; ++i)
+    {
+        chain[i] = m_ptr[i];
+    }
+    chain[i] = 0 ;
+
+    return CBotString(chain);
+}
+
+CBotString CBotString::Mid(int nFirst) const
+{
+    char chain[2000];
+
+    size_t i;
+    for (i = nFirst; i < m_lg && i < 1999 ; ++i)
+    {
+        chain[i] = m_ptr[i];
+    }
+    chain[i] = 0 ;
+
+    return CBotString(chain);
+}
+
+
+int CBotString::Find(const char c)
+{
+    for (size_t i = 0; i < m_lg; ++i)
+    {
+        if (m_ptr[i] == c) return i;
+    }
+    return -1;
+}
+
+int CBotString::Find(const char * lpsz)
+{
+    int l = strlen(lpsz);
+
+    for (size_t i = 0; i <= m_lg-l; ++i)
+    {
+        for (size_t j = 0; j < l; ++j)
+        {
+            if (m_ptr[i+j] != lpsz[j]) goto bad;
+        }
+        return i;
+bad:;
+    }
+    return -1;
+}
+
+int CBotString::ReverseFind(const char c)
+{
+    int i;
+    for (i = m_lg-1; i >= 0; --i)
+    {
+        if (m_ptr[i] == c) return i;
+    }
+    return -1;
+}
+
+int CBotString::ReverseFind(const char * lpsz)
+{
+    int i, j;
+    int l = strlen(lpsz);
+
+    for (i = m_lg-l; i >= 0; --i)
+    {
+        for (j = 0; j < l; ++j)
+        {
+            if (m_ptr[i+j] != lpsz[j]) goto bad;
+        }
+        return i;
+bad:;
+    }
+    return -1;
+}
+
+CBotString CBotString::Mid(int start, int lg)
+{
+    CBotString res;
+    if (start >= m_lg) return res;
+
+    if ( lg < 0 ) lg = m_lg - start;
+
+    char* p = (char*)malloc(m_lg+1);
+    strcpy(p, m_ptr+start);
+    p[lg] = 0;
+
+    res = p;
+    free(p);
+    return res;
+}
+
+void CBotString::MakeUpper()
+{
+    for (size_t i = 0; i < m_lg && i < 1999 ; ++i)
+    {
+        char c = m_ptr[i];
+        if ( c >= 'a' && c <= 'z' ) m_ptr[i] = c - 'a' + 'A';
+    }
+}
+
+void CBotString::MakeLower()
+{
+    for (size_t i = 0; i < m_lg && i < 1999 ; ++i)
+    {
+        char    c = m_ptr[i];
+        if ( c >= 'A' && c <= 'Z' ) m_ptr[i] = c - 'A' + 'a';
+    }
+}
+
+bool CBotString::LoadString(unsigned int id)
+{
+    const char * str = NULL;
+    str = MapIdToString((EID)id);
+    if (m_ptr != NULL) free(m_ptr);
+
+    m_lg = strlen(str);
+    m_ptr = NULL;
+    if (m_lg > 0)
+    {
+        m_ptr = (char*)malloc(m_lg+1);
+        strcpy(m_ptr, str);
+        return true;
+    }
+    return false;
+}
+
+
+const CBotString& CBotString::operator=(const CBotString& stringSrc)
+{
+    free(m_ptr);
+    m_ptr = NULL;
+
+    m_lg = stringSrc.m_lg; 
+
+    if (m_lg > 0)
+    {
+        m_ptr = (char*)malloc(m_lg+1);
+        strcpy(m_ptr, stringSrc.m_ptr);
+    }
+
+    return *this;
+}
+
+CBotString operator+(const CBotString& string, const char * lpsz)
+{
+    CBotString s(string);
+    s += lpsz;
+    return s;
+}
+
+const CBotString& CBotString::operator+(const CBotString& stringSrc)
+{
+    char* p = (char*)malloc(m_lg+stringSrc.m_lg+1);
+
+    strcpy(p, m_ptr);
+    char* pp = p + m_lg;
+    strcpy(pp, stringSrc.m_ptr);
+
+    free(m_ptr);
+    m_ptr = p;
+    m_lg += stringSrc.m_lg;
+
+    return *this;
+}
+
+const CBotString& CBotString::operator=(const char ch)
+{
+    free(m_ptr);
+
+    m_lg = 1; 
+
+    m_ptr = (char*)malloc(2);
+    m_ptr[0] = ch;
+    m_ptr[1] = 0;
+
+    return *this;
+}
+
+const CBotString& CBotString::operator=(const char* pString)
+{
+    free(m_ptr);
+    m_ptr = NULL;
+
+    if (pString != NULL)
+    {
+        m_lg = strlen(pString); 
+
+        if (m_lg != 0)
+        {
+            m_ptr = (char*)malloc(m_lg+1);
+            strcpy(m_ptr, pString);
+        }
+    }
+
+    return *this;
+}
+
+
+const CBotString& CBotString::operator+=(const char ch)
+{
+    char* p = (char*)malloc(m_lg+2);
+
+    if (m_ptr!=NULL) strcpy(p, m_ptr);
+    p[m_lg++] = ch;
+    p[m_lg]   = 0;
+
+    free(m_ptr);
+
+    m_ptr = p;
+
+    return *this;
+}
+
+const CBotString& CBotString::operator+=(const CBotString& str)
+{
+    char* p = (char*)malloc(m_lg+str.m_lg+1);
+
+    strcpy(p, m_ptr);
+    char* pp = p + m_lg;
+    strcpy(pp, str.m_ptr);
+
+    m_lg = m_lg + str.m_lg;
+
+    free(m_ptr);
+
+    m_ptr = p;
+
+    return *this;
+}
+
+bool CBotString::operator==(const CBotString& str)
+{
+    return Compare(str) == 0;
+}
+
+bool CBotString::operator==(const char* p)
+{
+    return Compare(p) == 0;
+}
+
+bool CBotString::operator!=(const CBotString& str)
+{
+    return Compare(str) != 0;
+}
+
+bool CBotString::operator!=(const char* p)
+{
+    return Compare(p) != 0;
+}
+
+bool CBotString::operator>(const CBotString& str)
+{
+    return Compare(str) > 0;
+}
+
+bool CBotString::operator>(const char* p)
+{
+    return Compare(p) > 0;
+}
+
+bool CBotString::operator>=(const CBotString& str)
+{
+    return Compare(str) >= 0;
+}
+
+bool CBotString::operator>=(const char* p)
+{
+    return Compare(p) >= 0;
+}
+
+bool CBotString::operator<(const CBotString& str)
+{
+    return Compare(str) < 0;
+}
+
+bool CBotString::operator<(const char* p)
+{
+    return Compare(p) < 0;
+}
+
+bool CBotString::operator<=(const CBotString& str)
+{
+    return Compare(str) <= 0;
+}
+
+bool CBotString::operator<=(const char* p)
+{
+    return Compare(p) <= 0;
+}
+
+bool CBotString::IsEmpty() const
+{
+    return (m_lg == 0);
+}
+
+void CBotString::Empty()
+{
+    free(m_ptr);
+    m_ptr = NULL;
+    m_lg = 0;
+}
+
+static char emptyString[] = {0};
+
+CBotString::operator const char * () const
+{
+    if (this == NULL || m_ptr == NULL) return emptyString;
+    return m_ptr;
+}
+
+
+int CBotString::Compare(const char * lpsz) const
+{
+    char* p = m_ptr;
+    if (lpsz  == NULL) lpsz = emptyString;
+    if (m_ptr == NULL) p = emptyString;
+    return strcmp(p, lpsz);    // wcscmp 
+}
+
+const char * CBotString::MapIdToString(EID id)
+{
+    if (s_keywordString.find(id) != s_keywordString.end())
+    {
+        return s_keywordString.at(id);
+    }
+    else
+    {
+        return emptyString;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// arrays of strings
+
+CBotStringArray::CBotStringArray()
+{
+    m_pData = NULL;
+    m_nSize = m_nMaxSize = 0;
+}
+
+CBotStringArray::~CBotStringArray()
+{
+    SetSize(0);                    // destroys data !
+}
+
+
+int CBotStringArray::GivSize()
+{
+    return m_nSize;
+}
+
+void CBotStringArray::Add(const CBotString& str)
+{
+    SetSize(m_nSize+1);
+
+    m_pData[m_nSize-1] = str;
+}
+
+///////////////////////////////////////////////////////////////////////
+// utility routines
+
+static inline void ConstructElement(CBotString* pNewData)
+{
+    memset(pNewData, 0, sizeof(CBotString));
+}
+
+static inline void DestructElement(CBotString* pOldData)
+{
+    pOldData->~CBotString();
+}
+
+static inline void CopyElement(CBotString* pSrc, CBotString* pDest)
+{
+    *pSrc = *pDest;
+}
+
+static void ConstructElements(CBotString* pNewData, int nCount)
+{
+    while (nCount--)
+    {
+        ConstructElement(pNewData);
+        pNewData++;
+    }
+}
+
+static void DestructElements(CBotString* pOldData, int nCount)
+{
+    while (nCount--)
+    {
+        DestructElement(pOldData);
+        pOldData++;
+    }
+}
+
+static void CopyElements(CBotString* pDest, CBotString* pSrc, int nCount)
+{
+    while (nCount--)
+    {
+        *pDest = *pSrc;
+        ++pDest;
+        ++pSrc;
+    }
+}
+
+
+
+// set the array size
+
+void CBotStringArray::SetSize(int nNewSize)
+{
+    if (nNewSize == 0)
+    {
+        // shrink to nothing
+
+        DestructElements(m_pData, m_nSize);
+        delete[] (unsigned char *)m_pData;
+        m_pData = NULL;
+        m_nSize = m_nMaxSize = 0;
+    }
+    else if (m_pData == NULL)
+    {
+        // create one with exact size
+        m_pData = (CBotString*) new unsigned char[nNewSize * sizeof(CBotString)];
+
+        ConstructElements(m_pData, nNewSize);
+
+        m_nSize = m_nMaxSize = nNewSize;
+    }
+    else if (nNewSize <= m_nMaxSize)
+    {
+        // it fits
+        if (nNewSize > m_nSize)
+        {
+            // initialize the new elements
+
+            ConstructElements(&m_pData[m_nSize], nNewSize-m_nSize);
+
+        }
+
+        else if (m_nSize > nNewSize)  // destroy the old elements
+            DestructElements(&m_pData[nNewSize], m_nSize-nNewSize);
+
+        m_nSize = nNewSize;
+    }
+    else
+    {
+        // otherwise, grow array
+        int nGrowBy;
+        {
+            // heuristically determine growth when nGrowBy == 0
+            //  (this avoids heap fragmentation in many situations)
+            nGrowBy = std::min(1024, std::max(4, m_nSize / 8));
+        }
+        int nNewMax;
+        if (nNewSize < m_nMaxSize + nGrowBy)
+            nNewMax = m_nMaxSize + nGrowBy;  // granularity
+        else
+            nNewMax = nNewSize;  // no slush
+
+        CBotString* pNewData = (CBotString*) new unsigned char[nNewMax * sizeof(CBotString)];
+
+        // copy new data from old
+        memcpy(pNewData, m_pData, m_nSize * sizeof(CBotString));
+
+        // construct remaining elements
+        ConstructElements(&pNewData[m_nSize], nNewSize-m_nSize);
+
+
+        // Get rid of old stuff (note: no destructors called)
+        delete[] (unsigned char *)m_pData;
+        m_pData = pNewData;
+        m_nSize = nNewSize;
+        m_nMaxSize = nNewMax;
+    }
+}
+
+
+CBotString& CBotStringArray::operator[](int nIndex)
+{
+    return ElementAt(nIndex);
+}
+
+CBotString& CBotStringArray::ElementAt(int nIndex)
+{
+    return m_pData[nIndex];
+}
+
diff --git a/src/CBot/CBotToken.cpp b/src/CBot/CBotToken.cpp
index fbf6726..2c0bfae 100644
--- a/src/CBot/CBotToken.cpp
+++ b/src/CBot/CBotToken.cpp
@@ -1,554 +1,562 @@
-// * 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  http://www.gnu.org/licenses/.//////////////////////////////////////////////////////////////////

-// Gestion des Tokens

-// le texte d'un programme est d'abord transformé

-// en une suite de tokens pour facilité l'interprétation

-

-// il faudra traiter le seul cas d'erreur possible

-// qui est un caractère illégal dans une string

-

-

-#include "CBot.h"

-

-CBotStringArray CBotToken::m_ListKeyWords;

-int				CBotToken::m_ListIdKeyWords[200];

-CBotStringArray	CBotToken::m_ListKeyDefine;

-long			CBotToken::m_ListKeyNums[MAXDEFNUM];

-

-// constructeurs

-CBotToken::CBotToken()

-{

-	m_next	= NULL;

-	m_prev  = NULL;

-

-	m_type = TokenTypVar;			// à priori un nom d'une variable

-	m_IdKeyWord = -1;

-}

-

-CBotToken::CBotToken(const CBotToken* pSrc)

-{

-	m_next		= NULL;

-	m_prev		= NULL;

-

-	m_Text.Empty();

-	m_Sep.Empty();

-

-	m_type		= 0;

-	m_IdKeyWord = 0;

-

-	m_start		= 0;

-	m_end		= 0;

-

-	if ( pSrc != NULL )

-	{

-		m_Text		= pSrc->m_Text;

-		m_Sep		= pSrc->m_Sep;

-

-		m_type		= pSrc->m_type;

-		m_IdKeyWord = pSrc->m_IdKeyWord;

-

-		m_start		= pSrc->m_start;

-		m_end		= pSrc->m_end;

-	}

-}

-

-CBotToken::CBotToken(const CBotString& mot, const CBotString& sep, int start, int end)

-{

-	m_Text	= mot;					// mot trouvé comme token

-	m_Sep	= sep;					// séparateurs qui suivent

-	m_next	= NULL;

-	m_prev	= NULL;

-	m_start	= start;

-	m_end	= end;

-

-	m_type = TokenTypVar;			// à priori un nom d'une variable

-	m_IdKeyWord = -1;

-}

-

-CBotToken::CBotToken(const char* mot, const char* sep)

-{

-	m_Text	= mot;

-	if ( sep != NULL ) m_Sep = sep;

-	m_next	= NULL;

-	m_prev	= NULL;

-

-	m_type = TokenTypVar;			// à priori un nom d'une variable

-	m_IdKeyWord = -1;

-}

-

-CBotToken::~CBotToken()

-{

-	delete	m_next;					// récursif

-	m_next = NULL;

-}

-

-void CBotToken::Free()

-{

-	m_ListKeyDefine.SetSize(0);

-}

-

-const CBotToken& CBotToken::operator=(const CBotToken& src)

-{

-	if (m_next != NULL) delete(m_next);

-	m_next		= NULL;

-	m_prev		= NULL;

-

-	m_Text		= src.m_Text;

-	m_Sep		= src.m_Sep;

-

-	m_type		= src.m_type;

-	m_IdKeyWord = src.m_IdKeyWord;

-

-	m_start		= src.m_start;

-	m_end		= src.m_end;

-	return *this;

-}

-

-

-int CBotToken::GivType()

-{

-	if (this == NULL) return 0;

-	if (m_type == TokenTypKeyWord) return m_IdKeyWord;

-	return m_type;

-}

-

-long CBotToken::GivIdKey()

-{

-	return m_IdKeyWord;

-}

-

-CBotToken* CBotToken::GivNext()

-{

-	if (this == NULL) return NULL;

-	return		m_next;

-}

-

-CBotToken* CBotToken::GivPrev()

-{

-	if (this == NULL) return NULL;

-	return		m_prev;

-}

-

-void CBotToken::AddNext(CBotToken* p)

-{

-	CBotToken*	n = new CBotToken(p);

-	CBotToken*	pt = this;

-

-	while ( pt->m_next != NULL ) pt = pt->m_next;

-

-	pt->m_next = n;

-	n->m_prev = pt;

-}

-

-

-CBotString& CBotToken::GivString()

-{

-	return	m_Text;

-}

-

-CBotString& CBotToken::GivSep()

-{

-	return	m_Sep;

-}

-

-void CBotToken::SetString(const char* name)

-{

-	m_Text = name;

-}

-

-

-int CBotToken::GivStart()

-{

-	if (this == NULL) return -1;

-	return m_start;

-}

-

-int CBotToken::GivEnd()

-{

-	if (this == NULL) return -1;

-	return m_end;

-}

-

-void CBotToken::SetPos(int start, int end)

-{

-	m_start = start;

-	m_end	= end;

-}

-

-BOOL CharInList(const char c, const char* list)

-{

-	int		i = 0;

-

-	while (TRUE)

-	{

-		if (c == list[i++]) return TRUE;

-		if (list[i] == 0) return FALSE;

-	}

-}

-

-BOOL Char2InList(const char c, const char cc, const char* list)

-{

-	int		i = 0;

-

-	while (TRUE)

-	{

-		if (c == list[i++] &&

-			cc == list[i++]) return TRUE;

-

-		if (list[i] == 0) return FALSE;

-	}

-}

-

-static char*	sep1 = " \r\n\t,:()[]{}-+*/=;><!~^|&%.";

-static char*	sep2 = " \r\n\t";							// séparateurs pures

-static char*	sep3 = ",:()[]{}-+*/=;<>!~^|&%.";			// séparateurs opérationnels

-static char*	num	 = "0123456789";						// le point (unique) est testé séparément

-static char*	hexnum	 = "0123456789ABCDEFabcdef";

-static char*	nch	 = "\"\r\n\t";							// refusé dans les chaines

-

-//static char*	duo	 = "+=-=*=/===!=<=>=++--///**/||&&";// les opérateurs doubles

-

-// cherche le prochain token dans une phrase

-// ne doit pas commencer par des séparateurs

-// qui sont pris avec le token précédent

-CBotToken*	CBotToken::NextToken(char* &program, int& error, BOOL first)

-{

-	CBotString		mot;				// le mot trouvé

-	CBotString		sep;				// les séparateurs qui le suivent

-	char			c;

-	BOOL			stop = first;

-

-	if (*program == 0) return NULL;

-

-	c   = *(program++);					// prochain caractère

-

-	if (!first)

-	{

-		mot = c;							// construit le mot

-		c   = *(program++);					// prochain caractère

-

-		// cas particulier pour les chaînes de caractères

-		if ( mot[0] == '\"' )

-		{

-			while (c != 0 && !CharInList(c, nch))

-			{

-				mot += c;

-				c   = *(program++);					// prochain caractère

-				if ( c == '\\' )

-				{

-					c   = *(program++);					// prochain caractère

-					if ( c == 'n' ) c = '\n';

-					if ( c == 'r' ) c = '\r';

-					if ( c == 't' ) c = '\t';

-					mot += c;

-					c   = *(program++);					// prochain caractère

-				}

-			}

-			if ( c == '\"' )

-			{

-				mot += c;							// chaîne complète

-				c   = *(program++);					// prochain caractère

-			}

-			stop = TRUE;

-		}

-

-		// cas particulier pour les nombres

-		if ( CharInList(mot[0], num ))

-		{

-			BOOL	bdot = FALSE;	// trouvé un point ?

-			BOOL	bexp = FALSE;	// trouvé un exposant ?

-

-			char*	liste = num;

-			if (mot[0] == '0' && c == 'x')			// valeur hexadécimale ?

-			{

-				mot += c;

-				c   = *(program++);					// prochain caractère

-				liste = hexnum;

-			}

-cw:

-			while (c != 0 && CharInList(c, liste))

-			{

-cc:				mot += c;

-				c   = *(program++);					// prochain caractère

-			}

-			if ( liste == num )						// pas pour les exadécimaux

-			{

-				if ( !bdot && c == '.' ) { bdot = TRUE; goto cc; }

-				if ( !bexp && ( c == 'e' || c == 'E' ) )

-				{

-					bexp = TRUE;

-					mot += c;

-					c   = *(program++);					// prochain caractère

-					if ( c == '-' ||

-						 c == '+' ) goto cc;

-					goto cw;

-				}

-

-			}

-			stop = TRUE;

-		}

-

-		if (CharInList(mot[0], sep3))				// un séparateur opérationnel ?

-		{

-			CBotString	motc = mot;

-			while (motc += c, c != 0 && GivKeyWords(motc)>0)	// cherche l'opérande le plus long possible

-			{

-				mot += c;							// construit le mot

-				c = *(program++);					// prochain caractère

-			}

-

-			stop = TRUE;

-		}

-	}

-

-

-

-	while (TRUE)

-	{

-		if (stop || c == 0 || CharInList(c, sep1))

-		{

-			if (!first && mot.IsEmpty()) return NULL;	// fin de l'analyse

-bis:

-			while (CharInList(c, sep2))

-			{

-				sep += c;							// tous les séparateurs qui suivent

-				c = *(program++);

-			}

-			if (c == '/' && *program == '/')		// un commentaire dans le tas ?

-			{

-				while( c != '\n' && c != 0 )

-				{

-					sep += c;

-					c = *(program++);				// prochain caractère

-				}

-				goto bis;

-			}

-

-			if (c == '/' && *program == '*')		// un commentaire dans le tas ?

-			{

-				while( c != 0 && (c != '*' || *program != '/'))

-				{

-					sep += c;

-					c = *(program++);				// prochain caractère

-				}

-				if ( c != 0 )

-				{

-					sep += c;

-					c = *(program++);				// prochain caractère

-					sep += c;

-					c = *(program++);				// prochain caractère

-				}

-				goto bis;

-			}

-

-			program--;

-

-			CBotToken*	token = new CBotToken(mot, sep);

-

-			if (CharInList( mot[0], num )) token->m_type = TokenTypNum;

-			if (mot[0] == '\"')  token->m_type = TokenTypString;

-			if (first) token->m_type = 0;

-

-			token->m_IdKeyWord = GivKeyWords(mot);

-			if (token->m_IdKeyWord > 0) token->m_type = TokenTypKeyWord;

-			else GivKeyDefNum(mot, token) ;			// traite les DefineNum

-

-			return token;

-		}

-

-		mot += c;						// construit le mot

-		c = *(program++);				// prochain caractère

-	}

-}

-

-CBotToken* CBotToken::CompileTokens(const char* program, int& error)

-{

-	CBotToken		*nxt, *prv, *tokenbase;

-	char*			p = (char*) program;

-	int				pos = 0;

-

-	error = 0;

-	prv = tokenbase = NextToken(p, error, TRUE);

-

-	if (tokenbase == NULL) return NULL;

-

-	tokenbase->m_start	= pos;

-	pos += tokenbase->m_Text.GivLength();

-	tokenbase->m_end	= pos;

-	pos += tokenbase->m_Sep.GivLength();

-

-	char* pp = p;

-	while (NULL != (nxt = NextToken(p, error)))

-	{

-		prv->m_next = nxt;				// ajoute à la suite

-		nxt->m_prev = prv;

-		prv = nxt;						// avance

-

-		nxt->m_start	= pos;

-/*		pos += nxt->m_Text.GivLength();	// la chaîne peut être plus courte (BOA supprimés)

-		nxt->m_end	= pos;

-		pos += nxt->m_Sep.GivLength();*/

-		pos += (p - pp);				// taille totale

-		nxt->m_end	= pos - nxt->m_Sep.GivLength();

-		pp = p;

-	}

-

-	// ajoute un token comme terminateur

-	// ( utile pour avoir le précédent )

-	nxt = new CBotToken();

-	nxt->m_type = 0;

-	prv->m_next = nxt;				// ajoute à la suite

-	nxt->m_prev = prv;

-

-	return tokenbase;

-}

-

-void CBotToken::Delete(CBotToken* pToken)

-{

-	delete pToken;

-}

-

-

-// recherche si un mot fait parti des mots clefs

-

-int CBotToken::GivKeyWords(const char* w)

-{

-	int		i;

-	int		l = m_ListKeyWords.GivSize();

-

-	if (l == 0)

-	{

-		LoadKeyWords();							// prend la liste la première fois

-		l = m_ListKeyWords.GivSize();

-	}

-

-	for (i = 0; i < l; i++)

-	{

-		if (m_ListKeyWords[i] == w) return m_ListIdKeyWords[ i ];

-	}

-

-	return -1;

-}

-

-BOOL CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)

-{

-	int		i;

-	int		l = m_ListKeyDefine.GivSize();

-

-	for (i = 0; i < l; i++)

-	{

-		if (m_ListKeyDefine[i] == w)

-		{

-			token->m_IdKeyWord = m_ListKeyNums[i];

-			token->m_type      = TokenTypDef;

-			return TRUE;

-		}

-	}

-

-	return FALSE;

-}

-

-// reprend la liste des mots clefs dans les ressources

-

-void CBotToken::LoadKeyWords()

-{

-	CBotString		s;

-	int				i, n = 0;

-	

-	i = TokenKeyWord;

-	while (s.LoadString(i))

-	{

-		m_ListKeyWords.Add(s);

-		m_ListIdKeyWords[n++] = i++;

-	}

-

-	i = TokenKeyDeclare;

-	while (s.LoadString(i))

-	{

-		m_ListKeyWords.Add(s);

-		m_ListIdKeyWords[n++] = i++;

-	}

-

-

-	i = TokenKeyVal;

-	while (s.LoadString(i))

-	{

-		m_ListKeyWords.Add(s);

-		m_ListIdKeyWords[n++] = i++;

-	}

-

-	i = TokenKeyOp;

-	while (s.LoadString(i))

-	{

-		m_ListKeyWords.Add(s);

-		m_ListIdKeyWords[n++] = i++;

-	}

-}

-

-BOOL CBotToken::DefineNum(const char* name, long val)

-{

-	int		i;

-	int		l = m_ListKeyDefine.GivSize();

-

-	for (i = 0; i < l; i++)

-	{

-		if (m_ListKeyDefine[i] == name) return FALSE;

-	}

-	if ( i == MAXDEFNUM ) return FALSE;

-

-	m_ListKeyDefine.Add( name );

-	m_ListKeyNums[i] = val;

-	return TRUE;

-}

-

-BOOL IsOfType(CBotToken* &p, int type1, int type2)

-{

-	if (p->GivType() == type1 ||

-		p->GivType() == type2 )

-	{

-		p = p->GivNext();

-		return TRUE;

-	}

-	return FALSE;

-}

-

-// idem avec un nombre indéfini d'arguments

-// il faut mettre un zéro comme dernier argument

-BOOL IsOfTypeList(CBotToken* &p, int type1, ...)

-{

-	int		i = type1;

-	int		max = 20;

-	int		type = p->GivType();

-

-	va_list marker;

-	va_start( marker, type1 );     /* Initialize variable arguments. */

-

-	while (TRUE)

-	{

-		if (type == i)

-		{

-			p = p->GivNext();

-			va_end( marker );              /* Reset variable arguments.      */

-			return TRUE;

-		}

-		if (--max == 0 || 0 == (i = va_arg( marker, int)))

-		{

-		   va_end( marker );              /* Reset variable arguments.      */

-		   return FALSE;

-		}

-	}

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+
+//CBotToken.cpp
+
+//////////////////////////////////////////////////////////////////
+// Managing Tokens
+// the text of a program is first transformed
+// into a sequence of tokens for easy interpretation
+// it will only treat the case as an error
+// where there is an illegal character in a string
+
+
+#include "CBot.h"
+#include <cstdarg>
+
+CBotStringArray CBotToken::m_ListKeyWords;
+int CBotToken::m_ListIdKeyWords[200];
+CBotStringArray CBotToken::m_ListKeyDefine;
+long CBotToken::m_ListKeyNums[MAXDEFNUM];
+
+//! contructors
+CBotToken::CBotToken()
+{
+    m_next = NULL;
+    m_prev = NULL;
+    m_type = TokenTypVar;           // at the beginning a default variable type
+    m_IdKeyWord = -1;
+}
+
+CBotToken::CBotToken(const CBotToken* pSrc)
+{
+    m_next = NULL;
+    m_prev = NULL;
+
+    m_Text.Empty();
+    m_Sep.Empty();
+
+    m_type      = 0;
+    m_IdKeyWord = 0;
+
+    m_start     = 0;
+    m_end       = 0;
+
+    if ( pSrc != NULL )
+    {
+
+        m_type      = pSrc->m_type;
+        m_IdKeyWord = pSrc->m_IdKeyWord;
+
+        m_Text      = pSrc->m_Text;
+        m_Sep       = pSrc->m_Sep;
+
+        m_start     = pSrc->m_start;
+        m_end       = pSrc->m_end;
+    }
+}
+
+CBotToken::CBotToken(const CBotString& mot, const CBotString& sep, int start, int end)
+{
+    m_Text  = mot;                  // word (mot) found as token
+    m_Sep   = sep;                  // separator
+    m_next  = NULL;
+    m_prev  = NULL;
+    m_start = start;
+    m_end   = end;
+
+    m_type = TokenTypVar;           // at the beginning a default variable type
+    m_IdKeyWord = -1;
+}
+
+CBotToken::CBotToken(const char* mot, const char* sep)
+{
+    m_Text  = mot;
+    if ( sep != NULL ) m_Sep = sep;
+    m_next  = NULL;
+    m_prev  = NULL;
+
+    m_type = TokenTypVar;           // at the beginning a default variable type
+    m_IdKeyWord = -1;
+}
+
+CBotToken::~CBotToken()
+{
+    delete  m_next;                 // recursive
+    m_next = NULL;
+}
+
+void CBotToken::Free()
+{
+    m_ListKeyDefine.SetSize(0);
+}
+
+const CBotToken& CBotToken::operator=(const CBotToken& src)
+{
+    if (m_next != NULL) delete(m_next);
+    m_next      = NULL;
+    m_prev      = NULL;
+
+    m_Text      = src.m_Text;
+    m_Sep       = src.m_Sep;
+
+    m_type      = src.m_type;
+    m_IdKeyWord = src.m_IdKeyWord;
+
+    m_start     = src.m_start;
+    m_end       = src.m_end;
+    return *this;
+}
+
+
+int CBotToken::GivType()
+{
+    if (this == NULL) return 0;
+    if (m_type == TokenTypKeyWord) return m_IdKeyWord;
+    return m_type;
+}
+
+long CBotToken::GivIdKey()
+{
+    return m_IdKeyWord;
+}
+
+CBotToken* CBotToken::GivNext()
+{
+    if (this == NULL) return NULL;
+    return      m_next;
+}
+
+CBotToken* CBotToken::GivPrev()
+{
+    if (this == NULL) return NULL;
+    return      m_prev;
+}
+
+void CBotToken::AddNext(CBotToken* p)
+{
+    CBotToken*  n = new CBotToken(p);
+    CBotToken*  pt = this;
+
+    while ( pt->m_next != NULL ) pt = pt->m_next;
+
+    pt->m_next = n;
+    n->m_prev = pt;
+}
+
+
+CBotString& CBotToken::GivString()
+{
+    return  m_Text;
+}
+
+CBotString& CBotToken::GivSep()
+{
+    return  m_Sep;
+}
+
+void CBotToken::SetString(const char* name)
+{
+    m_Text = name;
+}
+
+
+int CBotToken::GivStart()
+{
+    if (this == NULL) return -1;
+    return m_start;
+}
+
+int CBotToken::GivEnd()
+{
+    if (this == NULL) return -1;
+    return m_end;
+}
+
+void CBotToken::SetPos(int start, int end)
+{
+    m_start = start;
+    m_end   = end;
+}
+
+bool CharInList(const char c, const char* list)
+{
+    int     i = 0;
+
+    while (true)
+    {
+        if (c == list[i++]) return true;
+        if (list[i] == 0) return false;
+    }
+}
+
+bool Char2InList(const char c, const char cc, const char* list)
+{
+    int     i = 0;
+
+    while (true)
+    {
+        if (c == list[i++] &&
+            cc == list[i++]) return true;
+
+        if (list[i] == 0) return false;
+    }
+}
+
+static char*    sep1 = " \r\n\t,:()[]{}-+*/=;><!~^|&%.";
+static char*    sep2 = " \r\n\t";                           // only separators
+static char*    sep3 = ",:()[]{}-+*/=;<>!~^|&%.";           // operational separators
+static char*    num  = "0123456789";                        // point (single) is tested separately
+static char*    hexnum   = "0123456789ABCDEFabcdef";
+static char*    nch  = "\"\r\n\t";                          // forbidden in chains
+
+//static char*  duo  = "+=-=*=/===!=<=>=++--///**/||&&";    // double operators
+
+// looking for the next token in a sentence
+// do not start with separators
+// which are made in the previous token
+CBotToken*  CBotToken::NextToken(char* &program, int& error, bool first)
+{
+    CBotString      mot;                // the word which is found
+    CBotString      sep;                // separators that are after
+    char            c;
+    bool            stop = first;
+
+    if (*program == 0) return NULL;
+
+    c   = *(program++);                 // next character
+
+    if (!first)
+    {
+        mot = c;                            // built the word
+        c   = *(program++);                 // next character
+
+        // special case for strings
+        if ( mot[0] == '\"' )
+        {
+            while (c != 0 && !CharInList(c, nch))
+            {
+                mot += c;
+                c   = *(program++);                 // next character
+                if ( c == '\\' )
+                {
+                    c   = *(program++);                 // next character
+                    if ( c == 'n' ) c = '\n';
+                    if ( c == 'r' ) c = '\r';
+                    if ( c == 't' ) c = '\t';
+                    mot += c;
+                    c   = *(program++);                 // next character
+                }
+            }
+            if ( c == '\"' )
+            {
+                mot += c;                           // string is complete
+                c   = *(program++);                 // next character
+            }
+            stop = true;
+        }
+
+        // special case for numbers
+        if ( CharInList(mot[0], num ))
+        {
+            bool    bdot = false;   // found a point?
+            bool    bexp = false;   // found an exponent?
+
+            char*   liste = num;
+            if (mot[0] == '0' && c == 'x')          // hexadecimal value?
+            {
+                mot += c;
+                c   = *(program++);                 // next character
+                liste = hexnum;
+            }
+cw:
+            while (c != 0 && CharInList(c, liste))
+            {
+cc:             mot += c;
+                c   = *(program++);                 // next character
+            }
+            if ( liste == num )                     // not for hexadecimal
+            {
+                if ( !bdot && c == '.' ) { bdot = true; goto cc; }
+                if ( !bexp && ( c == 'e' || c == 'E' ) )
+                {
+                    bexp = true;
+                    mot += c;
+                    c   = *(program++);                 // next character
+                    if ( c == '-' ||
+                         c == '+' ) goto cc;
+                    goto cw;
+                }
+
+            }
+            stop = true;
+        }
+
+        if (CharInList(mot[0], sep3))               // an operational separator?
+        {
+            CBotString  motc = mot;
+            while (motc += c, c != 0 && GivKeyWords(motc)>0)    // operand seeks the longest possible
+            {
+                mot += c;                           // build the word
+                c = *(program++);                   // next character
+            }
+
+            stop = true;
+        }
+    }
+
+
+
+    while (true)
+    {
+        if (stop || c == 0 || CharInList(c, sep1))
+        {
+            if (!first && mot.IsEmpty()) return NULL;   // end of the analysis
+bis:
+            while (CharInList(c, sep2))
+            {
+                sep += c;                           // after all the separators
+                c = *(program++);
+            }
+            if (c == '/' && *program == '/')        // comment on the heap?
+            {
+                while( c != '\n' && c != 0 )
+                {
+                    sep += c;
+                    c = *(program++);               // next character
+                }
+                goto bis;
+            }
+
+            if (c == '/' && *program == '*')        // comment on the heap?
+            {
+                while( c != 0 && (c != '*' || *program != '/'))
+                {
+                    sep += c;
+                    c = *(program++);               // next character
+                }
+                if ( c != 0 )
+                {
+                    sep += c;
+                    c = *(program++);               // next character
+                    sep += c;
+                    c = *(program++);               // next character
+                }
+                goto bis;
+            }
+
+            program--;
+
+            CBotToken*  token = new CBotToken(mot, sep);
+
+            if (CharInList( mot[0], num )) token->m_type = TokenTypNum;
+            if (mot[0] == '\"')  token->m_type = TokenTypString;
+            if (first) token->m_type = 0;
+
+            token->m_IdKeyWord = GivKeyWords(mot);
+            if (token->m_IdKeyWord > 0) token->m_type = TokenTypKeyWord;
+            else GivKeyDefNum(mot, token) ;         // treats DefineNum
+
+            return token;
+        }
+
+        mot += c;                       // built the word
+        c = *(program++);               // next character
+    }
+}
+
+CBotToken* CBotToken::CompileTokens(const char* program, int& error)
+{
+    CBotToken       *nxt, *prv, *tokenbase;
+    char*           p = (char*) program;
+    int             pos = 0;
+
+    error = 0;
+    prv = tokenbase = NextToken(p, error, true);
+
+    if (tokenbase == NULL) return NULL;
+
+    tokenbase->m_start  = pos;
+    pos += tokenbase->m_Text.GivLength();
+    tokenbase->m_end    = pos;
+    pos += tokenbase->m_Sep.GivLength();
+
+    char* pp = p;
+    while (NULL != (nxt = NextToken(p, error)))
+    {
+        prv->m_next = nxt;              // added after
+        nxt->m_prev = prv;
+        prv = nxt;                      // advance
+
+        nxt->m_start    = pos;
+/*      pos += nxt->m_Text.GivLength(); // chain may be shorter (BOA deleted)
+        nxt->m_end  = pos;
+        pos += nxt->m_Sep.GivLength();*/
+        pos += (p - pp);                // total size
+        nxt->m_end  = pos - nxt->m_Sep.GivLength();
+        pp = p;
+    }
+
+    // adds a token as a terminator
+    // ( useful for the previous )
+    nxt = new CBotToken();
+    nxt->m_type = 0;
+    prv->m_next = nxt;              // added after
+    nxt->m_prev = prv;
+
+    return tokenbase;
+}
+
+void CBotToken::Delete(CBotToken* pToken)
+{
+    delete pToken;
+}
+
+
+// search if a word is part of the keywords
+
+int CBotToken::GivKeyWords(const char* w)
+{
+    int     i;
+    int     l = m_ListKeyWords.GivSize();
+
+    if (l == 0)
+    {
+        LoadKeyWords();                         // takes the list for the first time
+        l = m_ListKeyWords.GivSize();
+    }
+
+    for (i = 0; i < l; i++)
+    {
+        if (m_ListKeyWords[i] == w) return m_ListIdKeyWords[ i ];
+    }
+
+    return -1;
+}
+
+bool CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
+{
+    int     i;
+    int     l = m_ListKeyDefine.GivSize();
+
+    for (i = 0; i < l; i++)
+    {
+        if (m_ListKeyDefine[i] == w)
+        {
+            token->m_IdKeyWord = m_ListKeyNums[i];
+            token->m_type      = TokenTypDef;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+/// \todo Fixme Figure out how this should work.
+
+// recreates the list of keywords and its IDs basing on some resources
+// defines of TokenKey.. are in CBotDll.h
+
+void CBotToken::LoadKeyWords()
+{
+    CBotString      s;
+    int             i, n = 0;
+    
+    i = TokenKeyWord; //start with keywords of the language
+    while (s.LoadString(i))
+    {
+        m_ListKeyWords.Add(s);
+        m_ListIdKeyWords[n++] = i++;
+    }
+
+    i = TokenKeyDeclare; //keywords of declarations
+    while (s.LoadString(i))
+    {
+        m_ListKeyWords.Add(s);
+        m_ListIdKeyWords[n++] = i++;
+    }
+
+
+    i = TokenKeyVal;  //keywords of values
+    while (s.LoadString(i))
+    {
+        m_ListKeyWords.Add(s);
+        m_ListIdKeyWords[n++] = i++;
+    }
+
+    i = TokenKeyOp; //operators
+    while (s.LoadString(i))
+    {
+        m_ListKeyWords.Add(s);
+        m_ListIdKeyWords[n++] = i++;
+    }
+}
+
+bool CBotToken::DefineNum(const char* name, long val)
+{
+    int     i;
+    int     l = m_ListKeyDefine.GivSize();
+
+    for (i = 0; i < l; i++)
+    {
+        if (m_ListKeyDefine[i] == name) return false;
+    }
+    if ( i == MAXDEFNUM ) return false;
+
+    m_ListKeyDefine.Add( name );
+    m_ListKeyNums[i] = val;
+    return true;
+}
+
+bool IsOfType(CBotToken* &p, int type1, int type2)
+{
+    if (p->GivType() == type1 ||
+        p->GivType() == type2 )
+    {
+        p = p->GivNext();
+        return true;
+    }
+    return false;
+}
+// Same with any number of arguments
+// There must be a zero as the last argument
+bool IsOfTypeList(CBotToken* &p, int type1, ...)
+{
+    int     i = type1;
+    int     max = 20;
+    int     type = p->GivType();
+
+    va_list marker;
+    va_start( marker, type1 );     /* Initialize variable arguments. */
+
+    while (true)
+    {
+        if (type == i)
+        {
+            p = p->GivNext();
+            va_end( marker );              /* Reset variable arguments.      */
+            return true;
+        }
+        if (--max == 0 || 0 == (i = va_arg( marker, int)))
+        {
+           va_end( marker );              /* Reset variable arguments.      */
+           return false;
+        }
+    }
+}
+
diff --git a/src/CBot/CBotToken.h b/src/CBot/CBotToken.h
index 2d92409..6f11bb2 100644
--- a/src/CBot/CBotToken.h
+++ b/src/CBot/CBotToken.h
@@ -1,37 +1,38 @@
-// * 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  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////

-// interpréteur pour le language CBot du jeu COLOBOT

-

-

-// un programme écrit est tout d'abord transformé en une liste de tokens

-// avant d'aborder le compilateur proprement dit

-// par exemple 

-// int var = 3 * ( pos.y + x )

-// est décomposé en (chaque ligne est un token)

-//		int

-//		var

-//		=

-//		3

-//		*

-//		(

-//		pos.y

-//		+

-//		x

-//		)

-

-

-extern BOOL IsOfType(CBotToken* &p, int type1, int type2 = -1);

-extern BOOL IsOfTypeList(CBotToken* &p, int type1, ...);

+// * 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  http://www.gnu.org/licenses/.
+
+
+// interpreter of the lanuage CBot for game COLOBOT
+// writing a program is first transformed into a list of tokens
+// before tackling the compiler itself
+// for example
+// int var = 3 * ( pos.y + x )
+// is decomposed into (each line is a token)
+//      int
+//      var
+//      =
+//      3
+//      *
+//      (
+//      pos.y
+//      +
+//      x
+//      )
+
+#pragma once
+
+extern bool IsOfType(CBotToken* &p, int type1, int type2 = -1);
+extern bool IsOfTypeList(CBotToken* &p, int type1, ...);
diff --git a/src/CBot/CBotTwoOpExpr.cpp b/src/CBot/CBotTwoOpExpr.cpp
index d8f4ee7..62290da 100644
--- a/src/CBot/CBotTwoOpExpr.cpp
+++ b/src/CBot/CBotTwoOpExpr.cpp
@@ -1,566 +1,568 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////

-// expression du genre Opérande1 + Opérande2

-//					   Opérande1 > Opérande2

-

-#include "CBot.h"

-

-// divers constructeurs

-

-CBotTwoOpExpr::CBotTwoOpExpr()

-{

-	m_leftop	=

-	m_rightop	= NULL;			// NULL pour pouvoir faire delete sans autre

-	name = "CBotTwoOpExpr";		// debug

-}

-

-CBotTwoOpExpr::~CBotTwoOpExpr()

-{

-	delete	m_leftop;

-	delete	m_rightop;

-}

-

-CBotLogicExpr::CBotLogicExpr()

-{

-	m_condition	=

-	m_op1		=

-	m_op2		= NULL;			// NULL pour pouvoir faire delete sans autre

-	name = "CBotLogicExpr";		// debug

-}

-

-CBotLogicExpr::~CBotLogicExpr()

-{

-	delete	m_condition;

-	delete	m_op1;

-	delete	m_op2;

-}

-

-

-// type d'opérandes acceptés par les opérations

-#define		ENTIER		((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))

-#define		FLOTANT		((1<<CBotTypFloat)|(1<<CBotTypDouble))

-#define		BOOLEEN		(1<<CBotTypBoolean)

-#define		CHAINE		(1<<CBotTypString)

-#define		POINTER		(1<<CBotTypPointer)

-#define		INSTANCE	(1<<CBotTypClass)

-

-// liste des opérations (précéance)

-//	type acceptable, opérande

-//	le zéro termine un niveau de précéance

-

-static int	ListOp[] = 

-{

-	BOOLEEN,				ID_LOGIC, 0,

-	BOOLEEN,				ID_TXT_OR, 

-	BOOLEEN,				ID_LOG_OR, 0,

-	BOOLEEN,				ID_TXT_AND,

-	BOOLEEN,				ID_LOG_AND, 0,

-	BOOLEEN|ENTIER,			ID_OR, 0,

-	BOOLEEN|ENTIER,			ID_XOR, 0,

-	BOOLEEN|ENTIER,			ID_AND, 0,

-	BOOLEEN|ENTIER|FLOTANT

-				  |CHAINE

-				  |POINTER

-				  |INSTANCE,ID_EQ, 

-	BOOLEEN|ENTIER|FLOTANT

-				  |CHAINE

-				  |POINTER

-				  |INSTANCE,ID_NE, 0,

-	ENTIER|FLOTANT|CHAINE,	ID_HI,

-	ENTIER|FLOTANT|CHAINE,	ID_LO,

-	ENTIER|FLOTANT|CHAINE,	ID_HS,

-	ENTIER|FLOTANT|CHAINE,	ID_LS, 0,

-	ENTIER,					ID_SR,

-	ENTIER,					ID_SL,

-	ENTIER,					ID_ASR, 0,

-	ENTIER|FLOTANT|CHAINE,	ID_ADD,

-	ENTIER|FLOTANT,			ID_SUB, 0,

-	ENTIER|FLOTANT,			ID_MUL, 

-	ENTIER|FLOTANT,			ID_DIV, 

-	ENTIER|FLOTANT,			ID_MODULO, 0,

-	ENTIER|FLOTANT,			ID_POWER, 0,

-	0,

-};

-

-BOOL IsInList( int val, int* list, int& typemasque )

-{

-	while (TRUE)

-	{

-		if ( *list == 0 ) return FALSE;

-		typemasque = *list++;

-		if ( *list++ == val ) return TRUE;

-	}

-}

-

-BOOL TypeOk( int type, int test )

-{

-	while (TRUE)

-	{

-		if ( type == 0 ) return (test & 1);

-		type--; test /= 2;

-	}

-}

-

-// compile une instruction de type A op B

-

-CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)

-{

-	int	typemasque;

-

-	if ( pOperations == NULL ) pOperations = ListOp;

-	int* pOp = pOperations;

-	while ( *pOp++ != 0 );				// suite de la table

-

-	CBotCStack* pStk = pStack->TokenStack();					// un bout de pile svp

-

-	// cherche des instructions qui peuvent convenir à gauche de l'opération

-	CBotInstr*	left = (*pOp == 0) ?

-						CBotParExpr::Compile( p, pStk ) :		// expression (...) à gauche

-						CBotTwoOpExpr::Compile( p, pStk, pOp );	// expression A * B à gauche

-

-	if (left == NULL) return pStack->Return(NULL, pStk);		// si erreur, la transmet

-

-	// est-ce qu'on a l'opérande prévu ensuite ?

-	int	TypeOp = p->GivType();

-	if ( IsInList( TypeOp, pOperations, typemasque ) )

-	{

-		CBotTypResult	 type1, type2;

-		type1 = pStk->GivTypResult();							// de quel type le premier opérande ?

-

-		if ( TypeOp == ID_LOGIC )		// cas spécial pour condition ? op1 : op2 ;

-		{

-			if ( !type1.Eq(CBotTypBoolean) )

-			{

-				pStk->SetError( TX_BADTYPE, p);

-				return pStack->Return(NULL, pStk);

-			}

-			CBotLogicExpr* inst = new CBotLogicExpr();

-			inst->m_condition = left;

-

-			p = p->GivNext();										// saute le token de l'opération 

-			inst->m_op1 = CBotExpression::Compile(p, pStk);

-			CBotToken* pp = p;

-			if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) )

-			{

-				pStk->SetError( TX_MISDOTS, p->GivStart());

-				delete inst;

-				return pStack->Return(NULL, pStk);

-			}

-			type1 = pStk->GivTypResult();

-

-			inst->m_op2 = CBotExpression::Compile(p, pStk);

-			if ( inst->m_op2 == NULL )

-			{

-				pStk->SetError( TX_ENDOF, p->GivStart() );

-				delete inst;

-				return pStack->Return(NULL, pStk);

-			}

-			type2 = pStk->GivTypResult();

-			if (!TypeCompatible(type1, type2))

-			{

-				pStk->SetError( TX_BAD2TYPE, pp );

-				delete inst;

-				return pStack->Return(NULL, pStk);

-			}

-

-			pStk->SetType(type1);		// le plus grand des 2 types

-

-			return pStack->Return(inst, pStk);

-		}

-

-		CBotTwoOpExpr* inst = new CBotTwoOpExpr();				// élément pour opération

-		inst->SetToken(p);										// mémorise l'opération

-

-

-		p = p->GivNext();											// saute le token de l'opération 

-

-		// cherche des instructions qui peuvent convenir à droite

-

-		if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) )

-																// expression (...) à droite

-		{

-			// il y a un second opérande acceptable

-

-			type2 = pStk->GivTypResult();						// de quel type le résultat ?

-

-			// quel est le type du résultat ?

-			int	TypeRes = MAX( type1.GivType(3), type2.GivType(3) );

-			if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )

-			{

-				TypeRes = CBotTypString;

-				type2 = type1;	// tout type convertible en chaîne

-			}

-			else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) )

-			{

-				TypeRes = CBotTypString;

-				type1 = type2;	// tout type convertible en chaîne

-			}

-			else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// erreur de type

-

-			switch ( TypeOp )

-			{

-			case ID_LOG_OR:

-			case ID_LOG_AND:

-			case ID_TXT_OR:

-			case ID_TXT_AND:

-			case ID_EQ:

-			case ID_NE:

-			case ID_HI:

-			case ID_LO:

-			case ID_HS:

-			case ID_LS:

-				TypeRes = CBotTypBoolean;

-			}

-			if ( TypeCompatible (type1, type2, TypeOp ) )				// les résultats sont-ils compatibles

-			{

-				// si ok, enregistre l'opérande dans l'objet

-				inst->m_leftop = left;

-

-				// spécial pour évaluer les opérations de même niveau de gauche à droite

-				while ( IsInList( p->GivType(), pOperations, typemasque ) ) // même(s) opération(s) suit ?

-				{

-					TypeOp = p->GivType();

-					CBotTwoOpExpr* i = new CBotTwoOpExpr();				// élément pour opération

-					i->SetToken(p);										// mémorise l'opération

-					i->m_leftop = inst;									// opérande de gauche

-					type1 = TypeRes;

-

-					p = p->GivNext();										// avance à la suite

-					i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );

-					type2 = pStk->GivTypResult();

-

-					if ( !TypeCompatible (type1, type2, TypeOp) )		// les résultats sont-ils compatibles

-					{

-						pStk->SetError(TX_BAD2TYPE, &i->m_token);

-						delete i;

-						return pStack->Return(NULL, pStk);

-					}

-

-					if ( TypeRes != CBotTypString )

-						TypeRes = MAX(type1.GivType(), type2.GivType());

-					inst = i;

-				}

-

-				CBotTypResult t(type1);

-					t.SetType(TypeRes);

-				// met une variable sur la pile pour avoir le type de résultat

-				pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t));

-

-				// et rend l'object à qui l'a demandé

-				return pStack->Return(inst, pStk);

-			}

-			pStk->SetError(TX_BAD2TYPE, &inst->m_token);

-		}

-

-		// en cas d'erreur, libère les éléments

-		delete left;

-		delete inst;

-		// et transmet l'erreur qui se trouve sur la pile

-		return pStack->Return(NULL, pStk);

-	}

-

-	// si on n'a pas affaire à une opération + ou -

-	// rend à qui l'a demandé, l'opérande (de gauche) trouvé

-	// à la place de l'objet "addition"

-	return pStack->Return(left, pStk);

-}

-

-

-BOOL IsNan(CBotVar* left, CBotVar* right, int* err = NULL)

-{

-	if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF )

-	{

-		if ( err != NULL ) *err = TX_OPNAN ;

-		return TRUE;

-	}

-	return FALSE;

-}

-

-

-// fait l'opération sur 2 opérandes

-

-BOOL CBotTwoOpExpr::Execute(CBotStack* &pStack)

-{

-	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-//	if ( pStk1 == EOX ) return TRUE;

-

-	// selon la reprise, on peut être dans l'un des 2 états

-

-	if ( pStk1->GivState() == 0 )					// 1er état, évalue l'opérande de gauche

-	{

-		if (!m_leftop->Execute(pStk1) ) return FALSE;	// interrompu ici ?

-

-		// pour les OU et ET logique, n'évalue pas la seconde expression si pas nécessaire

-		if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == FALSE )

-		{

-			CBotVar*	res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);

-			res->SetValInt(FALSE);

-			pStk1->SetVar(res);

-			return pStack->Return(pStk1);				// transmet le résultat

-		}

-		if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == TRUE )

-		{

-			CBotVar*	res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);

-			res->SetValInt(TRUE);

-			pStk1->SetVar(res);

-			return pStack->Return(pStk1);				// transmet le résultat

-		}

-

-		// passe à l'étape suivante

-		pStk1->SetState(1);			// prêt pour la suite

-	}

-

-

-	// demande un peu plus de stack pour ne pas toucher le résultat de gauche

-	// qui se trouve sur la pile, justement.

-

-	CBotStack* pStk2 = pStk1->AddStack();				// ajoute un élément à la pile

-														// ou le retrouve en cas de reprise

-

-	// 2e état, évalue l'opérande de droite

-	if ( pStk2->GivState() == 0 )

-	{

-		if ( !m_rightop->Execute(pStk2) ) return FALSE;		// interrompu ici ?

-		pStk2->IncState();

-	}

-

-	CBotTypResult		type1 = pStk1->GivTypResult();		// de quels types les résultats ?

-	CBotTypResult		type2 = pStk2->GivTypResult();

-

-	CBotStack* pStk3 = pStk2->AddStack(this);				// ajoute un élément à la pile

-	if ( pStk3->IfStep() ) return FALSE;					// montre l'opération si step by step

-

-	// crée une variable temporaire pour y mettre le résultat

-	// quel est le type du résultat ?

-	int	TypeRes = MAX(type1.GivType(), type2.GivType());

-

-	if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )

-	{

-		TypeRes = CBotTypString;

-	}

-

-	switch ( GivTokenType() )

-	{

-	case ID_LOG_OR:

-	case ID_LOG_AND:

-	case ID_TXT_OR:

-	case ID_TXT_AND:

-	case ID_EQ:

-	case ID_NE:

-	case ID_HI:

-	case ID_LO:

-	case ID_HS:

-	case ID_LS:

-		TypeRes = CBotTypBoolean;

-		break;

-	case ID_DIV:

-		TypeRes = MAX(TypeRes, CBotTypFloat);

-	}

-

-	// crée une variable pour le résultat

-	CBotVar*	result = CBotVar::Create( (CBotToken*)NULL, TypeRes);

-

-	// crée une variable pour effectuer le calcul dans le type adapté

-	TypeRes = MAX(type1.GivType(), type2.GivType());

-

-	if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )

-	{

-		TypeRes = CBotTypString;

-	}

-

-	CBotVar*	temp;

-

-	if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer;

-	if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GivClass() ) );

-	else						   temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );

-

-	int	err = 0;

-	// fait l'opération selon la demande

-	CBotVar*	left  = pStk1->GivVar();

-	CBotVar*	right = pStk2->GivVar();

-

-	switch (GivTokenType())

-	{

-	case ID_ADD:

-		if ( !IsNan(left, right, &err) )	result->Add(left , right);		// additionne

-		break;

-	case ID_SUB:

-		if ( !IsNan(left, right, &err) )	result->Sub(left , right);		// soustrait

-		break;

-	case ID_MUL:

-		if ( !IsNan(left, right, &err) )	result->Mul(left , right);		// multiplie

-		break;

-	case ID_POWER:

-		if ( !IsNan(left, right, &err) )	result->Power(left , right);	// puissance

-		break;

-	case ID_DIV:

-		if ( !IsNan(left, right, &err) )	err = result->Div(left , right);// divise

-		break;

-	case ID_MODULO:

-		if ( !IsNan(left, right, &err) )	err = result->Modulo(left , right);// reste de division

-		break;

-	case ID_LO:

-		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Lo(left , right));	// inférieur

-		break;

-	case ID_HI:

-		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Hi(left , right));	// supérieur

-		break;

-	case ID_LS:

-		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Ls(left , right));	// inférieur ou égal

-		break;

-	case ID_HS:

-		if ( !IsNan(left, right, &err) )

-			result->SetValInt(temp->Hs(left , right));	// supérieur ou égal

-		break;

-	case ID_EQ:

-		if ( IsNan(left, right) )

-			result->SetValInt(left->GivInit() ==  right->GivInit()) ;

-		else

-			result->SetValInt(temp->Eq(left , right));	// égal

-		break;

-	case ID_NE:

-		if ( IsNan(left, right) )

-			 result->SetValInt(left ->GivInit() !=  right->GivInit()) ;

-		else

-			result->SetValInt(temp->Ne(left , right));	// différent

-		break;

-	case ID_TXT_AND:

-	case ID_LOG_AND:

-	case ID_AND:

-		if ( !IsNan(left, right, &err) )	result->And(left , right);		// ET

-		break;

-	case ID_TXT_OR:

-	case ID_LOG_OR:

-	case ID_OR:

-		if ( !IsNan(left, right, &err) )	result->Or(left , right);		// OU

-		break;

-	case ID_XOR:

-		if ( !IsNan(left, right, &err) )	result->XOr(left , right);		// OU exclusif

-		break;

-	case ID_ASR:

-		if ( !IsNan(left, right, &err) )	result->ASR(left , right);

-		break;

-	case ID_SR:

-		if ( !IsNan(left, right, &err) )	result->SR(left , right);

-		break;

-	case ID_SL:

-		if ( !IsNan(left, right, &err) )	result->SL(left , right);

-		break;

-	default:

-		ASM_TRAP();

-	}

-	delete temp;

-

-	pStk2->SetVar(result);						// met le résultat sur la pile

-	if ( err ) pStk2->SetError(err, &m_token);	// et l'erreur éventuelle (division par zéro)

-

-//	pStk1->Return(pStk2);						// libère la pile

-	return pStack->Return(pStk2);				// transmet le résultat

-}

-

-void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, BOOL bMain)

-{

-	if ( !bMain ) return;

-	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un élément à la pile

-	if ( pStk1 == NULL ) return;

-

-	// selon la reprise, on peut être dans l'un des 2 états

-

-	if ( pStk1->GivState() == 0 )					// 1er état, évalue l'opérande de gauche

-	{

-		m_leftop->RestoreState(pStk1, bMain);		// interrompu ici !

-		return;

-	}

-

-	CBotStack* pStk2 = pStk1->RestoreStack();			// ajoute un élément à la pile

-	if ( pStk2 == NULL ) return;

-

-	// 2e état, évalue l'opérande de droite

-	if ( pStk2->GivState() == 0 )

-	{

-		m_rightop->RestoreState(pStk2, bMain);			// interrompu ici !

-		return;

-	}

-}

-

-

-BOOL CBotLogicExpr::Execute(CBotStack* &pStack)

-{

-	CBotStack* pStk1 = pStack->AddStack(this);	// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-//	if ( pStk1 == EOX ) return TRUE;

-

-	if ( pStk1->GivState() == 0 )

-	{

-		if ( !m_condition->Execute(pStk1) ) return FALSE;

-		if (!pStk1->SetState(1)) return FALSE;

-	}

-

-	if ( pStk1->GivVal() == TRUE )

-	{

-		if ( !m_op1->Execute(pStk1) ) return FALSE;

-	}

-	else

-	{

-		if ( !m_op2->Execute(pStk1) ) return FALSE;

-	}

-

-	return pStack->Return(pStk1);					// transmet le résultat

-}

-

-void CBotLogicExpr::RestoreState(CBotStack* &pStack, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack* pStk1 = pStack->RestoreStack(this);	// ajoute un élément à la pile

-	if ( pStk1 == NULL ) return;

-

-	if ( pStk1->GivState() == 0 )

-	{

-		m_condition->RestoreState(pStk1, bMain);

-		return;

-	}

-

-	if ( pStk1->GivVal() == TRUE )

-	{

-		m_op1->RestoreState(pStk1, bMain);

-	}

-	else

-	{

-		m_op2->RestoreState(pStk1, bMain);

-	}

-}

-

-#if 0

-void t()

-{

-	int x,y;

-	1>0 ? x = 0 : y = 0;

-}

-#endif

-

-#if 01

-void t(BOOL t)

-{

-	int	 x;

-	x = 1 + t ? 1 : 3 + 4 * 2 ;

-	t ? 0 : "test";

-}

-#endif

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////
+// expression of type  Opérande1 + Opérande2
+//                     Opérande1 > Opérande2
+
+#include "CBot.h"
+
+// various constructors
+
+CBotTwoOpExpr::CBotTwoOpExpr()
+{
+    m_leftop    =
+    m_rightop   = NULL;         // NULL to be able to delete without other
+    name = "CBotTwoOpExpr";     // debug
+}
+
+CBotTwoOpExpr::~CBotTwoOpExpr()
+{
+    delete  m_leftop;
+    delete  m_rightop;
+}
+
+CBotLogicExpr::CBotLogicExpr()
+{
+    m_condition =
+    m_op1       =
+    m_op2       = NULL;         // NULL to be able to delete without other
+    name = "CBotLogicExpr";     // debug
+}
+
+CBotLogicExpr::~CBotLogicExpr()
+{
+    delete  m_condition;
+    delete  m_op1;
+    delete  m_op2;
+}
+
+
+// type of operands accepted by operations
+#define     ENTIER      ((1<<CBotTypByte)|(1<<CBotTypShort)|(1<<CBotTypChar)|(1<<CBotTypInt)|(1<<CBotTypLong))
+#define     FLOTANT     ((1<<CBotTypFloat)|(1<<CBotTypDouble))
+#define     BOOLEEN     (1<<CBotTypBoolean)
+#define     CHAINE      (1<<CBotTypString)
+#define     POINTER     (1<<CBotTypPointer)
+#define     INSTANCE    (1<<CBotTypClass)
+
+// list of operations (précéance)
+//  acceptable type, operand
+//  zero ends level \TODO précéance
+
+static int  ListOp[] = 
+{
+    BOOLEEN,                ID_LOGIC, 0,
+    BOOLEEN,                ID_TXT_OR, 
+    BOOLEEN,                ID_LOG_OR, 0,
+    BOOLEEN,                ID_TXT_AND,
+    BOOLEEN,                ID_LOG_AND, 0,
+    BOOLEEN|ENTIER,         ID_OR, 0,
+    BOOLEEN|ENTIER,         ID_XOR, 0,
+    BOOLEEN|ENTIER,         ID_AND, 0,
+    BOOLEEN|ENTIER|FLOTANT
+                  |CHAINE
+                  |POINTER
+                  |INSTANCE,ID_EQ, 
+    BOOLEEN|ENTIER|FLOTANT
+                  |CHAINE
+                  |POINTER
+                  |INSTANCE,ID_NE, 0,
+    ENTIER|FLOTANT|CHAINE,  ID_HI,
+    ENTIER|FLOTANT|CHAINE,  ID_LO,
+    ENTIER|FLOTANT|CHAINE,  ID_HS,
+    ENTIER|FLOTANT|CHAINE,  ID_LS, 0,
+    ENTIER,                 ID_SR,
+    ENTIER,                 ID_SL,
+    ENTIER,                 ID_ASR, 0,
+    ENTIER|FLOTANT|CHAINE,  ID_ADD,
+    ENTIER|FLOTANT,         ID_SUB, 0,
+    ENTIER|FLOTANT,         ID_MUL, 
+    ENTIER|FLOTANT,         ID_DIV, 
+    ENTIER|FLOTANT,         ID_MODULO, 0,
+    ENTIER|FLOTANT,         ID_POWER, 0,
+    0,
+};
+
+bool IsInList( int val, int* list, int& typemasque )
+{
+    while (true)
+    {
+        if ( *list == 0 ) return false;
+        typemasque = *list++;
+        if ( *list++ == val ) return true;
+    }
+}
+
+bool TypeOk( int type, int test )
+{
+    while (true)
+    {
+        if ( type == 0 ) return (test & 1);
+        type--; test /= 2;
+    }
+}
+
+// compiles a instruction of type A op B
+
+CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations)
+{
+    int typemasque;
+
+    if ( pOperations == NULL ) pOperations = ListOp;
+    int* pOp = pOperations;
+    while ( *pOp++ != 0 );              // follows the table
+
+    CBotCStack* pStk = pStack->TokenStack();                    // one end of stack please
+
+    // search the intructions that may be suitable to the left of the operation
+    CBotInstr*  left = (*pOp == 0) ?
+                        CBotParExpr::Compile( p, pStk ) :       // expression (...) left
+                        CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B left
+
+    if (left == NULL) return pStack->Return(NULL, pStk);        // if error,  transmit
+
+    // did we expected the operand?
+    int TypeOp = p->GivType();
+    if ( IsInList( TypeOp, pOperations, typemasque ) )
+    {
+        CBotTypResult    type1, type2;
+        type1 = pStk->GivTypResult();                           // what kind of the first operand?
+
+        if ( TypeOp == ID_LOGIC )       // special case provided for: ? op1: op2;
+        {
+            if ( !type1.Eq(CBotTypBoolean) )
+            {
+                pStk->SetError( TX_BADTYPE, p);
+                return pStack->Return(NULL, pStk);
+            }
+            CBotLogicExpr* inst = new CBotLogicExpr();
+            inst->m_condition = left;
+
+            p = p->GivNext();                                       // skip the token of the operation
+            inst->m_op1 = CBotExpression::Compile(p, pStk);
+            CBotToken* pp = p;
+            if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) )
+            {
+                pStk->SetError( TX_MISDOTS, p->GivStart());
+                delete inst;
+                return pStack->Return(NULL, pStk);
+            }
+            type1 = pStk->GivTypResult();
+
+            inst->m_op2 = CBotExpression::Compile(p, pStk);
+            if ( inst->m_op2 == NULL )
+            {
+                pStk->SetError( TX_ENDOF, p->GivStart() );
+                delete inst;
+                return pStack->Return(NULL, pStk);
+            }
+            type2 = pStk->GivTypResult();
+            if (!TypeCompatible(type1, type2))
+            {
+                pStk->SetError( TX_BAD2TYPE, pp );
+                delete inst;
+                return pStack->Return(NULL, pStk);
+            }
+
+            pStk->SetType(type1);       // the greatest of 2 types
+
+            return pStack->Return(inst, pStk);
+        }
+
+        CBotTwoOpExpr* inst = new CBotTwoOpExpr();              // element for operation
+        inst->SetToken(p);                                      // stores the operation
+
+
+        p = p->GivNext();                                           // skip the token of the operation
+
+        // looking statements that may be suitable for right
+
+        if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) )
+                                                                // expression (...) right
+        {
+            // there is an second operand acceptable 
+
+            type2 = pStk->GivTypResult();                       // what kind of results?
+
+            // what kind of result?
+            int TypeRes = MAX( type1.GivType(3), type2.GivType(3) );
+            if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )
+            {
+                TypeRes = CBotTypString;
+                type2 = type1;  // any type convertible chain
+            }
+            else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) )
+            {
+                TypeRes = CBotTypString;
+                type1 = type2;  // any type convertible chain
+            }
+            else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// error of type
+
+            switch ( TypeOp )
+            {
+            case ID_LOG_OR:
+            case ID_LOG_AND:
+            case ID_TXT_OR:
+            case ID_TXT_AND:
+            case ID_EQ:
+            case ID_NE:
+            case ID_HI:
+            case ID_LO:
+            case ID_HS:
+            case ID_LS:
+                TypeRes = CBotTypBoolean;
+            }
+            if ( TypeCompatible (type1, type2, TypeOp ) )               // the results are compatible
+            {
+                // ok so, saves the operand in the object
+                inst->m_leftop = left;
+
+                // special for evaluation of the operations of the same level from left to right
+                while ( IsInList( p->GivType(), pOperations, typemasque ) ) // same operation(s) follows?
+                {
+                    TypeOp = p->GivType();
+                    CBotTwoOpExpr* i = new CBotTwoOpExpr();             // element for operation
+                    i->SetToken(p);                                     // stores the operation
+                    i->m_leftop = inst;                                 // left operand
+                    type1 = TypeRes;
+
+                    p = p->GivNext();                                       // advance after
+                    i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );
+                    type2 = pStk->GivTypResult();
+
+                    if ( !TypeCompatible (type1, type2, TypeOp) )       // the results are compatible
+                    {
+                        pStk->SetError(TX_BAD2TYPE, &i->m_token);
+                        delete i;
+                        return pStack->Return(NULL, pStk);
+                    }
+
+                    if ( TypeRes != CBotTypString )
+                        TypeRes = MAX(type1.GivType(), type2.GivType());
+                    inst = i;
+                }
+
+                CBotTypResult t(type1);
+                    t.SetType(TypeRes);
+                // is a variable on the stack for the type of result
+                pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t));
+
+                // and returns the requested object
+                return pStack->Return(inst, pStk);
+            }
+            pStk->SetError(TX_BAD2TYPE, &inst->m_token);
+        }
+
+        // in case of error, releases the elements
+        delete left;
+        delete inst;
+        // and transmits the error to the stack
+        return pStack->Return(NULL, pStk);
+    }
+
+    // if we are not dealing with an operation + or -
+    // goes to that requested, the operand (left) found
+    // instead of the object "addition"
+    return pStack->Return(left, pStk);
+}
+
+
+bool IsNan(CBotVar* left, CBotVar* right, int* err = NULL)
+{
+    if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF )
+    {
+        if ( err != NULL ) *err = TX_OPNAN ;
+        return true;
+    }
+    return false;
+}
+
+
+// performes the operation on two operands
+
+bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
+{
+    CBotStack* pStk1 = pStack->AddStack(this);  // adds an item to the stack
+                                                // or return in case of recovery
+//  if ( pStk1 == EOX ) return true;
+
+    // according to recovery, it may be in one of two states
+
+    if ( pStk1->GivState() == 0 )                   // first state, evaluates the left operand
+    {
+        if (!m_leftop->Execute(pStk1) ) return false;   // interrupted here?
+
+        // for OR and AND logic does not evaluate the second expression if not necessary
+        if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == false )
+        {
+            CBotVar*    res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
+            res->SetValInt(false);
+            pStk1->SetVar(res);
+            return pStack->Return(pStk1);               // transmits the result
+        }
+        if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == true )
+        {
+            CBotVar*    res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
+            res->SetValInt(true);
+            pStk1->SetVar(res);
+            return pStack->Return(pStk1);               // transmits the result
+        }
+
+        // passes to the next step
+        pStk1->SetState(1);         // ready for further
+    }
+
+
+    // requires a little more stack to avoid touching the result 
+    // of which is left on the stack, precisely
+
+    CBotStack* pStk2 = pStk1->AddStack();               // adds an item to the stack
+                                                        // or return in case of recovery
+
+    // 2e état, évalue l'opérande de droite
+    if ( pStk2->GivState() == 0 )
+    {
+        if ( !m_rightop->Execute(pStk2) ) return false;     // interrupted here?
+        pStk2->IncState();
+    }
+
+    CBotTypResult       type1 = pStk1->GivTypResult();      // what kind of results?
+    CBotTypResult       type2 = pStk2->GivTypResult();
+
+    CBotStack* pStk3 = pStk2->AddStack(this);               // adds an item to the stack
+    if ( pStk3->IfStep() ) return false;                    // shows the operation if step by step
+
+    // creates a temporary variable to put the result
+    // what kind of result?
+    int TypeRes = MAX(type1.GivType(), type2.GivType());
+
+    if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
+    {
+        TypeRes = CBotTypString;
+    }
+
+    switch ( GivTokenType() )
+    {
+    case ID_LOG_OR:
+    case ID_LOG_AND:
+    case ID_TXT_OR:
+    case ID_TXT_AND:
+    case ID_EQ:
+    case ID_NE:
+    case ID_HI:
+    case ID_LO:
+    case ID_HS:
+    case ID_LS:
+        TypeRes = CBotTypBoolean;
+        break;
+    case ID_DIV:
+        TypeRes = MAX(TypeRes, CBotTypFloat);
+    }
+
+    // creates a variable for the result
+    CBotVar*    result = CBotVar::Create( (CBotToken*)NULL, TypeRes);
+
+    // creates a variable to perform the calculation in the appropriate type
+    TypeRes = MAX(type1.GivType(), type2.GivType());
+
+    if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
+    {
+        TypeRes = CBotTypString;
+    }
+
+    CBotVar*    temp;
+
+    if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer;
+    if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GivClass() ) );
+    else                           temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );
+
+    int err = 0;
+    // is a operation according to request
+    CBotVar*    left  = pStk1->GivVar();
+    CBotVar*    right = pStk2->GivVar();
+
+    switch (GivTokenType())
+    {
+    case ID_ADD:
+        if ( !IsNan(left, right, &err) )    result->Add(left , right);      // addition
+        break;
+    case ID_SUB:
+        if ( !IsNan(left, right, &err) )    result->Sub(left , right);      // substraction
+        break;
+    case ID_MUL:
+        if ( !IsNan(left, right, &err) )    result->Mul(left , right);      // multiplies
+        break;
+    case ID_POWER:
+        if ( !IsNan(left, right, &err) )    result->Power(left , right);    // power
+        break;
+    case ID_DIV:
+        if ( !IsNan(left, right, &err) )    err = result->Div(left , right);// division
+        break;
+    case ID_MODULO:
+        if ( !IsNan(left, right, &err) )    err = result->Modulo(left , right);// remainder of division
+        break;
+    case ID_LO:
+        if ( !IsNan(left, right, &err) )
+            result->SetValInt(temp->Lo(left , right));  // lower
+        break;
+    case ID_HI:
+        if ( !IsNan(left, right, &err) )
+            result->SetValInt(temp->Hi(left , right));  // top
+        break;
+    case ID_LS:
+        if ( !IsNan(left, right, &err) )
+            result->SetValInt(temp->Ls(left , right));  // less than or equal
+        break;
+    case ID_HS:
+        if ( !IsNan(left, right, &err) )
+            result->SetValInt(temp->Hs(left , right));  // greater than or equal
+        break;
+    case ID_EQ:
+        if ( IsNan(left, right) )
+            result->SetValInt(left->GivInit() ==  right->GivInit()) ;
+        else
+            result->SetValInt(temp->Eq(left , right));  // equal
+        break;
+    case ID_NE:
+        if ( IsNan(left, right) )
+             result->SetValInt(left ->GivInit() !=  right->GivInit()) ;
+        else
+            result->SetValInt(temp->Ne(left , right));  // different
+        break;
+    case ID_TXT_AND:
+    case ID_LOG_AND:
+    case ID_AND:
+        if ( !IsNan(left, right, &err) )    result->And(left , right);      // AND
+        break;
+    case ID_TXT_OR:
+    case ID_LOG_OR:
+    case ID_OR:
+        if ( !IsNan(left, right, &err) )    result->Or(left , right);       // OR
+        break;
+    case ID_XOR:
+        if ( !IsNan(left, right, &err) )    result->XOr(left , right);      // exclusive OR
+        break;
+    case ID_ASR:
+        if ( !IsNan(left, right, &err) )    result->ASR(left , right);
+        break;
+    case ID_SR:
+        if ( !IsNan(left, right, &err) )    result->SR(left , right);
+        break;
+    case ID_SL:
+        if ( !IsNan(left, right, &err) )    result->SL(left , right);
+        break;
+    default:
+        ASM_TRAP();
+    }
+    delete temp;
+
+    pStk2->SetVar(result);                      // puts the result on the stack
+    if ( err ) pStk2->SetError(err, &m_token);  // and the possible error (division by zero)
+
+//  pStk1->Return(pStk2);                       // releases the stack
+    return pStack->Return(pStk2);               // transmits the result
+}
+
+void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, bool bMain)
+{
+    if ( !bMain ) return;
+    CBotStack* pStk1 = pStack->RestoreStack(this);  // adds an item to the stack
+    if ( pStk1 == NULL ) return;
+
+    // according to recovery, it may be in one of two states
+
+    if ( pStk1->GivState() == 0 )                   // first state, evaluates the left operand
+    {
+        m_leftop->RestoreState(pStk1, bMain);       // interrupted here!
+        return;
+    }
+
+    CBotStack* pStk2 = pStk1->RestoreStack();           // adds an item to the stack
+    if ( pStk2 == NULL ) return;
+
+    // second state, evaluates the right operand
+    if ( pStk2->GivState() == 0 )
+    {
+        m_rightop->RestoreState(pStk2, bMain);          // interrupted here!
+        return;
+    }
+}
+
+
+bool CBotLogicExpr::Execute(CBotStack* &pStack)
+{
+    CBotStack* pStk1 = pStack->AddStack(this);  // adds an item to the stack
+                                                // or return in case of recovery
+//  if ( pStk1 == EOX ) return true;
+
+    if ( pStk1->GivState() == 0 )
+    {
+        if ( !m_condition->Execute(pStk1) ) return false;
+        if (!pStk1->SetState(1)) return false;
+    }
+
+    if ( pStk1->GivVal() == true )
+    {
+        if ( !m_op1->Execute(pStk1) ) return false;
+    }
+    else
+    {
+        if ( !m_op2->Execute(pStk1) ) return false;
+    }
+
+    return pStack->Return(pStk1);                   // transmits the result
+}
+
+void CBotLogicExpr::RestoreState(CBotStack* &pStack, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack* pStk1 = pStack->RestoreStack(this);  // adds an item to the stack
+    if ( pStk1 == NULL ) return;
+
+    if ( pStk1->GivState() == 0 )
+    {
+        m_condition->RestoreState(pStk1, bMain);
+        return;
+    }
+
+    if ( pStk1->GivVal() == true )
+    {
+        m_op1->RestoreState(pStk1, bMain);
+    }
+    else
+    {
+        m_op2->RestoreState(pStk1, bMain);
+    }
+}
+
+#if 0
+void t()
+{
+    int x,y;
+    1>0 ? x = 0 : y = 0;
+}
+#endif
+
+#if 01
+void t(bool t)
+{
+    int  x;
+    x = 1 + t ? 1 : 3 + 4 * 2 ;
+    t ? 0 : "test";
+}
+#endif
diff --git a/src/CBot/CBotVar.cpp b/src/CBot/CBotVar.cpp
index 37c8fb4..0d9bfb3 100644
--- a/src/CBot/CBotVar.cpp
+++ b/src/CBot/CBotVar.cpp
@@ -1,2245 +1,2248 @@
-// * 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  http://www.gnu.org/licenses/.////////////////////////////////////////////////////////////////////

-// 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

-

-

-#include "CBot.h"

-#include <math.h>

-#include <stdio.h>

-

-long CBotVar::m_identcpt = 0;

-

-CBotVar::CBotVar( )

-{

-	m_next	= NULL;

-	m_pMyThis = NULL;

-	m_pUserPtr = NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_type  = -1;

-	m_binit = FALSE;

-	m_ident = 0;

-	m_bStatic = FALSE;

-	m_mPrivate = 0;

-}

-

-CBotVarInt::CBotVarInt( const CBotToken* name )

-{

-	m_token	= new CBotToken(name);

-	m_next	= NULL;

-	m_pMyThis = NULL;

-	m_pUserPtr = NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_type  = CBotTypInt;

-	m_binit = FALSE;

-	m_bStatic = FALSE;

-	m_mPrivate = 0;

-

-	m_val	= 0;

-}

-

-CBotVarFloat::CBotVarFloat( const CBotToken* name )

-{

-	m_token	= new CBotToken(name);

-	m_next	= NULL;

-	m_pMyThis = NULL;

-	m_pUserPtr = NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_type  = CBotTypFloat;

-	m_binit = FALSE;

-	m_bStatic = FALSE;

-	m_mPrivate = 0;

-

-	m_val	= 0;

-}

-

-CBotVarString::CBotVarString( const CBotToken* name )

-{

-	m_token	= new CBotToken(name);

-	m_next	= NULL;

-	m_pMyThis = NULL;

-	m_pUserPtr = NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_type  = CBotTypString;

-	m_binit = FALSE;

-	m_bStatic = FALSE;

-	m_mPrivate = 0;

-

-	m_val.Empty();

-}

-

-CBotVarBoolean::CBotVarBoolean( const CBotToken* name )

-{

-	m_token		= new CBotToken(name);

-	m_next		= NULL;

-	m_pMyThis	= NULL;

-	m_pUserPtr	= NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_type		= CBotTypBoolean;

-	m_binit		= FALSE;

-	m_bStatic = FALSE;

-	m_mPrivate = 0;

-

-	m_val		= 0;

-}

-

-CBotVarClass* CBotVarClass::m_ExClass = NULL;

-

-CBotVarClass::CBotVarClass( const CBotToken* name, const CBotTypResult& type)

-{

-/*

-//	int	nIdent = 0;

-	InitCBotVarClass( name, type ) //, nIdent );

-}

-

-CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int &nIdent )

-{

-	InitCBotVarClass( name, type ); //, nIdent );

-}

-

-void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )

-{*/

-	if ( !type.Eq(CBotTypClass)        &&

-		 !type.Eq(CBotTypIntrinsic)    &&				// par comodité accepte ces types

-		 !type.Eq(CBotTypPointer)      &&

-		 !type.Eq(CBotTypArrayPointer) &&

-		 !type.Eq(CBotTypArrayBody)) ASM_TRAP();

-

-	m_token		= new CBotToken(name);

-	m_next		= NULL;

-	m_pMyThis	= NULL;

-	m_pUserPtr	= OBJECTCREATED;//NULL;

-	m_InitExpr = NULL;

-	m_LimExpr = NULL;

-	m_pVar		= NULL;

-	m_type		= type;

-	if ( type.Eq(CBotTypArrayPointer) )    m_type.SetType( CBotTypArrayBody );	

-	else if ( !type.Eq(CBotTypArrayBody) ) m_type.SetType( CBotTypClass );	

-					 							// type officel pour cet object

-

-	m_pClass	= NULL;

-	m_pParent	= NULL;

-	m_binit		= FALSE;

-	m_bStatic	= FALSE;

-	m_mPrivate	= 0;

-	m_bConstructor = FALSE;

-	m_CptUse	= 0;

-	m_ItemIdent = type.Eq(CBotTypIntrinsic) ? 0 : CBotVar::NextUniqNum();

-

-	// se place tout seul dans la liste

-	if (m_ExClass) m_ExClass->m_ExPrev = this;

-	m_ExNext  = m_ExClass;

-	m_ExPrev  = NULL;

-	m_ExClass = this;

-

-	CBotClass* pClass = type.GivClass();

-	CBotClass* pClass2 = pClass->GivParent();

-	if ( pClass2 != NULL )

-	{

-		// crée également une instance dans la classe père

-		m_pParent = new CBotVarClass(name, CBotTypResult(type.GivType(),pClass2) ); //, nIdent);

-	}

-

-	SetClass( pClass ); //, nIdent );

-

-}

-

-CBotVarClass::~CBotVarClass( )

-{

-	if ( m_CptUse != 0 )

-		ASM_TRAP();

-

-	if ( m_pParent ) delete m_pParent;

-	m_pParent = NULL;

-

-	// libère l'objet indirect s'il y a lieu

-//	if ( m_Indirect != NULL )

-//		m_Indirect->DecrementUse();

-

-	// retire la classe de la liste

-	if ( m_ExPrev ) m_ExPrev->m_ExNext = m_ExNext;

-	else m_ExClass = m_ExNext;

-

-	if ( m_ExNext ) m_ExNext->m_ExPrev = m_ExPrev;

-	m_ExPrev = NULL;

-	m_ExNext = NULL;

-

-	delete	m_pVar;

-}

-

-void CBotVarClass::ConstructorSet()

-{

-	m_bConstructor = TRUE;

-}

-

-

-CBotVar::~CBotVar( )

-{

-	delete  m_token;

-	delete	m_next;

-}

-

-void CBotVar::debug()

-{

-	const char*	p = (LPCTSTR) m_token->GivString();

-	CBotString  s = (LPCTSTR) GivValString();

-	const char* v = (LPCTSTR) s;

-

-	if ( m_type.Eq(CBotTypClass) )

-	{

-		CBotVar*	pv = ((CBotVarClass*)this)->m_pVar;

-		while (pv != NULL)

-		{

-			pv->debug();

-			pv = pv->GivNext();

-		}

-	}

-}

-

-void CBotVar::ConstructorSet()

-{

-	// nop

-}

-

-void CBotVar::SetUserPtr(void* pUser)

-{

-	m_pUserPtr = pUser;

-	if (m_type.Eq(CBotTypPointer) &&

-		((CBotVarPointer*)this)->m_pVarClass != NULL )

-		((CBotVarPointer*)this)->m_pVarClass->SetUserPtr(pUser);

-}

-

-void CBotVar::SetIdent(long n)

-{

-	if (m_type.Eq(CBotTypPointer) &&

-		((CBotVarPointer*)this)->m_pVarClass != NULL )

-		((CBotVarPointer*)this)->m_pVarClass->SetIdent(n);

-}

-

-void CBotVar::SetUniqNum(long n)

-{

-	m_ident = n;

-

-	if ( n == 0 ) ASM_TRAP();

-}

-

-long CBotVar::NextUniqNum()

-{

-	if (++m_identcpt < 10000) m_identcpt = 10000;

-	return m_identcpt;

-}

-

-long CBotVar::GivUniqNum()

-{

-	return m_ident;

-}

-

-

-void* CBotVar::GivUserPtr()

-{

-	return m_pUserPtr;

-}

-

-BOOL CBotVar::Save1State(FILE* pf)

-{

-	// 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_TRAP();

-	return FALSE;

-}

-

-void CBotVar::Maj(void* pUser, BOOL bContinu)

-{

-/*	if (!bContinu && m_pMyThis != NULL)

-		m_pMyThis->Maj(pUser, TRUE);*/

-}

-

-

-// crée une variable selon son type

-

-CBotVar* CBotVar::Create(const CBotToken* name, int type )

-{

-	CBotTypResult	t(type);

-	return Create(name, t);

-}

-

-CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type)

-{

-	switch (type.GivType())

-	{

-	case CBotTypShort:

-	case CBotTypInt:

-		return new CBotVarInt(name);

-	case CBotTypFloat:

-		return new CBotVarFloat(name);

-	case CBotTypBoolean:

-		return new CBotVarBoolean(name);

-	case CBotTypString:

-		return new CBotVarString(name);

-	case CBotTypPointer:

-	case CBotTypNullPointer:

-		return new CBotVarPointer(name, type);

-	case CBotTypIntrinsic:

-		return new CBotVarClass(name, type);

-

-	case CBotTypClass:

-		// crée une nouvelle instance d'une classe

-		// et retourne le POINTER sur cette instance

-		{

-			CBotVarClass* instance = new CBotVarClass(name, type);

-			CBotVarPointer* pointer = new CBotVarPointer(name, type);

-			pointer->SetPointer( instance );

-			return pointer;

-		}

-

-	case CBotTypArrayPointer:

-		return new CBotVarArray(name, type);

-

-	case CBotTypArrayBody:

-		{

-			CBotVarClass* instance = new CBotVarClass(name, type);

-			CBotVarArray* array = new CBotVarArray(name, type);

-			array->SetPointer( instance );

-

-			CBotVar*	pv = array;

-			while (type.Eq(CBotTypArrayBody))

-			{

-				type = type.GivTypElem();

-				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crée au moins l'élément [0]

-			}

-

-			return array;

-		}

-	}

-

-	ASM_TRAP();

-	return NULL;

-}

-

-CBotVar* CBotVar::Create( CBotVar* pVar )

-{

-	CBotVar*	p = Create(pVar->m_token->GivString(), pVar->GivTypResult(2));

-	return p;

-}

-

-

-CBotVar* CBotVar::Create( const char* n, CBotTypResult type)

-{

-	CBotToken	name(n);

-

-	switch (type.GivType())

-	{

-	case CBotTypShort:

-	case CBotTypInt:

-		return new CBotVarInt(&name);

-	case CBotTypFloat:

-		return new CBotVarFloat(&name);

-	case CBotTypBoolean:

-		return new CBotVarBoolean(&name);

-	case CBotTypString:

-		return new CBotVarString(&name);

-	case CBotTypPointer:

-	case CBotTypNullPointer:

-		{

-			CBotVarPointer* p = new CBotVarPointer(&name, type);

-//			p->SetClass(type.GivClass());

-			return p;

-		}

-	case CBotTypIntrinsic:

-		{

-			CBotVarClass* p = new CBotVarClass(&name, type);

-//			p->SetClass(type.GivClass());

-			return p;

-		}

-

-	case CBotTypClass:

-		// crée une nouvelle instance d'une classe

-		// et retourne le POINTER sur cette instance

-		{

-			CBotVarClass* instance = new CBotVarClass(&name, type);

-			CBotVarPointer* pointer = new CBotVarPointer(&name, type);

-			pointer->SetPointer( instance );

-//			pointer->SetClass( type.GivClass() );

-			return pointer;

-		}

-

-	case CBotTypArrayPointer:

-		return new CBotVarArray(&name, type);

-

-	case CBotTypArrayBody:

-		{

-			CBotVarClass* instance = new CBotVarClass(&name, type);

-			CBotVarArray* array = new CBotVarArray(&name, type);

-			array->SetPointer( instance );

-		

-			CBotVar*	pv = array;

-			while (type.Eq(CBotTypArrayBody))

-			{

-				type = type.GivTypElem();

-				pv = ((CBotVarArray*)pv)->GivItem(0, TRUE);			// crée au moins l'élément [0]

-			}

-

-			return array;

-		}

-	}

-

-	ASM_TRAP();

-	return NULL;

-}

-

-CBotVar* CBotVar::Create( const char* name, int type, CBotClass* pClass)

-{

-	CBotToken	token( name, "" );

-	CBotVar*	pVar = Create( &token, type );

-	

-	if ( type == CBotTypPointer && pClass == NULL )		// pointeur "null" ?

-		return pVar;

-

-	if ( type == CBotTypClass || type == CBotTypPointer ||

-		 type == CBotTypIntrinsic )

-	{

-		if (pClass == NULL) 

-		{

-			delete pVar;

-			return NULL;

-		}

-		pVar->SetClass( pClass );

-	}

-	return pVar;

-}

-

-CBotVar* CBotVar::Create( const char* name, CBotClass* pClass)

-{

-	CBotToken	token( name, "" );

-	CBotVar*	pVar = Create( &token, CBotTypResult( CBotTypClass, pClass ) );

-//	pVar->SetClass( pClass );

-	return		pVar;

-}

-

-CBotTypResult CBotVar::GivTypResult(int mode)

-{

-	CBotTypResult	r = m_type;

-

-	if ( mode == 1 && m_type.Eq(CBotTypClass) ) 

-		r.SetType(CBotTypPointer);

-	if ( mode == 2 && m_type.Eq(CBotTypClass) ) 

-		r.SetType(CBotTypIntrinsic);

-

-	return r;

-}

-

-int CBotVar::GivType(int mode)

-{

-	if ( mode == 1 && m_type.Eq(CBotTypClass) ) 

-		return CBotTypPointer;

-	if ( mode == 2 && m_type.Eq(CBotTypClass) ) 

-		return CBotTypIntrinsic;

-	return m_type.GivType();

-}

-

-void CBotVar::SetType(CBotTypResult& type)

-{

-	m_type = type;

-}

-

-

-int CBotVar::GivInit()

-{

-	if (  m_type.Eq(CBotTypClass) ) return IS_DEF;		// toujours défini !

-

-	return	m_binit;

-}

-

-void CBotVar::SetInit(BOOL bInit)

-{

-	m_binit = bInit;

-	if ( bInit == 2 ) m_binit = IS_DEF;					// cas spécial

-

-	if ( m_type.Eq(CBotTypPointer) && bInit == 2 )

-	{

-		CBotVarClass* instance = GivPointer();

-		if ( instance == NULL )

-		{

-			instance = new CBotVarClass(NULL, m_type);

-//			instance->SetClass(((CBotVarPointer*)this)->m_pClass);

-			SetPointer(instance);

-		}

-		instance->SetInit(1);

-	}

-

-	if ( m_type.Eq(CBotTypClass) || m_type.Eq(CBotTypIntrinsic) )

-	{

-		CBotVar*	p = ((CBotVarClass*)this)->m_pVar;

-		while( p != NULL )

-		{

-			p->SetInit( bInit );

-			p->m_pMyThis = (CBotVarClass*)this;

-			p = p->GivNext();

-		}

-	}

-}

-

-CBotString CBotVar::GivName()

-{

-	return	m_token->GivString();

-}

-

-void CBotVar::SetName(const char* name)

-{

-	m_token->SetString(name);

-}

-

-CBotToken* CBotVar::GivToken()

-{

-	return	m_token;

-}

-

-CBotVar* CBotVar::GivItem(const char* name)

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-CBotVar* CBotVar::GivItemRef(int nIdent)

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-CBotVar* CBotVar::GivItemList()

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-CBotVar* CBotVar::GivItem(int row, BOOL bGrow)

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-// dit si une variable appartient à une classe donnée

-BOOL CBotVar::IsElemOfClass(const char* name)

-{

-	CBotClass*	pc = NULL;

-

-	if ( m_type.Eq(CBotTypPointer) )

-	{

-		pc = ((CBotVarPointer*)this)->m_pClass;

-	}

-	if ( m_type.Eq(CBotTypClass) )

-	{

-		pc = ((CBotVarClass*)this)->m_pClass;

-	}

-

-	while ( pc != NULL )

-	{

-		if ( pc->GivName() == name ) return TRUE;

-		pc = pc->GivParent();

-	}

-

-	return FALSE;

-}

-

-

-CBotVar* CBotVar::GivStaticVar()

-{

-	// rend le pointeur à la variable si elle est statique

-	if ( m_bStatic == 0 || m_pMyThis == NULL ) return this;

-

-	CBotClass*	pClass = m_pMyThis->GivClass();

-	return pClass->GivItem( m_token->GivString() );

-}

-

-

-CBotVar* CBotVar::GivNext()

-{

-	return m_next;

-}

-

-void CBotVar::AddNext(CBotVar* pVar)

-{

-	CBotVar*	p = this;

-	while (p->m_next != NULL) p = p->m_next;

-

-	p->m_next = pVar;

-}

-

-void CBotVar::SetVal(CBotVar* var)

-{

-	switch (/*var->*/GivType())

-	{

-	case CBotTypBoolean:

-		SetValInt(var->GivValInt());

-		break;

-	case CBotTypInt:

-		SetValInt(var->GivValInt(), ((CBotVarInt*)var)->m_defnum);

-		break;

-	case CBotTypFloat:

-		SetValFloat(var->GivValFloat());

-		break;

-	case CBotTypString:

-		SetValString(var->GivValString());

-		break;

-	case CBotTypPointer:

-	case CBotTypNullPointer:

-	case CBotTypArrayPointer:

-		SetPointer(var->GivPointer());

-		break;

-	case CBotTypClass:

-		{

-			delete ((CBotVarClass*)this)->m_pVar;

-			((CBotVarClass*)this)->m_pVar = NULL;

-			Copy(var, FALSE);

-		}

-		break;

-	default:

-		ASM_TRAP();

-	}

-

-	m_binit = var->m_binit;		// copie l'état nan s'il y a 

-}

-

-void CBotVar::SetStatic(BOOL bStatic)

-{

-	m_bStatic = bStatic;

-}

-

-void CBotVar::SetPrivate(int mPrivate)

-{

-	m_mPrivate = mPrivate;

-}

-

-BOOL CBotVar::IsStatic()

-{

-	return m_bStatic;

-}

-

-BOOL CBotVar::IsPrivate(int mode)

-{

-	return m_mPrivate >= mode;

-}

-

-int CBotVar::GivPrivate()

-{

-	return m_mPrivate;

-}

-

-

-void CBotVar::SetPointer(CBotVar* pVarClass)

-{

-	ASM_TRAP();

-}

-

-CBotVarClass* CBotVar::GivPointer()

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-// toutes ces fonctions doivent être définies dans les classes filles 

-// dérivées de la classe CBotVar

-

-int CBotVar::GivValInt()

-{

-	ASM_TRAP();

-	return 0;

-}

-

-float CBotVar::GivValFloat()

-{

-	ASM_TRAP();

-	return 0;

-}

-

-void CBotVar::SetValInt(int c, const char* s)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::SetValFloat(float c)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Mul(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Power(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-int CBotVar::Div(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return 0;

-}

-

-int CBotVar::Modulo(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return 0;

-}

-

-void CBotVar::Add(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Sub(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-BOOL CBotVar::Lo(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-BOOL CBotVar::Hi(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-BOOL CBotVar::Ls(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-BOOL CBotVar::Hs(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-BOOL CBotVar::Eq(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-BOOL CBotVar::Ne(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-	return FALSE;

-}

-

-void CBotVar::And(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Or(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::XOr(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::ASR(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::SR(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::SL(CBotVar* left, CBotVar* right)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Neg()

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Not()

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Inc()

-{

-	ASM_TRAP();

-}

-void CBotVar::Dec()

-{

-	ASM_TRAP();

-}

-

-void CBotVar::Copy(CBotVar* pSrc, BOOL bName)

-{

-	ASM_TRAP();

-}

-

-void CBotVar::SetValString(const char* p)

-{

-	ASM_TRAP();

-}

-

-CBotString CBotVar::GivValString()

-{

-	ASM_TRAP();

-	return CBotString();

-}

-

-void CBotVar::SetClass(CBotClass* pClass)

-{

-	ASM_TRAP();

-}

-

-CBotClass* CBotVar::GivClass()

-{

-	ASM_TRAP();

-	return NULL;

-}

-

-/*

-void CBotVar::SetIndirection(CBotVar* pVar)

-{

-	// nop, uniquement pour CBotVarPointer::SetIndirection

-}

-*/

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-// copie une variable dans une autre

-void CBotVarInt::Copy(CBotVar* pSrc, BOOL bName)

-{

-	CBotVarInt*	p = (CBotVarInt*)pSrc;

-

-	if ( bName) *m_token	= *p->m_token;

-	m_type		= p->m_type;

-	m_val		= p->m_val;

-	m_binit		= p->m_binit;

-	m_pMyThis	= NULL;

-	m_pUserPtr	= p->m_pUserPtr;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-

-	m_defnum	= p->m_defnum;

-}

-

-

-

-

-void CBotVarInt::SetValInt(int val, const char* defnum)

-{

-	m_val = val;

-	m_binit	= TRUE;

-	m_defnum = defnum;

-}

-

-

-

-void CBotVarInt::SetValFloat(float val)

-{

-	m_val = (int)val;

-	m_binit	= TRUE;

-}

-

-int CBotVarInt::GivValInt()

-{

-	return	m_val;

-}

-

-float CBotVarInt::GivValFloat()

-{

-	return (float)m_val;

-}

-

-CBotString CBotVarInt::GivValString()

-{

-	if ( !m_defnum.IsEmpty() ) return m_defnum;

-

-	CBotString res;

-

-	if ( !m_binit )

-	{

-		res.LoadString(TX_UNDEF);

-		return res;

-	}

-	if ( m_binit == IS_NAN )

-	{

-		res.LoadString(TX_NAN);

-		return res;

-	}

-

-	char		buffer[300];

-	sprintf(buffer, "%d", m_val);

-	res = buffer;

-

-	return	res;

-}

-

-

-void CBotVarInt::Mul(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() * right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::Power(CBotVar* left, CBotVar* right)

-{

-	m_val = (int) pow( (double) left->GivValInt() , (double) right->GivValInt() );

-	m_binit = TRUE;

-}

-

-int CBotVarInt::Div(CBotVar* left, CBotVar* right)

-{

-	int	r = right->GivValInt();

-	if ( r != 0 )

-	{

-		m_val = left->GivValInt() / r;

-		m_binit = TRUE;

-	}

-	return ( r == 0 ? TX_DIVZERO : 0 );

-}

-

-int CBotVarInt::Modulo(CBotVar* left, CBotVar* right)

-{

-	int	r = right->GivValInt();

-	if ( r != 0 )

-	{

-		m_val = left->GivValInt() % r;

-		m_binit = TRUE;

-	}

-	return ( r == 0 ? TX_DIVZERO : 0 );

-}

-

-void CBotVarInt::Add(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() + right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::Sub(CBotVar* left, CBotVar* right)

-{

-		m_val = left->GivValInt() - right->GivValInt();

-		m_binit = TRUE;

-}

-

-void CBotVarInt::XOr(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() ^ right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::And(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() & right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::Or(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() | right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::SL(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() << right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::ASR(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() >> right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarInt::SR(CBotVar* left, CBotVar* right)

-{

-	int	source = left->GivValInt();

-	int shift  = right->GivValInt();

-	if (shift>=1) source &= 0x7fffffff;

-	m_val = source >> shift;

-	m_binit = TRUE;

-}

-

-void CBotVarInt::Neg()

-{

-		m_val = -m_val;

-}

-

-void CBotVarInt::Not()

-{

-		m_val = ~m_val;

-}

-

-void CBotVarInt::Inc()

-{

-		m_val++;

-		m_defnum.Empty();

-}

-

-void CBotVarInt::Dec()

-{

-		m_val--;

-		m_defnum.Empty();

-}

-

-BOOL CBotVarInt::Lo(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() < right->GivValInt();

-}

-

-BOOL CBotVarInt::Hi(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() > right->GivValInt();

-}

-

-BOOL CBotVarInt::Ls(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() <= right->GivValInt();

-}

-

-BOOL CBotVarInt::Hs(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() >= right->GivValInt();

-}

-

-BOOL CBotVarInt::Eq(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() == right->GivValInt();

-}

-

-BOOL CBotVarInt::Ne(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() != right->GivValInt();

-}

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-// copie une variable dans une autre

-void CBotVarFloat::Copy(CBotVar* pSrc, BOOL bName)

-{

-	CBotVarFloat*	p = (CBotVarFloat*)pSrc;

-

-	if (bName) 	*m_token	= *p->m_token;

-	m_type		= p->m_type;

-	m_val		= p->m_val;

-	m_binit		= p->m_binit;

-//-	m_bStatic	= p->m_bStatic;

-	m_next		= NULL;

-	m_pMyThis	= NULL;//p->m_pMyThis;

-	m_pUserPtr	= p->m_pUserPtr;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-}

-

-

-

-

-void CBotVarFloat::SetValInt(int val, const char* s)

-{

-	m_val = (float)val;

-	m_binit	= TRUE;

-}

-

-void CBotVarFloat::SetValFloat(float val)

-{

-	m_val = val;

-	m_binit	= TRUE;

-}

-

-int CBotVarFloat::GivValInt()

-{

-	return	(int)m_val;

-}

-

-float CBotVarFloat::GivValFloat()

-{

-	return m_val;

-}

-

-CBotString CBotVarFloat::GivValString()

-{

-	CBotString res;

-

-	if ( !m_binit )

-	{

-		res.LoadString(TX_UNDEF);

-		return res;

-	}

-	if ( m_binit == IS_NAN )

-	{

-		res.LoadString(TX_NAN);

-		return res;

-	}

-

-	char		buffer[300];

-	sprintf(buffer, "%.2f", m_val);

-	res = buffer;

-

-	return	res;

-}

-

-

-void CBotVarFloat::Mul(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValFloat() * right->GivValFloat();

-	m_binit = TRUE;

-}

-

-void CBotVarFloat::Power(CBotVar* left, CBotVar* right)

-{

-	m_val = (float)pow( left->GivValFloat() , right->GivValFloat() );

-	m_binit = TRUE;

-}

-

-int CBotVarFloat::Div(CBotVar* left, CBotVar* right)

-{

-	float	r = right->GivValFloat();

-	if ( r != 0 )

-	{

-		m_val = left->GivValFloat() / r;

-		m_binit = TRUE;

-	}

-	return ( r == 0 ? TX_DIVZERO : 0 );

-}

-

-int CBotVarFloat::Modulo(CBotVar* left, CBotVar* right)

-{

-	float	r = right->GivValFloat();

-	if ( r != 0 )

-	{

-		m_val = (float)fmod( left->GivValFloat() , r );

-		m_binit = TRUE;

-	}

-	return ( r == 0 ? TX_DIVZERO : 0 );

-}

-

-void CBotVarFloat::Add(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValFloat() + right->GivValFloat();

-	m_binit = TRUE;

-}

-

-void CBotVarFloat::Sub(CBotVar* left, CBotVar* right)

-{

-		m_val = left->GivValFloat() - right->GivValFloat();

-		m_binit = TRUE;

-}

-

-void CBotVarFloat::Neg()

-{

-		m_val = -m_val;

-}

-

-void CBotVarFloat::Inc()

-{

-		m_val++;

-}

-

-void CBotVarFloat::Dec()

-{

-		m_val--;

-}

-

-

-BOOL CBotVarFloat::Lo(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() < right->GivValFloat();

-}

-

-BOOL CBotVarFloat::Hi(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() > right->GivValFloat();

-}

-

-BOOL CBotVarFloat::Ls(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() <= right->GivValFloat();

-}

-

-BOOL CBotVarFloat::Hs(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() >= right->GivValFloat();

-}

-

-BOOL CBotVarFloat::Eq(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() == right->GivValFloat();

-}

-

-BOOL CBotVarFloat::Ne(CBotVar* left, CBotVar* right)

-{

-	return left->GivValFloat() != right->GivValFloat();

-}

-

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-// copie une variable dans une autre

-void CBotVarBoolean::Copy(CBotVar* pSrc, BOOL bName)

-{

-	CBotVarBoolean*	p = (CBotVarBoolean*)pSrc;

-

-	if (bName)	*m_token	= *p->m_token;

-	m_type		= p->m_type;

-	m_val		= p->m_val;

-	m_binit		= p->m_binit;

-//-	m_bStatic	= p->m_bStatic;

-	m_next		= NULL;

-	m_pMyThis	= NULL;//p->m_pMyThis;

-	m_pUserPtr	= p->m_pUserPtr;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-}

-

-

-

-

-void CBotVarBoolean::SetValInt(int val, const char* s)

-{

-	m_val = (BOOL)val;

-	m_binit	= TRUE;

-}

-

-void CBotVarBoolean::SetValFloat(float val)

-{

-	m_val = (BOOL)val;

-	m_binit	= TRUE;

-}

-

-int CBotVarBoolean::GivValInt()

-{

-	return	m_val;

-}

-

-float CBotVarBoolean::GivValFloat()

-{

-	return (float)m_val;

-}

-

-CBotString CBotVarBoolean::GivValString()

-{

-	CBotString	ret;

-

-	CBotString res;

-

-	if ( !m_binit )

-	{

-		res.LoadString(TX_UNDEF);

-		return res;

-	}

-	if ( m_binit == IS_NAN )

-	{

-		res.LoadString(TX_NAN);

-		return res;

-	}

-

-	ret.LoadString( m_val > 0 ? ID_TRUE : ID_FALSE );

-	return	ret;

-}

-

-void CBotVarBoolean::And(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() && right->GivValInt();

-	m_binit = TRUE;

-}

-void CBotVarBoolean::Or(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() || right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarBoolean::XOr(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValInt() ^ right->GivValInt();

-	m_binit = TRUE;

-}

-

-void CBotVarBoolean::Not()

-{

-	m_val = m_val ? FALSE : TRUE ; 

-}

-

-BOOL CBotVarBoolean::Eq(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() == right->GivValInt();

-}

-

-BOOL CBotVarBoolean::Ne(CBotVar* left, CBotVar* right)

-{

-	return left->GivValInt() != right->GivValInt();

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-

-// copie une variable dans une autre

-void CBotVarString::Copy(CBotVar* pSrc, BOOL bName)

-{

-	CBotVarString*	p = (CBotVarString*)pSrc;

-

-	if (bName)	*m_token	= *p->m_token;

-	m_type		= p->m_type;

-	m_val		= p->m_val;

-	m_binit		= p->m_binit;

-//-	m_bStatic	= p->m_bStatic;

-	m_next		= NULL;

-	m_pMyThis	= NULL;//p->m_pMyThis;

-	m_pUserPtr	= p->m_pUserPtr;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-}

-

-

-void CBotVarString::SetValString(const char* p)

-{

-	m_val = p;

-	m_binit	= TRUE;

-}

-

-CBotString CBotVarString::GivValString()

-{

-	if ( !m_binit )

-	{

-		CBotString res;

-		res.LoadString(TX_UNDEF);

-		return res;

-	}

-	if ( m_binit == IS_NAN )

-	{

-		CBotString res;

-		res.LoadString(TX_NAN);

-		return res;

-	}

-

-	return	m_val;

-}

-

-

-void CBotVarString::Add(CBotVar* left, CBotVar* right)

-{

-	m_val = left->GivValString() + right->GivValString();

-	m_binit = TRUE;

-}

-

-BOOL CBotVarString::Eq(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() == right->GivValString());

-}

-

-BOOL CBotVarString::Ne(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() != right->GivValString());

-}

-

-

-BOOL CBotVarString::Lo(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() == right->GivValString());

-}

-

-BOOL CBotVarString::Hi(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() == right->GivValString());

-}

-

-BOOL CBotVarString::Ls(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() == right->GivValString());

-}

-

-BOOL CBotVarString::Hs(CBotVar* left, CBotVar* right)

-{

-	return (left->GivValString() == right->GivValString());

-}

-

-

-////////////////////////////////////////////////////////////////

-

-// copie une variable dans une autre

-void CBotVarClass::Copy(CBotVar* pSrc, BOOL bName)

-{

-	pSrc = pSrc->GivPointer();					// si source donné par un pointeur

-

-	if ( pSrc->GivType() != CBotTypClass )

-		ASM_TRAP();

-

-	CBotVarClass*	p = (CBotVarClass*)pSrc;

-

-	if (bName)	*m_token	= *p->m_token;

-

-	m_type		= p->m_type;

-	m_binit		= p->m_binit;

-//-	m_bStatic	= p->m_bStatic;

-	m_pClass	= p->m_pClass;

-	if ( p->m_pParent )

-	{

-		ASM_TRAP();		"que faire du pParent";

-	}

-

-//	m_next		= NULL;

-	m_pUserPtr	= p->m_pUserPtr;

-	m_pMyThis	= NULL;//p->m_pMyThis;

-	m_ItemIdent = p->m_ItemIdent;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-

-	delete		m_pVar;

-	m_pVar		= NULL;

-

-	CBotVar*	pv = p->m_pVar;

-	while( pv != NULL )

-	{

-		CBotVar*	pn = CBotVar::Create(pv);

-		pn->Copy( pv );

-		if ( m_pVar == NULL ) m_pVar = pn;

-		else m_pVar->AddNext(pn);

-

-		pv = pv->GivNext();

-	}

-}

-

-void CBotVarClass::SetItemList(CBotVar* pVar)

-{

-	delete	m_pVar;

-	m_pVar	= pVar;	// remplace le pointeur existant

-}

-

-void CBotVarClass::SetIdent(long n)

-{

-	m_ItemIdent = n;

-}

-

-void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent)

-{

-	m_type.m_pClass = pClass;

-

-	if ( m_pClass == pClass ) return;

-

-	m_pClass = pClass;

-

-	// initialise les variables associées à cette classe

-	delete m_pVar;

-	m_pVar = NULL;

-

-	if (pClass == NULL) return;

-

-	CBotVar*	pv = pClass->GivVar();				// premier de la liste

-	while ( pv != NULL )

-	{

-		// cherche les dimensions max du tableau

-		CBotInstr*	p  = pv->m_LimExpr;							// les différentes formules

-		if ( p != NULL )

-		{

-			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

-				max[n] = v->GivValInt();							// valeur

-				n++;

-				p = p->GivNext3();

-			}

-			while (n<100) max[n++] = 0;

-

-			pv->m_type.SetArray( max );					// mémorise les limitations

-			pile->Delete();

-		}

-

-		CBotVar*	pn = CBotVar::Create( pv );		// une copie

-		pn->SetStatic(pv->IsStatic());

-		pn->SetPrivate(pv->GivPrivate());

-

-		if ( pv->m_InitExpr != NULL )				// expression pour l'initialisation ?

-		{

-#if	STACKMEM

-			CBotStack* pile = CBotStack::FirstStack();	// une pile indépendante

-

-			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

-			pn->SetVal( pile->GivVar() ) ;

-			delete pile;

-#endif

-		}

-

-//		pn->SetUniqNum(CBotVar::NextUniqNum());		// numérote les éléments

-		pn->SetUniqNum(pv->GivUniqNum());	//++nIdent

-		pn->m_pMyThis = this;

-

-		if ( m_pVar == NULL) m_pVar = pn;

-		else m_pVar->AddNext( pn );

-		pv = pv->GivNext();

-	}

-}

-

-CBotClass* CBotVarClass::GivClass()

-{

-	return	m_pClass;

-}

-

-

-void CBotVarClass::Maj(void* pUser, BOOL bContinu)

-{

-/*	if (!bContinu && m_pMyThis != NULL) 

-		m_pMyThis->Maj(pUser, TRUE);*/

-

-	// 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()

-

-	if ( m_pUserPtr != NULL) pUser = m_pUserPtr;

-	if ( pUser == OBJECTDELETED ||

-		 pUser == OBJECTCREATED ) return;

-	m_pClass->m_rMaj( this, pUser );

-}

-

-CBotVar* CBotVarClass::GivItem(const char* name)

-{

-	CBotVar*	p = m_pVar;

-

-	while ( p != NULL )

-	{

-		if ( p->GivName() == name ) return p;

-		p = p->GivNext();

-	}

-

-	if ( m_pParent != NULL ) return m_pParent->GivItem(name);

-	return NULL;

-}

-

-CBotVar* CBotVarClass::GivItemRef(int nIdent)

-{

-	CBotVar*	p = m_pVar;

-

-	while ( p != NULL )

-	{

-		if ( p->GivUniqNum() == nIdent ) return p;

-		p = p->GivNext();

-	}

-

-	if ( m_pParent != NULL ) return m_pParent->GivItemRef(nIdent);

-	return NULL;

-}

-

-// pour la gestion d'un tableau

-// bExtend permet d'agrandir le tableau, mais pas au dela de la taille fixée par SetArray()

-

-CBotVar* CBotVarClass::GivItem(int n, BOOL bExtend)

-{

-	CBotVar*	p = m_pVar;

-

-	if ( n < 0 ) return NULL;

-	if ( n > MAXARRAYSIZE ) return NULL;

-

-	if ( m_type.GivLimite() >= 0 && n >= m_type.GivLimite() ) return NULL;

-

-	if ( p == NULL && bExtend )

-	{

-		p = CBotVar::Create("", m_type.GivTypElem());

-		m_pVar = p;

-	}

-

-	if ( n == 0 ) return p;

-

-	while ( n-- > 0 )

-	{

-		if ( p->m_next == NULL )

-		{

-			if ( bExtend ) p->m_next = CBotVar::Create("", m_type.GivTypElem());

-			if ( p->m_next == NULL ) return NULL;

-		}

-		p = p->m_next;

-	}

-

-	return p;

-}

-

-CBotVar* CBotVarClass::GivItemList()

-{

-	return m_pVar;

-}

-

-

-CBotString CBotVarClass::GivValString()

-{

-//	if ( m_Indirect != NULL) return m_Indirect->GivValString();

-

-	CBotString	res;

-

-	if ( m_pClass != NULL )						// pas utilisé pour un array

-	{

-		res = m_pClass->GivName() + CBotString("( ");

-

-		CBotVarClass*	my = this;

-		while ( my != NULL )

-		{

-			CBotVar*	pv = my->m_pVar;

-			while ( pv != NULL )

-			{

-				res += pv->GivName() + CBotString("=");

-

-				if ( pv->IsStatic() )

-				{

-					CBotVar* pvv = my->m_pClass->GivItem(pv->GivName());

-					res += pvv->GivValString();

-				}

-				else

-				{

-					res += pv->GivValString();

-				}

-				pv = pv->GivNext();

-				if ( pv != NULL ) res += ", ";

-			}

-			my = my->m_pParent;

-			if ( my != NULL )

-			{

-				res += ") extends ";

-				res += my->m_pClass->GivName();

-				res += " (";

-			}

-		}

-	}

-	else

-	{

-		res = "( ";

-

-		CBotVar*	pv = m_pVar;

-		while ( pv != NULL )

-		{

-			res += pv->GivValString();

-			if ( pv->GivNext() != NULL ) res += ", ";

-			pv = pv->GivNext();

-		}

-	}

-

-	res += " )";

-	return	res;

-}

-

-void CBotVarClass::IncrementUse()

-{

-	m_CptUse++;

-}

-

-void CBotVarClass::DecrementUse()

-{

-	m_CptUse--;

-	if ( m_CptUse == 0 ) 

-	{

-		// s'il y en a un, appel le destructeur

-		// mais seulement si un constructeur avait été appelé.

-		if ( m_bConstructor )

-		{

-			m_CptUse++;	// ne revient pas dans le destructeur

-

-			// m_error est static dans le stack

-			// 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 !!

-

-			pile = CBotStack::FirstStack();		// efface l'erreur

-			CBotVar*	ppVars[1];

-			ppVars[0] = NULL;

-

-			CBotVar*	pThis  = CBotVar::Create("this", CBotTypNullPointer);

-			pThis->SetPointer(this);

-			CBotVar*	pResult = NULL;

-

-			CBotString	nom = "~" + m_pClass->GivName();

-			long		ident = 0;

-

-			while ( pile->IsOk() && !m_pClass->ExecuteMethode(ident, nom, pThis, ppVars, pResult, pile, NULL)) ;	// attend la fin

-

-			pile->ResetError(err, start,end);

-

-			pile->Delete();

-			delete pThis;

-			m_CptUse--;

-		}

-

-		delete this; // s'auto-détruit !!

-	}

-}

-

-CBotVarClass* CBotVarClass::GivPointer()

-{

-	return this;

-}

-

-

-// trouve une instance selon son numéro unique

-

-CBotVarClass* CBotVarClass::Find(long id)

-{

-	CBotVarClass*	p = m_ExClass;

-

-	while ( p != NULL )

-	{

-		if ( p->m_ItemIdent == id ) return p;

-		p = p->m_ExNext;

-	}

-

-	return NULL;

-}

-

-BOOL CBotVarClass::Eq(CBotVar* left, CBotVar* right)

-{

-	CBotVar*	l = left->GivItemList();

-	CBotVar*	r = right->GivItemList();

-

-	while ( l != NULL && r != NULL )

-	{

-		if ( l->Ne(l, r) ) return FALSE;

-		l = l->GivNext();

-		r = r->GivNext();

-	}

-

-	// devrait toujours arrivé simultanément au bout (mêmes classes)

-	return l == r;

-}

-

-BOOL CBotVarClass::Ne(CBotVar* left, CBotVar* right)

-{

-	CBotVar*	l = left->GivItemList();

-	CBotVar*	r = right->GivItemList();

-

-	while ( l != NULL && r != NULL )

-	{

-		if ( l->Ne(l, r) ) return TRUE;

-		l = l->GivNext();

-		r = r->GivNext();

-	}

-

-	// devrait toujours arrivé simultanément au bout (mêmes classes)

-	return l != r;

-}

-

-/////////////////////////////////////////////////////////////////////////////

-// gestion des tableaux de variables

-

-CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type )

-{

-	if ( !type.Eq(CBotTypArrayPointer) &&

-		 !type.Eq(CBotTypArrayBody)) ASM_TRAP();

-

-	m_token		= new CBotToken(name);

-	m_next		= NULL;

-	m_pMyThis	= NULL;

-	m_pUserPtr	= NULL;

-

-	m_type		= type;

-	m_type.SetType(CBotTypArrayPointer);

-	m_binit		= FALSE;

-

-	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

-}

-

-// copie une variable dans une autre

-void CBotVarArray::Copy(CBotVar* pSrc, BOOL bName)

-{

-	if ( pSrc->GivType() != CBotTypArrayPointer )

-		ASM_TRAP();

-

-	CBotVarArray*	p = (CBotVarArray*)pSrc;

-

-	if ( bName) *m_token	= *p->m_token;

-	m_type		= p->m_type;

-	m_pInstance = p->GivPointer();

-

-	if ( m_pInstance != NULL )

-		 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)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-}

-

-void CBotVarArray::SetPointer(CBotVar* pVarClass)

-{

-	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 ( pVarClass != NULL )

-	{

-		if ( pVarClass->GivType() == CBotTypArrayPointer )

-			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur à l'objet

-

-		if ( !pVarClass->m_type.Eq(CBotTypClass) &&

-			 !pVarClass->m_type.Eq(CBotTypArrayBody))

-			ASM_TRAP();

-

-		((CBotVarClass*)pVarClass)->IncrementUse();			// une référence en plus

-	}

-

-	if ( m_pInstance != NULL ) m_pInstance->DecrementUse();

-	m_pInstance = (CBotVarClass*)pVarClass;

-}

-

-

-CBotVarClass* CBotVarArray::GivPointer()

-{

-	if ( m_pInstance == NULL ) return NULL;

-	return m_pInstance->GivPointer();

-}

-

-CBotVar* CBotVarArray::GivItem(int n, BOOL bExtend)

-{

-	if ( m_pInstance == NULL )

-	{

-		if ( !bExtend ) return NULL;

-		// crée une instance pour le tableau

-

-		CBotVarClass* instance = new CBotVarClass(NULL, m_type);

-		SetPointer( instance );

-	}

-	return m_pInstance->GivItem(n, bExtend);

-}

-

-CBotVar* CBotVarArray::GivItemList()

-{

-	if ( m_pInstance == NULL) return NULL;

-	return m_pInstance->GivItemList();

-}

-

-CBotString CBotVarArray::GivValString()

-{

-	if ( m_pInstance == NULL ) return ( CBotString( "Null pointer" ) ) ;

-	return m_pInstance->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

-}

-

-

-/////////////////////////////////////////////////////////////////////////////

-// 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(CBotTypIntrinsic) ) ASM_TRAP();

-

-	m_token		= new CBotToken(name);

-	m_next		= NULL;

-	m_pMyThis	= NULL;

-	m_pUserPtr	= NULL;

-

-	m_type		= type;

-	if ( !type.Eq(CBotTypNullPointer) )

-		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()

-

-	SetClass(type.GivClass() );

-}

-

-CBotVarPointer::~CBotVarPointer()

-{

-	if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();	// une référence en moins

-}

-

-

-void CBotVarPointer::Maj(void* pUser, BOOL bContinu)

-{

-/*	if ( !bContinu && m_pMyThis != NULL )

-		 m_pMyThis->Maj(pUser, FALSE);*/

-

-	if ( m_pVarClass != NULL) m_pVarClass->Maj(pUser, FALSE);

-}

-

-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_pVarClass->GivItem(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_pVarClass->GivItemRef(nIdent);

-}

-

-CBotVar* CBotVarPointer::GivItemList()

-{

-	if ( m_pVarClass == NULL) return NULL;

-	return m_pVarClass->GivItemList();

-}

-

-CBotString CBotVarPointer::GivValString()

-{

-	CBotString	s = "Pointer to ";

-	if ( m_pVarClass == NULL ) s = "Null pointer" ;

-	else  s += m_pVarClass->GivValString();

-	return s;

-}

-

-

-void CBotVarPointer::ConstructorSet()

-{

-	if ( m_pVarClass != NULL) m_pVarClass->ConstructorSet();

-}

-

-// initialise le pointeur vers l'instance d'une classe

-

-void CBotVarPointer::SetPointer(CBotVar* pVarClass)

-{

-	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 ( pVarClass != NULL )

-	{

-		if ( pVarClass->GivType() == CBotTypPointer )

-			 pVarClass = pVarClass->GivPointer();	// le vrai pointeur à l'objet

-

-//		if ( pVarClass->GivType() != CBotTypClass )

-		if ( !pVarClass->m_type.Eq(CBotTypClass) )

-			ASM_TRAP();

-

-		((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

-	}

-

-	if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();

-	m_pVarClass = (CBotVarClass*)pVarClass;

-

-}

-

-CBotVarClass* CBotVarPointer::GivPointer()

-{

-	if ( m_pVarClass == NULL ) return NULL;

-	return m_pVarClass->GivPointer();

-}

-

-void CBotVarPointer::SetIdent(long n)

-{

-	if ( m_pVarClass == NULL ) return;

-	m_pVarClass->SetIdent( n );

-}

-

-long CBotVarPointer::GivIdent()

-{

-	if ( m_pVarClass == NULL ) return 0;

-	return m_pVarClass->m_ItemIdent;

-}

-

-

-void CBotVarPointer::SetClass(CBotClass* pClass)

-{

-//	int		nIdent = 0;

-	m_type.m_pClass = m_pClass = pClass;

-	if ( m_pVarClass != NULL ) m_pVarClass->SetClass(pClass); //, nIdent);

-}

-

-CBotClass* CBotVarPointer::GivClass()

-{

-	if ( m_pVarClass != NULL ) return m_pVarClass->GivClass();

-

-	return	m_pClass;

-}

-

-

-BOOL CBotVarPointer::Save1State(FILE* pf)

-{

-	if ( m_pClass )

-	{

-		if (!WriteString(pf, m_pClass->GivName())) return FALSE;	// nom de la classe

-	}

-	else

-	{

-		if (!WriteString(pf, "")) return FALSE;

-	}

-

-	if (!WriteLong(pf, GivIdent())) return FALSE;		// la référence unique

-

-	// sauve aussi une copie de l'instance

-	return SaveVar(pf, GivPointer());

-}

-

-// copie une variable dans une autre

-void CBotVarPointer::Copy(CBotVar* pSrc, BOOL bName)

-{

-	if ( pSrc->GivType() != CBotTypPointer &&

-		 pSrc->GivType() != CBotTypNullPointer)

-		ASM_TRAP();

-

-	CBotVarPointer*	p = (CBotVarPointer*)pSrc;

-

-	if ( bName) *m_token	= *p->m_token;

-	m_type		= p->m_type;

-//	m_pVarClass = p->m_pVarClass;

-	m_pVarClass = p->GivPointer();

-

-	if ( m_pVarClass != NULL )

-		 m_pVarClass->IncrementUse();			// une référence en plus

-

-	m_pClass	= p->m_pClass;

-	m_binit		= p->m_binit;

-//-	m_bStatic	= p->m_bStatic;

-	m_next		= NULL;

-	m_pMyThis	= NULL;//p->m_pMyThis;

-	m_pUserPtr	= p->m_pUserPtr;

-

-	// garde le même idendificateur (par défaut)

-	if (m_ident == 0 ) m_ident     = p->m_ident;

-}

-

-BOOL CBotVarPointer::Eq(CBotVar* left, CBotVar* right)

-{

-	CBotVarClass*	l = left->GivPointer();

-	CBotVarClass*	r = right->GivPointer();

-

-	if ( l == r ) return TRUE;

-	if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return TRUE;

-	if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return TRUE;

-	return FALSE;

-}

-

-BOOL CBotVarPointer::Ne(CBotVar* left, CBotVar* right)

-{

-	CBotVarClass*	l = left->GivPointer();

-	CBotVarClass*	r = right->GivPointer();

-

-	if ( l == r ) return FALSE;

-	if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return FALSE;

-	if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return FALSE;

-	return TRUE;

-}

-

-

-

-///////////////////////////////////////////////////////

-// gestion des types de résultats

-

-

-CBotTypResult::CBotTypResult(int type)

-{

-	m_type		= type;

-	m_pNext		= NULL;

-	m_pClass	= NULL;

-	m_limite	= -1;

-}

-

-CBotTypResult::CBotTypResult(int type, const char* name)

-{

-	m_type		= type;

-	m_pNext		= NULL;

-	m_pClass	= NULL;

-	m_limite	= -1;

-

-	if ( type == CBotTypPointer ||

-		 type == CBotTypClass   ||

-		 type == CBotTypIntrinsic )

-	{

-		m_pClass = CBotClass::Find(name);

-		if ( m_pClass && m_pClass->IsIntrinsic() ) m_type = CBotTypIntrinsic;

-	}

-}

-

-CBotTypResult::CBotTypResult(int type, CBotClass* pClass)

-{

-	m_type		= type;

-	m_pNext		= NULL;

-	m_pClass	= pClass;

-	m_limite	= -1;

-

-	if ( m_pClass && m_pClass->IsIntrinsic() ) m_type = CBotTypIntrinsic;

-}

-

-CBotTypResult::CBotTypResult(int type, CBotTypResult elem)

-{

-	m_type		= type;

-	m_pNext		= NULL;

-	m_pClass	= NULL;

-	m_limite	= -1;

-

-	if ( type == CBotTypArrayPointer ||

-		 type == CBotTypArrayBody )

-		m_pNext = new CBotTypResult( elem );

-}

-

-CBotTypResult::CBotTypResult(const CBotTypResult& typ)

-{

-	m_type		= typ.m_type;

-	m_pClass	= typ.m_pClass;

-	m_pNext		= NULL;

-	m_limite	= typ.m_limite;

-

-	if ( typ.m_pNext )

-		m_pNext = new CBotTypResult( *typ.m_pNext );

-}

-

-CBotTypResult::CBotTypResult()

-{

-	m_type		= 0;

-	m_limite	= -1;

-	m_pNext		= NULL;

-	m_pClass	= NULL;

-}

-

-CBotTypResult::~CBotTypResult()

-{

-	delete	m_pNext;

-}

-

-int CBotTypResult::GivType(int mode) const

-{

-#ifdef	_DEBUG

-	if ( m_type == CBotTypPointer ||

-		 m_type == CBotTypClass   ||

-		 m_type == CBotTypIntrinsic )

-

-		 if ( m_pClass == NULL ) ASM_TRAP();

-

-		

-	if ( m_type == CBotTypArrayPointer )

-		 if ( m_pNext == NULL ) ASM_TRAP();

-#endif

-	if ( mode == 3 && m_type == CBotTypNullPointer ) return CBotTypPointer;

-	return	m_type;

-}

-

-void CBotTypResult::SetType(int n)

-{

-	m_type = n;

-}

-

-CBotClass* CBotTypResult::GivClass() const

-{

-	return m_pClass;

-}

-

-CBotTypResult& CBotTypResult::GivTypElem() const

-{

-	return *m_pNext;

-}

-

-int CBotTypResult::GivLimite() const

-{

-	return m_limite;

-}

-

-void CBotTypResult::SetLimite(int n)

-{

-	m_limite = n;

-}

-

-void CBotTypResult::SetArray( int* max )

-{

-	m_limite = *max;

-	if (m_limite < 1) m_limite = -1;

-

-	if ( m_pNext != NULL )					// dernière dimension ?

-	{

-		m_pNext->SetArray( max+1 );

-	}

-}

-

-

-

-BOOL CBotTypResult::Compare(const CBotTypResult& typ) const

-{

-	if ( m_type != typ.m_type ) return FALSE;

-

-	if ( m_type == CBotTypArrayPointer ) return m_pNext->Compare(*typ.m_pNext);

-

-	if ( m_type == CBotTypPointer ||

-		 m_type == CBotTypClass   ||

-		 m_type == CBotTypIntrinsic )

-	{

-		return m_pClass == typ.m_pClass;

-	}

-

-	return TRUE;

-}

-

-BOOL CBotTypResult::Eq(int type) const

-{

-	return m_type == type;

-}

-

-CBotTypResult&

-	CBotTypResult::operator=(const CBotTypResult& src)

-{

-	m_type = src.m_type;

-	m_limite = src.m_limite;

-	m_pClass = src.m_pClass;

-	m_pNext = NULL;

-	if ( src.m_pNext != NULL )

-	{

-		m_pNext = new CBotTypResult(*src.m_pNext);

-	}

-	return *this;

-}

-

-

+// * 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  http://www.gnu.org/licenses/.
+
+////////////////////////////////////////////////////////////////////
+// Definition for the class CBotVar
+// variables management of the language CBoT
+
+// it never creates an instance of the class mother CBotVar
+
+#include "CBot.h"
+#include <math.h>
+#include <stdio.h>
+
+long CBotVar::m_identcpt = 0;
+
+CBotVar::CBotVar( )
+{
+    m_next    = NULL;
+    m_pMyThis = NULL;
+    m_pUserPtr = NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_type  = -1;
+    m_binit = false;
+    m_ident = 0;
+    m_bStatic = false;
+    m_mPrivate = 0;
+}
+
+CBotVarInt::CBotVarInt( const CBotToken* name )
+{
+    m_token    = new CBotToken(name);
+    m_next    = NULL;
+    m_pMyThis = NULL;
+    m_pUserPtr = NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_type  = CBotTypInt;
+    m_binit = false;
+    m_bStatic = false;
+    m_mPrivate = 0;
+
+    m_val    = 0;
+}
+
+CBotVarFloat::CBotVarFloat( const CBotToken* name )
+{
+    m_token    = new CBotToken(name);
+    m_next    = NULL;
+    m_pMyThis = NULL;
+    m_pUserPtr = NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_type  = CBotTypFloat;
+    m_binit = false;
+    m_bStatic = false;
+    m_mPrivate = 0;
+
+    m_val    = 0;
+}
+
+CBotVarString::CBotVarString( const CBotToken* name )
+{
+    m_token    = new CBotToken(name);
+    m_next    = NULL;
+    m_pMyThis = NULL;
+    m_pUserPtr = NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_type  = CBotTypString;
+    m_binit = false;
+    m_bStatic = false;
+    m_mPrivate = 0;
+
+    m_val.Empty();
+}
+
+CBotVarBoolean::CBotVarBoolean( const CBotToken* name )
+{
+    m_token        = new CBotToken(name);
+    m_next        = NULL;
+    m_pMyThis    = NULL;
+    m_pUserPtr    = NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_type        = CBotTypBoolean;
+    m_binit        = false;
+    m_bStatic = false;
+    m_mPrivate = 0;
+
+    m_val        = 0;
+}
+
+CBotVarClass* CBotVarClass::m_ExClass = NULL;
+
+CBotVarClass::CBotVarClass( const CBotToken* name, const CBotTypResult& type)
+{
+/*
+//    int    nIdent = 0;
+    InitCBotVarClass( name, type ) //, nIdent );
+}
+
+CBotVarClass::CBotVarClass( const CBotToken* name, CBotTypResult& type) //, int &nIdent )
+{
+    InitCBotVarClass( name, type ); //, nIdent );
+}
+
+void CBotVarClass::InitCBotVarClass( const CBotToken* name, CBotTypResult& type ) //, int &nIdent )
+{*/
+    if ( !type.Eq(CBotTypClass)        &&
+         !type.Eq(CBotTypIntrinsic)    &&                // by convenience there accepts these types
+         !type.Eq(CBotTypPointer)      &&
+         !type.Eq(CBotTypArrayPointer) &&
+         !type.Eq(CBotTypArrayBody)) ASM_TRAP();
+
+    m_token        = new CBotToken(name);
+    m_next        = NULL;
+    m_pMyThis    = NULL;
+    m_pUserPtr    = OBJECTCREATED;//NULL;
+    m_InitExpr = NULL;
+    m_LimExpr = NULL;
+    m_pVar        = NULL;
+    m_type        = type;
+    if ( type.Eq(CBotTypArrayPointer) )    m_type.SetType( CBotTypArrayBody );    
+    else if ( !type.Eq(CBotTypArrayBody) ) m_type.SetType( CBotTypClass );    
+                                                 // officel type for this object
+
+    m_pClass    = NULL;
+    m_pParent    = NULL;
+    m_binit        = false;
+    m_bStatic    = false;
+    m_mPrivate    = 0;
+    m_bConstructor = false;
+    m_CptUse    = 0;
+    m_ItemIdent = type.Eq(CBotTypIntrinsic) ? 0 : CBotVar::NextUniqNum();
+
+    // se place tout seul dans la liste
+    // TODO stands alone in the list (stands only in a list)
+    if (m_ExClass) m_ExClass->m_ExPrev = this;
+    m_ExNext  = m_ExClass;
+    m_ExPrev  = NULL;
+    m_ExClass = this;
+
+    CBotClass* pClass = type.GivClass();
+    CBotClass* pClass2 = pClass->GivParent();
+    if ( pClass2 != NULL )
+    {
+        // also creates an instance of the parent class
+        m_pParent = new CBotVarClass(name, CBotTypResult(type.GivType(),pClass2) ); //, nIdent);
+    }
+
+    SetClass( pClass ); //, nIdent );
+
+}
+
+CBotVarClass::~CBotVarClass( )
+{
+    if ( m_CptUse != 0 )
+        ASM_TRAP();
+
+    if ( m_pParent ) delete m_pParent;
+    m_pParent = NULL;
+
+    // frees the indirect object if necessary
+//    if ( m_Indirect != NULL )
+//        m_Indirect->DecrementUse();
+
+    // removes the class list
+    if ( m_ExPrev ) m_ExPrev->m_ExNext = m_ExNext;
+    else m_ExClass = m_ExNext;
+
+    if ( m_ExNext ) m_ExNext->m_ExPrev = m_ExPrev;
+    m_ExPrev = NULL;
+    m_ExNext = NULL;
+
+    delete    m_pVar;
+}
+
+void CBotVarClass::ConstructorSet()
+{
+    m_bConstructor = true;
+}
+
+
+CBotVar::~CBotVar( )
+{
+    delete  m_token;
+    delete    m_next;
+}
+
+void CBotVar::debug()
+{
+    const char*    p = (const char*) m_token->GivString();
+    CBotString  s = (const char*) GivValString();
+    const char* v = (const char*) s;
+
+    if ( m_type.Eq(CBotTypClass) )
+    {
+        CBotVar*    pv = ((CBotVarClass*)this)->m_pVar;
+        while (pv != NULL)
+        {
+            pv->debug();
+            pv = pv->GivNext();
+        }
+    }
+}
+
+void CBotVar::ConstructorSet()
+{
+    // nop
+}
+
+void CBotVar::SetUserPtr(void* pUser)
+{
+    m_pUserPtr = pUser;
+    if (m_type.Eq(CBotTypPointer) &&
+        ((CBotVarPointer*)this)->m_pVarClass != NULL )
+        ((CBotVarPointer*)this)->m_pVarClass->SetUserPtr(pUser);
+}
+
+void CBotVar::SetIdent(long n)
+{
+    if (m_type.Eq(CBotTypPointer) &&
+        ((CBotVarPointer*)this)->m_pVarClass != NULL )
+        ((CBotVarPointer*)this)->m_pVarClass->SetIdent(n);
+}
+
+void CBotVar::SetUniqNum(long n)
+{
+    m_ident = n;
+
+    if ( n == 0 ) ASM_TRAP();
+}
+
+long CBotVar::NextUniqNum()
+{
+    if (++m_identcpt < 10000) m_identcpt = 10000;
+    return m_identcpt;
+}
+
+long CBotVar::GivUniqNum()
+{
+    return m_ident;
+}
+
+
+void* CBotVar::GivUserPtr()
+{
+    return m_pUserPtr;
+}
+
+bool CBotVar::Save1State(FILE* pf)
+{
+    // this routine "virtual" must never be called,
+    // there must be a routine for each of the subclasses (CBotVarInt, CBotVarFloat, etc)
+    // ( see the type in m_type )
+    ASM_TRAP();
+    return false;
+}
+
+void CBotVar::Maj(void* pUser, bool bContinu)
+{
+/*    if (!bContinu && m_pMyThis != NULL)
+        m_pMyThis->Maj(pUser, true);*/
+}
+
+
+// creates a variable depending on its type
+
+CBotVar* CBotVar::Create(const CBotToken* name, int type )
+{
+    CBotTypResult    t(type);
+    return Create(name, t);
+}
+
+CBotVar* CBotVar::Create(const CBotToken* name, CBotTypResult type)
+{
+    switch (type.GivType())
+    {
+    case CBotTypShort:
+    case CBotTypInt:
+        return new CBotVarInt(name);
+    case CBotTypFloat:
+        return new CBotVarFloat(name);
+    case CBotTypBoolean:
+        return new CBotVarBoolean(name);
+    case CBotTypString:
+        return new CBotVarString(name);
+    case CBotTypPointer:
+    case CBotTypNullPointer:
+        return new CBotVarPointer(name, type);
+    case CBotTypIntrinsic:
+        return new CBotVarClass(name, type);
+
+    case CBotTypClass:
+        // creates a new instance of a class
+        // and returns the POINTER on this instance
+        {
+            CBotVarClass* instance = new CBotVarClass(name, type);
+            CBotVarPointer* pointer = new CBotVarPointer(name, type);
+            pointer->SetPointer( instance );
+            return pointer;
+        }
+
+    case CBotTypArrayPointer:
+        return new CBotVarArray(name, type);
+
+    case CBotTypArrayBody:
+        {
+            CBotVarClass* instance = new CBotVarClass(name, type);
+            CBotVarArray* array = new CBotVarArray(name, type);
+            array->SetPointer( instance );
+
+            CBotVar*    pv = array;
+            while (type.Eq(CBotTypArrayBody))
+            {
+                type = type.GivTypElem();
+                pv = ((CBotVarArray*)pv)->GivItem(0, true);            // creates at least the element [0]
+            }
+
+            return array;
+        }
+    }
+
+    ASM_TRAP();
+    return NULL;
+}
+
+CBotVar* CBotVar::Create( CBotVar* pVar )
+{
+    CBotVar*    p = Create(pVar->m_token->GivString(), pVar->GivTypResult(2));
+    return p;
+}
+
+
+CBotVar* CBotVar::Create( const char* n, CBotTypResult type)
+{
+    CBotToken    name(n);
+
+    switch (type.GivType())
+    {
+    case CBotTypShort:
+    case CBotTypInt:
+        return new CBotVarInt(&name);
+    case CBotTypFloat:
+        return new CBotVarFloat(&name);
+    case CBotTypBoolean:
+        return new CBotVarBoolean(&name);
+    case CBotTypString:
+        return new CBotVarString(&name);
+    case CBotTypPointer:
+    case CBotTypNullPointer:
+        {
+            CBotVarPointer* p = new CBotVarPointer(&name, type);
+//            p->SetClass(type.GivClass());
+            return p;
+        }
+    case CBotTypIntrinsic:
+        {
+            CBotVarClass* p = new CBotVarClass(&name, type);
+//            p->SetClass(type.GivClass());
+            return p;
+        }
+
+    case CBotTypClass:
+        // creates a new instance of a class
+        // and returns the POINTER on this instance
+        {
+            CBotVarClass* instance = new CBotVarClass(&name, type);
+            CBotVarPointer* pointer = new CBotVarPointer(&name, type);
+            pointer->SetPointer( instance );
+//            pointer->SetClass( type.GivClass() );
+            return pointer;
+        }
+
+    case CBotTypArrayPointer:
+        return new CBotVarArray(&name, type);
+
+    case CBotTypArrayBody:
+        {
+            CBotVarClass* instance = new CBotVarClass(&name, type);
+            CBotVarArray* array = new CBotVarArray(&name, type);
+            array->SetPointer( instance );
+        
+            CBotVar*    pv = array;
+            while (type.Eq(CBotTypArrayBody))
+            {
+                type = type.GivTypElem();
+                pv = ((CBotVarArray*)pv)->GivItem(0, true);            // creates at least the element [0]
+            }
+
+            return array;
+        }
+    }
+
+    ASM_TRAP();
+    return NULL;
+}
+
+CBotVar* CBotVar::Create( const char* name, int type, CBotClass* pClass)
+{
+    CBotToken    token( name, "" );
+    CBotVar*    pVar = Create( &token, type );
+    
+    if ( type == CBotTypPointer && pClass == NULL )        // pointer "null" ?
+        return pVar;
+
+    if ( type == CBotTypClass || type == CBotTypPointer ||
+         type == CBotTypIntrinsic )
+    {
+        if (pClass == NULL) 
+        {
+            delete pVar;
+            return NULL;
+        }
+        pVar->SetClass( pClass );
+    }
+    return pVar;
+}
+
+CBotVar* CBotVar::Create( const char* name, CBotClass* pClass)
+{
+    CBotToken    token( name, "" );
+    CBotVar*    pVar = Create( &token, CBotTypResult( CBotTypClass, pClass ) );
+//    pVar->SetClass( pClass );
+    return        pVar;
+}
+
+CBotTypResult CBotVar::GivTypResult(int mode)
+{
+    CBotTypResult    r = m_type;
+
+    if ( mode == 1 && m_type.Eq(CBotTypClass) ) 
+        r.SetType(CBotTypPointer);
+    if ( mode == 2 && m_type.Eq(CBotTypClass) ) 
+        r.SetType(CBotTypIntrinsic);
+
+    return r;
+}
+
+int CBotVar::GivType(int mode)
+{
+    if ( mode == 1 && m_type.Eq(CBotTypClass) ) 
+        return CBotTypPointer;
+    if ( mode == 2 && m_type.Eq(CBotTypClass) ) 
+        return CBotTypIntrinsic;
+    return m_type.GivType();
+}
+
+void CBotVar::SetType(CBotTypResult& type)
+{
+    m_type = type;
+}
+
+
+int CBotVar::GivInit()
+{
+    if (  m_type.Eq(CBotTypClass) ) return IS_DEF;        // always set!
+
+    return    m_binit;
+}
+
+void CBotVar::SetInit(int bInit)
+{
+    m_binit = bInit;
+    if ( bInit == 2 ) m_binit = IS_DEF;                    // cas spécial
+
+    if ( m_type.Eq(CBotTypPointer) && bInit == 2 )
+    {
+        CBotVarClass* instance = GivPointer();
+        if ( instance == NULL )
+        {
+            instance = new CBotVarClass(NULL, m_type);
+//            instance->SetClass(((CBotVarPointer*)this)->m_pClass);
+            SetPointer(instance);
+        }
+        instance->SetInit(1);
+    }
+
+    if ( m_type.Eq(CBotTypClass) || m_type.Eq(CBotTypIntrinsic) )
+    {
+        CBotVar*    p = ((CBotVarClass*)this)->m_pVar;
+        while( p != NULL )
+        {
+            p->SetInit( bInit );
+            p->m_pMyThis = (CBotVarClass*)this;
+            p = p->GivNext();
+        }
+    }
+}
+
+CBotString CBotVar::GivName()
+{
+    return    m_token->GivString();
+}
+
+void CBotVar::SetName(const char* name)
+{
+    m_token->SetString(name);
+}
+
+CBotToken* CBotVar::GivToken()
+{
+    return    m_token;
+}
+
+CBotVar* CBotVar::GivItem(const char* name)
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+CBotVar* CBotVar::GivItemRef(int nIdent)
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+CBotVar* CBotVar::GivItemList()
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+CBotVar* CBotVar::GivItem(int row, bool bGrow)
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+// check if a variable belongs to a given class
+bool CBotVar::IsElemOfClass(const char* name)
+{
+    CBotClass*    pc = NULL;
+
+    if ( m_type.Eq(CBotTypPointer) )
+    {
+        pc = ((CBotVarPointer*)this)->m_pClass;
+    }
+    if ( m_type.Eq(CBotTypClass) )
+    {
+        pc = ((CBotVarClass*)this)->m_pClass;
+    }
+
+    while ( pc != NULL )
+    {
+        if ( pc->GivName() == name ) return true;
+        pc = pc->GivParent();
+    }
+
+    return false;
+}
+
+
+CBotVar* CBotVar::GivStaticVar()
+{
+    // makes the pointer to the variable if it is static
+    if ( m_bStatic == 0 || m_pMyThis == NULL ) return this;
+
+    CBotClass*    pClass = m_pMyThis->GivClass();
+    return pClass->GivItem( m_token->GivString() );
+}
+
+
+CBotVar* CBotVar::GivNext()
+{
+    return m_next;
+}
+
+void CBotVar::AddNext(CBotVar* pVar)
+{
+    CBotVar*    p = this;
+    while (p->m_next != NULL) p = p->m_next;
+
+    p->m_next = pVar;
+}
+
+void CBotVar::SetVal(CBotVar* var)
+{
+    switch (/*var->*/GivType())
+    {
+    case CBotTypBoolean:
+        SetValInt(var->GivValInt());
+        break;
+    case CBotTypInt:
+        SetValInt(var->GivValInt(), ((CBotVarInt*)var)->m_defnum);
+        break;
+    case CBotTypFloat:
+        SetValFloat(var->GivValFloat());
+        break;
+    case CBotTypString:
+        SetValString(var->GivValString());
+        break;
+    case CBotTypPointer:
+    case CBotTypNullPointer:
+    case CBotTypArrayPointer:
+        SetPointer(var->GivPointer());
+        break;
+    case CBotTypClass:
+        {
+            delete ((CBotVarClass*)this)->m_pVar;
+            ((CBotVarClass*)this)->m_pVar = NULL;
+            Copy(var, false);
+        }
+        break;
+    default:
+        ASM_TRAP();
+    }
+
+    m_binit = var->m_binit;        // copie l'état nan s'il y a 
+}
+
+void CBotVar::SetStatic(bool bStatic)
+{
+    m_bStatic = bStatic;
+}
+
+void CBotVar::SetPrivate(int mPrivate)
+{
+    m_mPrivate = mPrivate;
+}
+
+bool CBotVar::IsStatic()
+{
+    return m_bStatic;
+}
+
+bool CBotVar::IsPrivate(int mode)
+{
+    return m_mPrivate >= mode;
+}
+
+int CBotVar::GivPrivate()
+{
+    return m_mPrivate;
+}
+
+
+void CBotVar::SetPointer(CBotVar* pVarClass)
+{
+    ASM_TRAP();
+}
+
+CBotVarClass* CBotVar::GivPointer()
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+// All these functions must be defined in the subclasses
+// derived from class CBotVar
+
+int CBotVar::GivValInt()
+{
+    ASM_TRAP();
+    return 0;
+}
+
+float CBotVar::GivValFloat()
+{
+    ASM_TRAP();
+    return 0;
+}
+
+void CBotVar::SetValInt(int c, const char* s)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::SetValFloat(float c)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Mul(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Power(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+int CBotVar::Div(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return 0;
+}
+
+int CBotVar::Modulo(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return 0;
+}
+
+void CBotVar::Add(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Sub(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+bool CBotVar::Lo(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+bool CBotVar::Hi(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+bool CBotVar::Ls(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+bool CBotVar::Hs(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+bool CBotVar::Eq(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+bool CBotVar::Ne(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+    return false;
+}
+
+void CBotVar::And(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Or(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::XOr(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::ASR(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::SR(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::SL(CBotVar* left, CBotVar* right)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Neg()
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Not()
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Inc()
+{
+    ASM_TRAP();
+}
+void CBotVar::Dec()
+{
+    ASM_TRAP();
+}
+
+void CBotVar::Copy(CBotVar* pSrc, bool bName)
+{
+    ASM_TRAP();
+}
+
+void CBotVar::SetValString(const char* p)
+{
+    ASM_TRAP();
+}
+
+CBotString CBotVar::GivValString()
+{
+    ASM_TRAP();
+    return CBotString();
+}
+
+void CBotVar::SetClass(CBotClass* pClass)
+{
+    ASM_TRAP();
+}
+
+CBotClass* CBotVar::GivClass()
+{
+    ASM_TRAP();
+    return NULL;
+}
+
+/*
+void CBotVar::SetIndirection(CBotVar* pVar)
+{
+    // nop, only  CBotVarPointer::SetIndirection
+}
+*/
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+// copy a variable in to another
+void CBotVarInt::Copy(CBotVar* pSrc, bool bName)
+{
+    CBotVarInt*    p = (CBotVarInt*)pSrc;
+
+    if ( bName) *m_token    = *p->m_token;
+    m_type        = p->m_type;
+    m_val        = p->m_val;
+    m_binit        = p->m_binit;
+    m_pMyThis    = NULL;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // identificator is the same (by défaut)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+
+    m_defnum    = p->m_defnum;
+}
+
+
+
+
+void CBotVarInt::SetValInt(int val, const char* defnum)
+{
+    m_val = val;
+    m_binit    = true;
+    m_defnum = defnum;
+}
+
+
+
+void CBotVarInt::SetValFloat(float val)
+{
+    m_val = (int)val;
+    m_binit    = true;
+}
+
+int CBotVarInt::GivValInt()
+{
+    return    m_val;
+}
+
+float CBotVarInt::GivValFloat()
+{
+    return (float)m_val;
+}
+
+CBotString CBotVarInt::GivValString()
+{
+    if ( !m_defnum.IsEmpty() ) return m_defnum;
+
+    CBotString res;
+
+    if ( !m_binit )
+    {
+        res.LoadString(TX_UNDEF);
+        return res;
+    }
+    if ( m_binit == IS_NAN )
+    {
+        res.LoadString(TX_NAN);
+        return res;
+    }
+
+    char        buffer[300];
+    sprintf(buffer, "%d", m_val);
+    res = buffer;
+
+    return    res;
+}
+
+
+void CBotVarInt::Mul(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() * right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::Power(CBotVar* left, CBotVar* right)
+{
+    m_val = (int) pow( (double) left->GivValInt() , (double) right->GivValInt() );
+    m_binit = true;
+}
+
+int CBotVarInt::Div(CBotVar* left, CBotVar* right)
+{
+    int    r = right->GivValInt();
+    if ( r != 0 )
+    {
+        m_val = left->GivValInt() / r;
+        m_binit = true;
+    }
+    return ( r == 0 ? TX_DIVZERO : 0 );
+}
+
+int CBotVarInt::Modulo(CBotVar* left, CBotVar* right)
+{
+    int    r = right->GivValInt();
+    if ( r != 0 )
+    {
+        m_val = left->GivValInt() % r;
+        m_binit = true;
+    }
+    return ( r == 0 ? TX_DIVZERO : 0 );
+}
+
+void CBotVarInt::Add(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() + right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::Sub(CBotVar* left, CBotVar* right)
+{
+        m_val = left->GivValInt() - right->GivValInt();
+        m_binit = true;
+}
+
+void CBotVarInt::XOr(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() ^ right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::And(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() & right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::Or(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() | right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::SL(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() << right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::ASR(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() >> right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarInt::SR(CBotVar* left, CBotVar* right)
+{
+    int    source = left->GivValInt();
+    int shift  = right->GivValInt();
+    if (shift>=1) source &= 0x7fffffff;
+    m_val = source >> shift;
+    m_binit = true;
+}
+
+void CBotVarInt::Neg()
+{
+        m_val = -m_val;
+}
+
+void CBotVarInt::Not()
+{
+        m_val = ~m_val;
+}
+
+void CBotVarInt::Inc()
+{
+        m_val++;
+        m_defnum.Empty();
+}
+
+void CBotVarInt::Dec()
+{
+        m_val--;
+        m_defnum.Empty();
+}
+
+bool CBotVarInt::Lo(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() < right->GivValInt();
+}
+
+bool CBotVarInt::Hi(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() > right->GivValInt();
+}
+
+bool CBotVarInt::Ls(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() <= right->GivValInt();
+}
+
+bool CBotVarInt::Hs(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() >= right->GivValInt();
+}
+
+bool CBotVarInt::Eq(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() == right->GivValInt();
+}
+
+bool CBotVarInt::Ne(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() != right->GivValInt();
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+// copy a variable into another
+void CBotVarFloat::Copy(CBotVar* pSrc, bool bName)
+{
+    CBotVarFloat*    p = (CBotVarFloat*)pSrc;
+
+    if (bName)     *m_token    = *p->m_token;
+    m_type        = p->m_type;
+    m_val        = p->m_val;
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_next        = NULL;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+}
+
+
+
+
+void CBotVarFloat::SetValInt(int val, const char* s)
+{
+    m_val = (float)val;
+    m_binit    = true;
+}
+
+void CBotVarFloat::SetValFloat(float val)
+{
+    m_val = val;
+    m_binit    = true;
+}
+
+int CBotVarFloat::GivValInt()
+{
+    return    (int)m_val;
+}
+
+float CBotVarFloat::GivValFloat()
+{
+    return m_val;
+}
+
+CBotString CBotVarFloat::GivValString()
+{
+    CBotString res;
+
+    if ( !m_binit )
+    {
+        res.LoadString(TX_UNDEF);
+        return res;
+    }
+    if ( m_binit == IS_NAN )
+    {
+        res.LoadString(TX_NAN);
+        return res;
+    }
+
+    char        buffer[300];
+    sprintf(buffer, "%.2f", m_val);
+    res = buffer;
+
+    return    res;
+}
+
+
+void CBotVarFloat::Mul(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValFloat() * right->GivValFloat();
+    m_binit = true;
+}
+
+void CBotVarFloat::Power(CBotVar* left, CBotVar* right)
+{
+    m_val = (float)pow( left->GivValFloat() , right->GivValFloat() );
+    m_binit = true;
+}
+
+int CBotVarFloat::Div(CBotVar* left, CBotVar* right)
+{
+    float    r = right->GivValFloat();
+    if ( r != 0 )
+    {
+        m_val = left->GivValFloat() / r;
+        m_binit = true;
+    }
+    return ( r == 0 ? TX_DIVZERO : 0 );
+}
+
+int CBotVarFloat::Modulo(CBotVar* left, CBotVar* right)
+{
+    float    r = right->GivValFloat();
+    if ( r != 0 )
+    {
+        m_val = (float)fmod( left->GivValFloat() , r );
+        m_binit = true;
+    }
+    return ( r == 0 ? TX_DIVZERO : 0 );
+}
+
+void CBotVarFloat::Add(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValFloat() + right->GivValFloat();
+    m_binit = true;
+}
+
+void CBotVarFloat::Sub(CBotVar* left, CBotVar* right)
+{
+        m_val = left->GivValFloat() - right->GivValFloat();
+        m_binit = true;
+}
+
+void CBotVarFloat::Neg()
+{
+        m_val = -m_val;
+}
+
+void CBotVarFloat::Inc()
+{
+        m_val++;
+}
+
+void CBotVarFloat::Dec()
+{
+        m_val--;
+}
+
+
+bool CBotVarFloat::Lo(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() < right->GivValFloat();
+}
+
+bool CBotVarFloat::Hi(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() > right->GivValFloat();
+}
+
+bool CBotVarFloat::Ls(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() <= right->GivValFloat();
+}
+
+bool CBotVarFloat::Hs(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() >= right->GivValFloat();
+}
+
+bool CBotVarFloat::Eq(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() == right->GivValFloat();
+}
+
+bool CBotVarFloat::Ne(CBotVar* left, CBotVar* right)
+{
+    return left->GivValFloat() != right->GivValFloat();
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+// copy a variable into another
+void CBotVarBoolean::Copy(CBotVar* pSrc, bool bName)
+{
+    CBotVarBoolean*    p = (CBotVarBoolean*)pSrc;
+
+    if (bName)    *m_token    = *p->m_token;
+    m_type        = p->m_type;
+    m_val        = p->m_val;
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_next        = NULL;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+}
+
+
+
+
+void CBotVarBoolean::SetValInt(int val, const char* s)
+{
+    m_val = (bool)val;
+    m_binit    = true;
+}
+
+void CBotVarBoolean::SetValFloat(float val)
+{
+    m_val = (bool)val;
+    m_binit    = true;
+}
+
+int CBotVarBoolean::GivValInt()
+{
+    return    m_val;
+}
+
+float CBotVarBoolean::GivValFloat()
+{
+    return (float)m_val;
+}
+
+CBotString CBotVarBoolean::GivValString()
+{
+    CBotString    ret;
+
+    CBotString res;
+
+    if ( !m_binit )
+    {
+        res.LoadString(TX_UNDEF);
+        return res;
+    }
+    if ( m_binit == IS_NAN )
+    {
+        res.LoadString(TX_NAN);
+        return res;
+    }
+
+    ret.LoadString( m_val > 0 ? ID_TRUE : ID_FALSE );
+    return    ret;
+}
+
+void CBotVarBoolean::And(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() && right->GivValInt();
+    m_binit = true;
+}
+void CBotVarBoolean::Or(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() || right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarBoolean::XOr(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValInt() ^ right->GivValInt();
+    m_binit = true;
+}
+
+void CBotVarBoolean::Not()
+{
+    m_val = m_val ? false : true ; 
+}
+
+bool CBotVarBoolean::Eq(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() == right->GivValInt();
+}
+
+bool CBotVarBoolean::Ne(CBotVar* left, CBotVar* right)
+{
+    return left->GivValInt() != right->GivValInt();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+
+// copy a variable into another
+void CBotVarString::Copy(CBotVar* pSrc, bool bName)
+{
+    CBotVarString*    p = (CBotVarString*)pSrc;
+
+    if (bName)    *m_token    = *p->m_token;
+    m_type        = p->m_type;
+    m_val        = p->m_val;
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_next        = NULL;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+}
+
+
+void CBotVarString::SetValString(const char* p)
+{
+    m_val = p;
+    m_binit    = true;
+}
+
+CBotString CBotVarString::GivValString()
+{
+    if ( !m_binit )
+    {
+        CBotString res;
+        res.LoadString(TX_UNDEF);
+        return res;
+    }
+    if ( m_binit == IS_NAN )
+    {
+        CBotString res;
+        res.LoadString(TX_NAN);
+        return res;
+    }
+
+    return    m_val;
+}
+
+
+void CBotVarString::Add(CBotVar* left, CBotVar* right)
+{
+    m_val = left->GivValString() + right->GivValString();
+    m_binit = true;
+}
+
+bool CBotVarString::Eq(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() == right->GivValString());
+}
+
+bool CBotVarString::Ne(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() != right->GivValString());
+}
+
+
+bool CBotVarString::Lo(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() == right->GivValString());
+}
+
+bool CBotVarString::Hi(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() == right->GivValString());
+}
+
+bool CBotVarString::Ls(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() == right->GivValString());
+}
+
+bool CBotVarString::Hs(CBotVar* left, CBotVar* right)
+{
+    return (left->GivValString() == right->GivValString());
+}
+
+
+////////////////////////////////////////////////////////////////
+
+// copy a variable into another
+void CBotVarClass::Copy(CBotVar* pSrc, bool bName)
+{
+    pSrc = pSrc->GivPointer();                    // if source given by a pointer
+
+    if ( pSrc->GivType() != CBotTypClass )
+        ASM_TRAP();
+
+    CBotVarClass*    p = (CBotVarClass*)pSrc;
+
+    if (bName)    *m_token    = *p->m_token;
+
+    m_type        = p->m_type;
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_pClass    = p->m_pClass;
+    if ( p->m_pParent )
+    {
+        ASM_TRAP();        "que faire du pParent";
+    }
+
+//    m_next        = NULL;
+    m_pUserPtr    = p->m_pUserPtr;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_ItemIdent = p->m_ItemIdent;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+
+    delete        m_pVar;
+    m_pVar        = NULL;
+
+    CBotVar*    pv = p->m_pVar;
+    while( pv != NULL )
+    {
+        CBotVar*    pn = CBotVar::Create(pv);
+        pn->Copy( pv );
+        if ( m_pVar == NULL ) m_pVar = pn;
+        else m_pVar->AddNext(pn);
+
+        pv = pv->GivNext();
+    }
+}
+
+void CBotVarClass::SetItemList(CBotVar* pVar)
+{
+    delete    m_pVar;
+    m_pVar    = pVar;    // replaces the existing pointer
+}
+
+void CBotVarClass::SetIdent(long n)
+{
+    m_ItemIdent = n;
+}
+
+void CBotVarClass::SetClass(CBotClass* pClass)//, int &nIdent)
+{
+    m_type.m_pClass = pClass;
+
+    if ( m_pClass == pClass ) return;
+
+    m_pClass = pClass;
+
+    // initializes the variables associated with this class
+    delete m_pVar;
+    m_pVar = NULL;
+
+    if (pClass == NULL) return;
+
+    CBotVar*    pv = pClass->GivVar();                // first on a list
+    while ( pv != NULL )
+    {
+        // seeks the maximum dimensions of the table
+        CBotInstr*    p  = pv->m_LimExpr;                            // the different formulas
+        if ( p != NULL )
+        {
+            CBotStack* pile = CBotStack::FirstStack();    // an independent stack 
+            int     n = 0;
+            int     max[100];
+
+            while (p != NULL)
+            {
+                while( pile->IsOk() && !p->Execute(pile) ) ;        // calculate size without interruptions
+                CBotVar*    v = pile->GivVar();                        // result
+                max[n] = v->GivValInt();                            // value
+                n++;
+                p = p->GivNext3();
+            }
+            while (n<100) max[n++] = 0;
+
+            pv->m_type.SetArray( max );                    // stores the limitations
+            pile->Delete();
+        }
+
+        CBotVar*    pn = CBotVar::Create( pv );        // a copy
+        pn->SetStatic(pv->IsStatic());
+        pn->SetPrivate(pv->GivPrivate());
+
+        if ( pv->m_InitExpr != NULL )                // expression for initialization?
+        {
+#if    STACKMEM
+            CBotStack* pile = CBotStack::FirstStack();    // an independent stack
+
+            while(pile->IsOk() && !pv->m_InitExpr->Execute(pile, pn));    // evaluates the expression without timer
+
+            pile->Delete();
+#else
+            CBotStack* pile = new CBotStack(NULL);     // an independent stack
+            while(!pv->m_InitExpr->Execute(pile));    // evaluates the expression without timer
+            pn->SetVal( pile->GivVar() ) ;
+            delete pile;
+#endif
+        }
+
+//        pn->SetUniqNum(CBotVar::NextUniqNum());        // enumerate elements
+        pn->SetUniqNum(pv->GivUniqNum());    //++nIdent
+        pn->m_pMyThis = this;
+
+        if ( m_pVar == NULL) m_pVar = pn;
+        else m_pVar->AddNext( pn );
+        pv = pv->GivNext();
+    }
+}
+
+CBotClass* CBotVarClass::GivClass()
+{
+    return    m_pClass;
+}
+
+
+void CBotVarClass::Maj(void* pUser, bool bContinu)
+{
+/*    if (!bContinu && m_pMyThis != NULL) 
+        m_pMyThis->Maj(pUser, true);*/
+
+    // an update routine exist?
+
+    if ( m_pClass->m_rMaj == NULL ) return;
+
+    // retrieves the user pointer according to the class
+    // or according to the parameter passed to CBotProgram::Run()
+
+    if ( m_pUserPtr != NULL) pUser = m_pUserPtr;
+    if ( pUser == OBJECTDELETED ||
+         pUser == OBJECTCREATED ) return;
+    m_pClass->m_rMaj( this, pUser );
+}
+
+CBotVar* CBotVarClass::GivItem(const char* name)
+{
+    CBotVar*    p = m_pVar;
+
+    while ( p != NULL )
+    {
+        if ( p->GivName() == name ) return p;
+        p = p->GivNext();
+    }
+
+    if ( m_pParent != NULL ) return m_pParent->GivItem(name);
+    return NULL;
+}
+
+CBotVar* CBotVarClass::GivItemRef(int nIdent)
+{
+    CBotVar*    p = m_pVar;
+
+    while ( p != NULL )
+    {
+        if ( p->GivUniqNum() == nIdent ) return p;
+        p = p->GivNext();
+    }
+
+    if ( m_pParent != NULL ) return m_pParent->GivItemRef(nIdent);
+    return NULL;
+}
+
+// for the management of an array
+// bExtend can enlarge the table, but not beyond the threshold size of SetArray ()
+
+CBotVar* CBotVarClass::GivItem(int n, bool bExtend)
+{
+    CBotVar*    p = m_pVar;
+
+    if ( n < 0 ) return NULL;
+    if ( n > MAXARRAYSIZE ) return NULL;
+
+    if ( m_type.GivLimite() >= 0 && n >= m_type.GivLimite() ) return NULL;
+
+    if ( p == NULL && bExtend )
+    {
+        p = CBotVar::Create("", m_type.GivTypElem());
+        m_pVar = p;
+    }
+
+    if ( n == 0 ) return p;
+
+    while ( n-- > 0 )
+    {
+        if ( p->m_next == NULL )
+        {
+            if ( bExtend ) p->m_next = CBotVar::Create("", m_type.GivTypElem());
+            if ( p->m_next == NULL ) return NULL;
+        }
+        p = p->m_next;
+    }
+
+    return p;
+}
+
+CBotVar* CBotVarClass::GivItemList()
+{
+    return m_pVar;
+}
+
+
+CBotString CBotVarClass::GivValString()
+{
+//    if ( m_Indirect != NULL) return m_Indirect->GivValString();
+
+    CBotString    res;
+
+    if ( m_pClass != NULL )                        // not used for an array
+    {
+        res = m_pClass->GivName() + CBotString("( ");
+
+        CBotVarClass*    my = this;
+        while ( my != NULL )
+        {
+            CBotVar*    pv = my->m_pVar;
+            while ( pv != NULL )
+            {
+                res += pv->GivName() + CBotString("=");
+
+                if ( pv->IsStatic() )
+                {
+                    CBotVar* pvv = my->m_pClass->GivItem(pv->GivName());
+                    res += pvv->GivValString();
+                }
+                else
+                {
+                    res += pv->GivValString();
+                }
+                pv = pv->GivNext();
+                if ( pv != NULL ) res += ", ";
+            }
+            my = my->m_pParent;
+            if ( my != NULL )
+            {
+                res += ") extends ";
+                res += my->m_pClass->GivName();
+                res += " (";
+            }
+        }
+    }
+    else
+    {
+        res = "( ";
+
+        CBotVar*    pv = m_pVar;
+        while ( pv != NULL )
+        {
+            res += pv->GivValString();
+            if ( pv->GivNext() != NULL ) res += ", ";
+            pv = pv->GivNext();
+        }
+    }
+
+    res += " )";
+    return    res;
+}
+
+void CBotVarClass::IncrementUse()
+{
+    m_CptUse++;
+}
+
+void CBotVarClass::DecrementUse()
+{
+    m_CptUse--;
+    if ( m_CptUse == 0 ) 
+    {
+        // if there is one, call the destructor
+        // but only if a constructor had been called.
+        if ( m_bConstructor )
+        {
+            m_CptUse++;    // does not return to the destructor
+
+            // m_error is static in the stack
+            // saves the value for return
+            int    err, start, end;
+            CBotStack*    pile = NULL;
+            err = pile->GivError(start,end);    // stack == NULL it does not bother!
+
+            pile = CBotStack::FirstStack();        // clears the error
+            CBotVar*    ppVars[1];
+            ppVars[0] = NULL;
+
+            CBotVar*    pThis  = CBotVar::Create("this", CBotTypNullPointer);
+            pThis->SetPointer(this);
+            CBotVar*    pResult = NULL;
+
+            CBotString    nom = "~" + m_pClass->GivName();
+            long        ident = 0;
+
+            while ( pile->IsOk() && !m_pClass->ExecuteMethode(ident, nom, pThis, ppVars, pResult, pile, NULL)) ;    // waits for the end
+
+            pile->ResetError(err, start,end);
+
+            pile->Delete();
+            delete pThis;
+            m_CptUse--;
+        }
+
+        delete this; // self-destructs!
+    }
+}
+
+CBotVarClass* CBotVarClass::GivPointer()
+{
+    return this;
+}
+
+
+// makes an instance according to its unique number
+
+CBotVarClass* CBotVarClass::Find(long id)
+{
+    CBotVarClass*    p = m_ExClass;
+
+    while ( p != NULL )
+    {
+        if ( p->m_ItemIdent == id ) return p;
+        p = p->m_ExNext;
+    }
+
+    return NULL;
+}
+
+bool CBotVarClass::Eq(CBotVar* left, CBotVar* right)
+{
+    CBotVar*    l = left->GivItemList();
+    CBotVar*    r = right->GivItemList();
+
+    while ( l != NULL && r != NULL )
+    {
+        if ( l->Ne(l, r) ) return false;
+        l = l->GivNext();
+        r = r->GivNext();
+    }
+
+    // should always arrived simultaneously at the end (same classes)
+    return l == r;
+}
+
+bool CBotVarClass::Ne(CBotVar* left, CBotVar* right)
+{
+    CBotVar*    l = left->GivItemList();
+    CBotVar*    r = right->GivItemList();
+
+    while ( l != NULL && r != NULL )
+    {
+        if ( l->Ne(l, r) ) return true;
+        l = l->GivNext();
+        r = r->GivNext();
+    }
+
+    // should always arrived simultaneously at the end (same classes)
+    return l != r;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// management of arrays
+
+CBotVarArray::CBotVarArray(const CBotToken* name, CBotTypResult& type )
+{
+    if ( !type.Eq(CBotTypArrayPointer) &&
+         !type.Eq(CBotTypArrayBody)) ASM_TRAP();
+
+    m_token        = new CBotToken(name);
+    m_next        = NULL;
+    m_pMyThis    = NULL;
+    m_pUserPtr    = NULL;
+
+    m_type        = type;
+    m_type.SetType(CBotTypArrayPointer);
+    m_binit        = false;
+
+    m_pInstance    = NULL;                        // the list of the array elements
+}
+
+CBotVarArray::~CBotVarArray()
+{
+    if ( m_pInstance != NULL ) m_pInstance->DecrementUse();    // the lowest reference
+}
+
+// copy a variable into another
+void CBotVarArray::Copy(CBotVar* pSrc, bool bName)
+{
+    if ( pSrc->GivType() != CBotTypArrayPointer )
+        ASM_TRAP();
+
+    CBotVarArray*    p = (CBotVarArray*)pSrc;
+
+    if ( bName) *m_token    = *p->m_token;
+    m_type        = p->m_type;
+    m_pInstance = p->GivPointer();
+
+    if ( m_pInstance != NULL )
+         m_pInstance->IncrementUse();            // a reference increase
+
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+}
+
+void CBotVarArray::SetPointer(CBotVar* pVarClass)
+{
+    m_binit = true;                            // init, even on a null pointer
+
+    if ( m_pInstance == pVarClass) return;    // Special, not decrement and reincrement
+                                            // because the decrement can destroy the object
+
+    if ( pVarClass != NULL )
+    {
+        if ( pVarClass->GivType() == CBotTypArrayPointer )
+             pVarClass = pVarClass->GivPointer();    // the real pointer to the object
+
+        if ( !pVarClass->m_type.Eq(CBotTypClass) &&
+             !pVarClass->m_type.Eq(CBotTypArrayBody))
+            ASM_TRAP();
+
+        ((CBotVarClass*)pVarClass)->IncrementUse();            // incement the reference
+    }
+
+    if ( m_pInstance != NULL ) m_pInstance->DecrementUse();
+    m_pInstance = (CBotVarClass*)pVarClass;
+}
+
+
+CBotVarClass* CBotVarArray::GivPointer()
+{
+    if ( m_pInstance == NULL ) return NULL;
+    return m_pInstance->GivPointer();
+}
+
+CBotVar* CBotVarArray::GivItem(int n, bool bExtend)
+{
+    if ( m_pInstance == NULL )
+    {
+        if ( !bExtend ) return NULL;
+        // creates an instance of the table
+
+        CBotVarClass* instance = new CBotVarClass(NULL, m_type);
+        SetPointer( instance );
+    }
+    return m_pInstance->GivItem(n, bExtend);
+}
+
+CBotVar* CBotVarArray::GivItemList()
+{
+    if ( m_pInstance == NULL) return NULL;
+    return m_pInstance->GivItemList();
+}
+
+CBotString CBotVarArray::GivValString()
+{
+    if ( m_pInstance == NULL ) return ( CBotString( "Null pointer" ) ) ;
+    return m_pInstance->GivValString();
+}
+
+bool CBotVarArray::Save1State(FILE* pf)
+{
+    if ( !WriteType(pf, m_type) ) return false;
+    return SaveVar(pf, m_pInstance);                        // saves the instance that manages the table
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+// gestion des pointeurs à une instance donnée
+// TODO management of pointers to a given instance
+
+CBotVarPointer::CBotVarPointer(const CBotToken* name, CBotTypResult& type )
+{
+    if ( !type.Eq(CBotTypPointer) &&
+         !type.Eq(CBotTypNullPointer) &&
+         !type.Eq(CBotTypClass)   &&                    // for convenience accepts Class and Intrinsic
+         !type.Eq(CBotTypIntrinsic) ) ASM_TRAP();
+
+    m_token        = new CBotToken(name);
+    m_next        = NULL;
+    m_pMyThis    = NULL;
+    m_pUserPtr    = NULL;
+
+    m_type        = type;
+    if ( !type.Eq(CBotTypNullPointer) )
+        m_type.SetType(CBotTypPointer);                    // anyway, this is a pointer
+    m_binit        = false;
+    m_pClass    = NULL;
+    m_pVarClass = NULL;                                    // will be defined by a SetPointer()
+
+    SetClass(type.GivClass() );
+}
+
+CBotVarPointer::~CBotVarPointer()
+{
+    if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();    // decrement reference
+}
+
+
+void CBotVarPointer::Maj(void* pUser, bool bContinu)
+{
+/*    if ( !bContinu && m_pMyThis != NULL )
+         m_pMyThis->Maj(pUser, false);*/
+
+    if ( m_pVarClass != NULL) m_pVarClass->Maj(pUser, false);
+}
+
+CBotVar* CBotVarPointer::GivItem(const char* name)
+{
+    if ( m_pVarClass == NULL)                // no existing instance?
+        return m_pClass->GivItem(name);        // makes the pointer in the class itself
+
+    return m_pVarClass->GivItem(name);
+}
+
+CBotVar* CBotVarPointer::GivItemRef(int nIdent)
+{
+    if ( m_pVarClass == NULL)                // no existing instance?
+        return m_pClass->GivItemRef(nIdent);// makes the pointer to the class itself
+
+    return m_pVarClass->GivItemRef(nIdent);
+}
+
+CBotVar* CBotVarPointer::GivItemList()
+{
+    if ( m_pVarClass == NULL) return NULL;
+    return m_pVarClass->GivItemList();
+}
+
+CBotString CBotVarPointer::GivValString()
+{
+    CBotString    s = "Pointer to ";
+    if ( m_pVarClass == NULL ) s = "Null pointer" ;
+    else  s += m_pVarClass->GivValString();
+    return s;
+}
+
+
+void CBotVarPointer::ConstructorSet()
+{
+    if ( m_pVarClass != NULL) m_pVarClass->ConstructorSet();
+}
+
+// initializes the pointer to the instance of a class
+
+void CBotVarPointer::SetPointer(CBotVar* pVarClass)
+{
+    m_binit = true;                            // init, even on a null pointer
+
+    if ( m_pVarClass == pVarClass) return;    // special, not decrement and reincrement
+                                            // because the decrement can destroy the object
+
+    if ( pVarClass != NULL )
+    {
+        if ( pVarClass->GivType() == CBotTypPointer )
+             pVarClass = pVarClass->GivPointer();    // the real pointer to the object
+
+//        if ( pVarClass->GivType() != CBotTypClass )
+        if ( !pVarClass->m_type.Eq(CBotTypClass) )
+            ASM_TRAP();
+
+        ((CBotVarClass*)pVarClass)->IncrementUse();            // increment the reference
+        m_pClass = ((CBotVarClass*)pVarClass)->m_pClass;
+        m_pUserPtr = pVarClass->m_pUserPtr;                    // not really necessary
+        m_type = CBotTypResult(CBotTypPointer, m_pClass);    // what kind of a pointer
+    }
+
+    if ( m_pVarClass != NULL ) m_pVarClass->DecrementUse();
+    m_pVarClass = (CBotVarClass*)pVarClass;
+
+}
+
+CBotVarClass* CBotVarPointer::GivPointer()
+{
+    if ( m_pVarClass == NULL ) return NULL;
+    return m_pVarClass->GivPointer();
+}
+
+void CBotVarPointer::SetIdent(long n)
+{
+    if ( m_pVarClass == NULL ) return;
+    m_pVarClass->SetIdent( n );
+}
+
+long CBotVarPointer::GivIdent()
+{
+    if ( m_pVarClass == NULL ) return 0;
+    return m_pVarClass->m_ItemIdent;
+}
+
+
+void CBotVarPointer::SetClass(CBotClass* pClass)
+{
+//    int        nIdent = 0;
+    m_type.m_pClass = m_pClass = pClass;
+    if ( m_pVarClass != NULL ) m_pVarClass->SetClass(pClass); //, nIdent);
+}
+
+CBotClass* CBotVarPointer::GivClass()
+{
+    if ( m_pVarClass != NULL ) return m_pVarClass->GivClass();
+
+    return    m_pClass;
+}
+
+
+bool CBotVarPointer::Save1State(FILE* pf)
+{
+    if ( m_pClass )
+    {
+        if (!WriteString(pf, m_pClass->GivName())) return false;    // name of the class
+    }
+    else
+    {
+        if (!WriteString(pf, "")) return false;
+    }
+
+    if (!WriteLong(pf, GivIdent())) return false;        // the unique reference
+
+    // also saves the proceedings copies  
+    return SaveVar(pf, GivPointer());
+}
+
+// copy a variable into another
+void CBotVarPointer::Copy(CBotVar* pSrc, bool bName)
+{
+    if ( pSrc->GivType() != CBotTypPointer &&
+         pSrc->GivType() != CBotTypNullPointer)
+        ASM_TRAP();
+
+    CBotVarPointer*    p = (CBotVarPointer*)pSrc;
+
+    if ( bName) *m_token    = *p->m_token;
+    m_type        = p->m_type;
+//    m_pVarClass = p->m_pVarClass;
+    m_pVarClass = p->GivPointer();
+
+    if ( m_pVarClass != NULL )
+         m_pVarClass->IncrementUse();            // incerement the reference
+
+    m_pClass    = p->m_pClass;
+    m_binit        = p->m_binit;
+//-    m_bStatic    = p->m_bStatic;
+    m_next        = NULL;
+    m_pMyThis    = NULL;//p->m_pMyThis;
+    m_pUserPtr    = p->m_pUserPtr;
+
+    // keeps indentificator the same (by default)
+    if (m_ident == 0 ) m_ident     = p->m_ident;
+}
+
+bool CBotVarPointer::Eq(CBotVar* left, CBotVar* right)
+{
+    CBotVarClass*    l = left->GivPointer();
+    CBotVarClass*    r = right->GivPointer();
+
+    if ( l == r ) return true;
+    if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return true;
+    if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return true;
+    return false;
+}
+
+bool CBotVarPointer::Ne(CBotVar* left, CBotVar* right)
+{
+    CBotVarClass*    l = left->GivPointer();
+    CBotVarClass*    r = right->GivPointer();
+
+    if ( l == r ) return false;
+    if ( l == NULL && r->GivUserPtr() == OBJECTDELETED ) return false;
+    if ( r == NULL && l->GivUserPtr() == OBJECTDELETED ) return false;
+    return true;
+}
+
+
+
+///////////////////////////////////////////////////////
+// management of results types 
+
+
+CBotTypResult::CBotTypResult(int type)
+{
+    m_type        = type;
+    m_pNext        = NULL;
+    m_pClass    = NULL;
+    m_limite    = -1;
+}
+
+CBotTypResult::CBotTypResult(int type, const char* name)
+{
+    m_type        = type;
+    m_pNext        = NULL;
+    m_pClass    = NULL;
+    m_limite    = -1;
+
+    if ( type == CBotTypPointer ||
+         type == CBotTypClass   ||
+         type == CBotTypIntrinsic )
+    {
+        m_pClass = CBotClass::Find(name);
+        if ( m_pClass && m_pClass->IsIntrinsic() ) m_type = CBotTypIntrinsic;
+    }
+}
+
+CBotTypResult::CBotTypResult(int type, CBotClass* pClass)
+{
+    m_type        = type;
+    m_pNext        = NULL;
+    m_pClass    = pClass;
+    m_limite    = -1;
+
+    if ( m_pClass && m_pClass->IsIntrinsic() ) m_type = CBotTypIntrinsic;
+}
+
+CBotTypResult::CBotTypResult(int type, CBotTypResult elem)
+{
+    m_type        = type;
+    m_pNext        = NULL;
+    m_pClass    = NULL;
+    m_limite    = -1;
+
+    if ( type == CBotTypArrayPointer ||
+         type == CBotTypArrayBody )
+        m_pNext = new CBotTypResult( elem );
+}
+
+CBotTypResult::CBotTypResult(const CBotTypResult& typ)
+{
+    m_type        = typ.m_type;
+    m_pClass    = typ.m_pClass;
+    m_pNext        = NULL;
+    m_limite    = typ.m_limite;
+
+    if ( typ.m_pNext )
+        m_pNext = new CBotTypResult( *typ.m_pNext );
+}
+
+CBotTypResult::CBotTypResult()
+{
+    m_type        = 0;
+    m_limite    = -1;
+    m_pNext        = NULL;
+    m_pClass    = NULL;
+}
+
+CBotTypResult::~CBotTypResult()
+{
+    delete    m_pNext;
+}
+
+int CBotTypResult::GivType(int mode) const
+{
+#ifdef    _DEBUG
+    if ( m_type == CBotTypPointer ||
+         m_type == CBotTypClass   ||
+         m_type == CBotTypIntrinsic )
+
+         if ( m_pClass == NULL ) ASM_TRAP();
+
+        
+    if ( m_type == CBotTypArrayPointer )
+         if ( m_pNext == NULL ) ASM_TRAP();
+#endif
+    if ( mode == 3 && m_type == CBotTypNullPointer ) return CBotTypPointer;
+    return    m_type;
+}
+
+void CBotTypResult::SetType(int n)
+{
+    m_type = n;
+}
+
+CBotClass* CBotTypResult::GivClass() const
+{
+    return m_pClass;
+}
+
+CBotTypResult& CBotTypResult::GivTypElem() const
+{
+    return *m_pNext;
+}
+
+int CBotTypResult::GivLimite() const
+{
+    return m_limite;
+}
+
+void CBotTypResult::SetLimite(int n)
+{
+    m_limite = n;
+}
+
+void CBotTypResult::SetArray( int* max )
+{
+    m_limite = *max;
+    if (m_limite < 1) m_limite = -1;
+
+    if ( m_pNext != NULL )                    // last dimension?
+    {
+        m_pNext->SetArray( max+1 );
+    }
+}
+
+
+
+bool CBotTypResult::Compare(const CBotTypResult& typ) const
+{
+    if ( m_type != typ.m_type ) return false;
+
+    if ( m_type == CBotTypArrayPointer ) return m_pNext->Compare(*typ.m_pNext);
+
+    if ( m_type == CBotTypPointer ||
+         m_type == CBotTypClass   ||
+         m_type == CBotTypIntrinsic )
+    {
+        return m_pClass == typ.m_pClass;
+    }
+
+    return true;
+}
+
+bool CBotTypResult::Eq(int type) const
+{
+    return m_type == type;
+}
+
+CBotTypResult&
+    CBotTypResult::operator=(const CBotTypResult& src)
+{
+    m_type = src.m_type;
+    m_limite = src.m_limite;
+    m_pClass = src.m_pClass;
+    m_pNext = NULL;
+    if ( src.m_pNext != NULL )
+    {
+        m_pNext = new CBotTypResult(*src.m_pNext);
+    }
+    return *this;
+}
+
+
diff --git a/src/CBot/CBotWhile.cpp b/src/CBot/CBotWhile.cpp
index 124fb3d..51310a9 100644
--- a/src/CBot/CBotWhile.cpp
+++ b/src/CBot/CBotWhile.cpp
@@ -1,1427 +1,1433 @@
-// * 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  http://www.gnu.org/licenses/.///////////////////////////////////////////////////////////////////////

-// ce fichier défini les instructions suivantes:

-//		CBotWhile	"while (condition) {instructions}"

-//		CBotDo		"do {instructions} while (condition)"

-//		CBotFor		"for (init, condition, incr) {instructions}"

-//		CBotSwitch	"switch (val) {instructions}"

-//		CBotCase	"case val:"

-//		CBotBreak	"break", "break label", "continu", "continu label"

-//		CBotTry		"try {instructions}"

-//		CBotCatch	"catch (condition) {instructions}" ou "finally"

-//		CBotThrow	"throw execption"

-

-

-#include "CBot.h"

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "while"

-

-CBotWhile::CBotWhile()

-{

-	m_Condition =

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotWhile";		// debug

-}

-

-CBotWhile::~CBotWhile()

-{

-	delete	m_Condition;	// libère la condition

-	delete	m_Block;		// libère le bloc d'instruction

-}

-

-CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotWhile*	inst = new CBotWhile();			// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	if ( IsOfType( p, TokenTypVar ) &&

-		 IsOfType( p, ID_DOTS ) )

-	{

-		inst->m_label = pp->GivString();		// enregistre le nom du label

-	}

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_WHILE)) return NULL;	// ne devrait jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-	if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )

-	{

-		// la condition existe

-

-		IncLvl(inst->m_label);

-		inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-		DecLvl();

-

-		if ( pStk->IsOk() )

-		{

-			// le bloc d'instruction est ok (il peut être vide !

-

-			return pStack->Return(inst, pStk);	// rend l'objet à qui le demande

-		}

-	}

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute une instruction "while"

-

-BOOL CBotWhile :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this);	// ajoute un élément à la pile

-											// ou le retrouve en cas de reprise

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	while( TRUE ) switch( pile->GivState() )	// exécute la boucle

-	{											// il y a 2 états possibles (selon reprise)

-	case 0:

-		// évalue la condition

-		if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?

-

-		// le résultat de la condition est sur la pile

-

-		// termine s'il y a une erreur ou si la condition est fausse

-		if ( !pile->IsOk() || pile->GivVal() != TRUE )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		// la condition est vrai, passe dans le second mode

-

-		if (!pile->SetState(1)) return FALSE;			// prêt pour la suite

- 

-	case 1:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL && 

-			!m_Block->Execute(pile) )

-		{

-			if (pile->IfContinue(0, m_label)) continue;	// si continue, repasse au test

-			return pj->BreakReturn(pile, m_label);		// transmet le résultat et libère la pile

-		}

- 

-		// termine s'il y a une erreur

-		if ( !pile->IsOk() )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		// repasse au test pour recommencer

-		if (!pile->SetState(0, 0)) return FALSE;

-		continue; 

-	}

-}

-

-void CBotWhile :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-	CBotStack* pile = pj->RestoreStack(this);	// ajoute un élément à la pile

-	if ( pile == NULL ) return;

-

-	switch( pile->GivState() )	

-	{											// il y a 2 états possibles (selon reprise)

-	case 0:

-		// évalue la condition

-		m_Condition->RestoreState(pile, bMain); 

-		return;

- 

-	case 1:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);

-		return;

-	} 

-}

-

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "repeat"

-

-CBotRepeat::CBotRepeat()

-{

-	m_NbIter =

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotRepeat";		// debug

-}

-

-CBotRepeat::~CBotRepeat()

-{

-	delete	m_NbIter;	// libère la condition

-	delete	m_Block;		// libère le bloc d'instruction

-}

-

-CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotRepeat*	inst = new CBotRepeat();			// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	if ( IsOfType( p, TokenTypVar ) &&

-		 IsOfType( p, ID_DOTS ) )

-	{

-		inst->m_label = pp->GivString();		// enregistre le nom du label

-	}

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_REPEAT)) return NULL;	// ne devrait jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-	if ( IsOfType(p, ID_OPENPAR ) )

-	{

-		CBotToken*	ppp = p;					// conserve le ^au token (position début)

-		if ( NULL != (inst->m_NbIter = CBotExpression::Compile( p, pStk )) )

-		{

-			if ( pStk->GivType() < CBotTypLong )

-			{

-				if ( IsOfType(p, ID_CLOSEPAR ) )

-				{

-

-					IncLvl(inst->m_label);

-					inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-					DecLvl();

-

-					if ( pStk->IsOk() )

-					{

-						// le bloc d'instruction est ok (il peut être vide !

-

-						return pStack->Return(inst, pStk);	// rend l'objet à qui le demande

-					}

-				}

-				pStack->SetError(TX_CLOSEPAR, p->GivStart());

-			}

-			pStk->SetStartError(ppp->GivStart());

-			pStk->SetError( TX_BADTYPE, p->GivStart() );

-		}

-		pStack->SetError(TX_ENDOF, p);

-	}

-	pStack->SetError(TX_OPENPAR, p->GivStart());	// manque la parenthèse

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute une instruction "repeat"

-

-BOOL CBotRepeat :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this);	// ajoute un élément à la pile

-											// ou le retrouve en cas de reprise

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	while( TRUE ) switch( pile->GivState() )	// exécute la boucle

-	{											// il y a 2 états possibles (selon reprise)

-	case 0:

-		// évalue le nombre d'itération

-		if ( !m_NbIter->Execute(pile) ) return FALSE; // interrompu ici ?

-

-		// le résultat de la condition est sur la pile

-

-		// termine s'il y a une erreur ou si la condition est fausse

-		int		n;

-		if ( !pile->IsOk() || ( n = pile->GivVal() ) < 1 )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		// met le nombre d'itération +1 dans le "state"

-

-		if (!pile->SetState(n+1)) return FALSE;			// prêt pour la suite

-		continue;										// passe à la suite

-

-	case 1:

-		// fin normale de la boucle

-		return pj->Return(pile);					// transmet le résultat et libère la pile

- 

-	default:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL && 

-			!m_Block->Execute(pile) )

-		{

-			if (pile->IfContinue(pile->GivState()-1, m_label)) continue;	// si continue, repasse au test

-			return pj->BreakReturn(pile, m_label);		// transmet le résultat et libère la pile

-		}

- 

-		// termine s'il y a une erreur

-		if ( !pile->IsOk() )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		// repasse au test pour recommencer

-		if (!pile->SetState(pile->GivState()-1, 0)) return FALSE;

-		continue; 

-	}

-}

-

-void CBotRepeat :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-	CBotStack* pile = pj->RestoreStack(this);	// ajoute un élément à la pile

-	if ( pile == NULL ) return;

-

-	switch( pile->GivState() )	

-	{											// il y a 2 états possibles (selon reprise)

-	case 0:

-		// évalue la condition

-		m_NbIter->RestoreState(pile, bMain); 

-		return;

- 

-	case 1:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);

-		return;

-	} 

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "do"

-

-CBotDo::CBotDo()

-{

-	m_Condition =

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotDo";		// debug

-}

-

-CBotDo::~CBotDo()

-{

-	delete	m_Condition;	// libère la condition

-	delete	m_Block;		// libère le bloc d'instruction

-}

-

-CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotDo*	inst = new CBotDo();				// crée l'objet

-

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	if ( IsOfType( p, TokenTypVar ) &&

-		 IsOfType( p, ID_DOTS ) )

-	{

-		inst->m_label = pp->GivString();		// enregistre le nom du label

-	}

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_DO)) return NULL;		// ne devrait jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-

-	// cherche un bloc d'instruction après le do

-	IncLvl(inst->m_label);

-	inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-	DecLvl();

-

-	if ( pStk->IsOk() )

-	{

-		if (IsOfType(p, ID_WHILE))

-		{

-			if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )

-			{

-				// la condition existe

-				if (IsOfType(p, ID_SEP))

-				{

-					return pStack->Return(inst, pStk);	// rend l'objet à qui le demande

-				}

-				pStk->SetError(TX_ENDOF, p->GivStart());

-			}

-		}

-		pStk->SetError(TX_WHILE, p->GivStart());

-	}

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute une instruction "do"

-

-BOOL CBotDo :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this);		// ajoute un élément à la pile

-												// ou le retrouve en cas de reprise

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	while( TRUE ) switch( pile->GivState() )			// exécute la boucle

-	{													// il y a 2 états possibles (selon reprise)

-	case 0:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL && 

-			!m_Block->Execute(pile) )

-		{

-			if (pile->IfContinue(1, m_label)) continue;	// si continue, repasse au test

-			return pj->BreakReturn(pile, m_label);		// transmet le résultat et libère la pile

-		}

- 

-		// termine s'il y a une erreur

-		if ( !pile->IsOk() )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		if (!pile->SetState(1)) return FALSE;			// prêt pour la suite

- 

-	case 1:

-		// évalue la condition

-		if ( !m_Condition->Execute(pile) ) return FALSE; // interrompu ici ?

-

-		// le résultat de la condition est sur la pile

-

-		// termine s'il y a une erreur ou si la condition est fausse

-		if ( !pile->IsOk() || pile->GivVal() != TRUE )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		// repasse au bloc d'instruction pour recommencer

-		if (!pile->SetState(0, 0)) return FALSE;

-		continue; 

-	}

-}

-

-void CBotDo :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack* pile = pj->RestoreStack(this);			// ajoute un élément à la pile

-	if ( pile == NULL ) return;

-

-	switch( pile->GivState() )

-	{													// il y a 2 états possibles (selon reprise)

-	case 0:

-		// restitue le bloc d'instruction associé

-		if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);

-		return;

-		

-	case 1:

-		// restitue la condition

-		m_Condition->RestoreState(pile, bMain);

-		return;

-	}

-}

-

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "for"

-

-CBotFor::CBotFor()

-{

-	m_Init		=

-	m_Test		=

-	m_Incr		=

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotFor";		// debug

-}

-

-CBotFor::~CBotFor()

-{

-	delete	m_Init;	

-	delete	m_Test;	

-	delete	m_Incr;	

-	delete	m_Block;		// libère le bloc d'instruction

-}

-

-CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotFor*	inst = new CBotFor();			// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	if ( IsOfType( p, TokenTypVar ) &&

-		 IsOfType( p, ID_DOTS ) )

-	{

-		inst->m_label = pp->GivString();		// enregistre le nom du label

-	}

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_FOR)) return NULL;		// ne devrait jamais arriver

-

-	if ( !IsOfType(p, ID_OPENPAR))				// manque la parenthèse ?

-	{

-		pStack->SetError(TX_OPENPAR, p->GivStart());

-		return NULL;

-	}

-

-	CBotCStack* pStk = pStack->TokenStack(pp, TRUE);	// un petit bout de pile svp

-

-	// compile les instructions pour initialisation

-	inst->m_Init = CBotListExpression::Compile( p, pStk );

-	if ( pStk->IsOk() )

-	{

-		if ( !IsOfType(p, ID_SEP))						// manque le point-virgule ?

-		{

-			pStack->SetError(TX_OPENPAR, p->GivStart());

-			delete inst;

-			return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-		}

-		inst->m_Test = CBotBoolExpr::Compile( p, pStk );

-		if ( pStk->IsOk() )

-		{

-			if ( !IsOfType(p, ID_SEP))						// manque le point-virgule ?

-			{

-				pStack->SetError(TX_OPENPAR, p->GivStart());

-				delete inst;

-				return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-			}

-			inst->m_Incr = CBotListExpression::Compile( p, pStk );

-			if ( pStk->IsOk() )

-			{

-				if ( IsOfType(p, ID_CLOSEPAR))				// manque la parenthèse ?

-				{

-					IncLvl(inst->m_label);

-					inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-					DecLvl();

-					if ( pStk->IsOk() )

-						return pStack->Return(inst, pStk);;

-				}

-				pStack->SetError(TX_CLOSEPAR, p->GivStart());

-			}

-		}

-	}

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute l'instruction "for"

-

-BOOL CBotFor :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this, TRUE);		// ajoute un élément à la pile (variables locales)

-													// ou le retrouve en cas de reprise

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	while( TRUE ) switch( pile->GivState() )	// exécute la boucle

-	{											// il y a 4 états possibles (selon reprise)

-	case 0:

-		// évalue l'initialisation

-		if ( m_Init != NULL &&

-			 !m_Init->Execute(pile) ) return FALSE;		// interrompu ici ?

-		if (!pile->SetState(1)) return FALSE;			// prêt pour la suite

- 

-	case 1:

-		// évalue la condition

-		if ( m_Test != NULL )							// pas de condition ? -> vrai !

-		{

-			if (!m_Test->Execute(pile) ) return FALSE;	// interrompu ici ?

-

-			// le résultat de la condition est sur la pile

-

-			// termine s'il y a une erreur ou si la condition est fausse

-			if ( !pile->IsOk() || pile->GivVal() != TRUE )

-			{

-				return pj->Return(pile);				// transmet le résultat et libère la pile

-			}

-		}

-

-		// la condition est vrai, passe à la suite

-		if (!pile->SetState(2)) return FALSE;			// prêt pour la suite

-	

-	case 2:

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL && 

-			!m_Block->Execute(pile) )

- 		{

-			if (pile->IfContinue(3, m_label)) continue;	// si continue, passe à l'incrémentation

-			return pj->BreakReturn(pile, m_label);		// transmet le résultat et libère la pile

-		}

-

-		// termine s'il y a une erreur

-		if ( !pile->IsOk() )

-		{

-			return pj->Return(pile);					// transmet le résultat et libère la pile

-		}

-

-		if (!pile->SetState(3)) return FALSE;			// prêt pour la suite

-

-	case 3:

-		// évalue l'incrémentation

-		if ( m_Incr != NULL &&

-			!m_Incr->Execute(pile) ) return FALSE;		// interrompu ici ?

-

-		// repasse au test pour recommencer

-		if (!pile->SetState(1, 0)) return FALSE;			// revient au test

-		continue; 

-	}

-}

-

-void CBotFor :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack* pile = pj->RestoreStack(this);		// ajoute un élément à la pile (variables locales)

-	if ( pile == NULL ) return;

-

-	switch( pile->GivState() )

-	{											// il y a 4 états possibles (selon reprise)

-	case 0:

-		// évalue l'initialisation

-		if ( m_Init != NULL ) m_Init->RestoreState(pile, TRUE);		// interrompu ici !

-		return;

-		

-	case 1:

-		if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE);	// définitions variables

-

-		// évalue la condition

-		if ( m_Test != NULL ) m_Test->RestoreState(pile, TRUE);		// interrompu ici !

-		return;

-

-	case 2:

-		if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE);	// définitions variables

-

-		// évalue le bloc d'instruction associé

-		if ( m_Block != NULL ) m_Block->RestoreState(pile, TRUE);

-		return;

-

-	case 3:

-		if ( m_Init != NULL ) m_Init->RestoreState(pile, FALSE);	// définitions variables

-

-		// évalue l'incrémentation

-		if ( m_Incr != NULL ) m_Incr->RestoreState(pile, TRUE);		// interrompu ici !

-		return;

-	}

-}

-

-//////////////////////////////////////////////////////////////////////////////////////

-// compile une liste d'expression

-// n'est utilisé que pour l'instruction for

-// dans l'intitialisation et dans l'incrémentation

-

-CBotListExpression::CBotListExpression()

-{

-	m_Expr	= NULL;

-	name = "CBotListExpression";

-}

-

-CBotListExpression::~CBotListExpression()

-{

-	delete	m_Expr;

-}

-

-// cherche une déclaration de variable ou une expression

-

-static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotInstr*	i = CBotInt::Compile( p, pStack, FALSE, TRUE );			// est-ce une déclaration d'un entier ?

-	if ( i== NULL ) i = CBotFloat::Compile( p, pStack, FALSE, TRUE );	// ou d'un nombre réel ?

-	if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, FALSE, TRUE ); // ou d'un booléen ?

-	if ( i== NULL ) i = CBotIString::Compile( p, pStack, FALSE, TRUE );	// ou d'une chaîne ?

-	if ( i== NULL ) i = CBotExpression::Compile( p, pStack );			// compile une expression

-	return i;

-}

-

-CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotListExpression* inst = new CBotListExpression();

-

-	inst->m_Expr = CompileInstrOrDefVar( p, pStack );			// compile la première expression de la liste

-	if (pStack->IsOk())

-	{

-		while ( IsOfType(p, ID_COMMA) )							// plusieurs instructions ?

-		{

-			CBotInstr*	i = CompileInstrOrDefVar( p, pStack );		// est-ce une déclaration d'un entier ?

-			inst->m_Expr->AddNext(i);							// ajoute à la suite

-			if ( !pStack->IsOk() )

-			{

-				delete inst;

-				return NULL;									// pas d'objet, l'erreur est sur la pile

-			}

-		}

-		return inst;

-	}

-	delete inst;

-	return NULL;

-}

-

-BOOL CBotListExpression::Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack();// indispensable

-	CBotInstr*	p = m_Expr;										// la première expression

-

-	int		state = pile->GivState();

-	while (state-->0) p = p->GivNext();							// revient sur l'opération interrompue

-

-	if ( p != NULL ) while (TRUE)

-	{

-		if ( !p->Execute(pile) ) return FALSE;

-		p = p->GivNext();

-		if ( p == NULL ) break;

-		if (!pile->IncState()) return FALSE;					// prêt pour la suivante

-	}

-	return pj->Return(pile);

-}

-

-void CBotListExpression::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	CBotStack*	pile = pj;

-	int		state = 0x7000;

-	

-	if ( bMain )

-	{

-		pile = pj->RestoreStack();

-		if ( pile == NULL ) return;

-		state = pile->GivState();

-	}

-

-	CBotInstr*	p = m_Expr;										// la première expression

-

-	while (p != NULL && state-->0)

-	{

-		p->RestoreState(pile, FALSE);

-		p = p->GivNext();							// revient sur l'opération interrompue

-	}

-

-	if ( p != NULL )

-	{

-		p->RestoreState(pile, bMain);

-	}

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "switch"

-

-CBotSwitch::CBotSwitch()

-{

-	m_Value		=

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotSwitch";		// debug

-}

-

-CBotSwitch::~CBotSwitch()

-{

-	delete	m_Value;		// libère la valeur

-	delete	m_Block;		// libère le bloc d'instruction

-}

-

-

-CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotSwitch*	inst = new CBotSwitch();		// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_SWITCH)) return NULL;	// ne devrait jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-	if ( IsOfType(p, ID_OPENPAR ) )

-	{

-		if ( NULL != (inst->m_Value = CBotExpression::Compile( p, pStk )) )

-		{

-			if ( pStk->GivType() < CBotTypLong )

-			{

-				if ( IsOfType(p, ID_CLOSEPAR ) )

-				{

-					if ( IsOfType(p, ID_OPBLK ) )

-					{

-						IncLvl();

-

-						while( !IsOfType( p, ID_CLBLK ) )

-						{

-							if ( p->GivType() == ID_CASE || p->GivType() == ID_DEFAULT)

-							{

-								CBotCStack* pStk2 = pStk->TokenStack(p);	// un petit bout de pile svp

-

-								CBotInstr* i = CBotCase::Compile( p, pStk2 );

-								if (i == NULL)

-								{

-									delete inst; 

-									return pStack->Return(NULL, pStk2);

-								}

-								delete pStk2;

-								if ( inst->m_Block == NULL ) inst->m_Block = i;

-								else inst->m_Block->AddNext(i);

-								continue;

-							}

-							

-							if ( inst->m_Block == NULL )

-							{

-								pStk->SetError(TX_NOCASE, p->GivStart());

-								delete inst;

-								return pStack->Return(NULL, pStk);

-							}

-

-							CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, TRUE );

-							if ( !pStk->IsOk() )

-							{

-								delete inst;

-								return pStack->Return(NULL, pStk);

-							}

-							inst->m_Block->AddNext(i);

-

-							if ( p == NULL )

-							{

-								pStk->SetError(TX_CLOSEBLK, -1);

-								delete inst;

-								return pStack->Return(NULL, pStk);

-							}

-						}

-						DecLvl();

-							

-						if ( inst->m_Block == NULL )

-						{

-							pStk->SetError(TX_NOCASE, p->GivStart());

-							delete inst;

-							return pStack->Return(NULL, pStk);

-						}

-						// le bloc d'instruction est ok

-						return pStack->Return(inst, pStk);	// rend l'objet à qui le demande

-					}

-					pStk->SetError( TX_OPENBLK, p->GivStart() );

-				}

-				pStk->SetError( TX_CLOSEPAR, p->GivStart() );

-			}

-			pStk->SetError( TX_BADTYPE, p->GivStart() );

-		}

-	}

-	pStk->SetError( TX_OPENPAR, p->GivStart());

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute une instruction "switch"

-

-BOOL CBotSwitch :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile1 = pj->AddStack(this);		// ajoute un élément à la pile 

-//	if ( pile1 == EOX ) return TRUE;

-

-	CBotInstr*	p = m_Block;					// la première expression

-

-	int		state = pile1->GivState();

-	if (state == 0)

-	{

-		if ( !m_Value->Execute(pile1) ) return FALSE;

-		pile1->SetState(state = -1);

-	}

-

-	if ( pile1->IfStep() ) return FALSE;

-

-	if ( state == -1 )

-	{

-		state = 0;

-		int	val = pile1->GivVal();						// résultat de la valeur

-

-		CBotStack* pile2 = pile1->AddStack();

-		while ( p != NULL )								// recherche le case correspondant dans la liste

-		{

-			state++;

-			if ( p->CompCase( pile2, val ) ) break;		// trouvé le case

-			p = p->GivNext();

-		}

-		pile2->Delete();

-

-		if ( p == NULL ) return pj->Return(pile1);		// terminé si plus rien

-

-		if ( !pile1->SetState(state) ) return FALSE;

-	}

-

-	p = m_Block;										// revient au début

-	while (state-->0) p = p->GivNext();					// avance dans la liste

-

-	while( p != NULL )

-	{

-		if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);

-		if ( !pile1->IncState() ) return FALSE;

-		p = p->GivNext();

-	}

-	return pj->Return(pile1);

-}

-

-void CBotSwitch :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack* pile1 = pj->RestoreStack(this);	// ajoute un élément à la pile 

-	if ( pile1 == NULL ) return;

-

-	CBotInstr*	p = m_Block;					// la première expression

-

-	int		state = pile1->GivState();

-	if (state == 0)

-	{

-		m_Value->RestoreState(pile1, bMain);

-		return;

-	}

-

-	if ( state == -1 )

-	{

-		return;

-	}

-

-//	p = m_Block;								// revient au début

-	while ( p != NULL && state-- > 0 )

-	{

-		p->RestoreState(pile1, FALSE);

-		p = p->GivNext();						// avance dans la liste

-	}

-

-	if( p != NULL )

-	{

-		p->RestoreState(pile1, TRUE);

-		return;

-	}

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "case"

-// on est forcément dans un bloc d'instruction "switch"

-

-CBotCase::CBotCase()

-{

-	m_Value		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotCase";		// debug

-}

-

-CBotCase::~CBotCase()

-{

-	delete	m_Value;		// libère la valeur

-}

-

-

-CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCase*	inst = new CBotCase();			// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return NULL;		// ne devrait jamais arriver

-

-	if ( pp->GivType() == ID_CASE )

-	{

-		pp = p;

-		inst->m_Value = CBotExprNum::Compile(p, pStack);

-		if ( inst->m_Value == NULL )

-		{

-			pStack->SetError( TX_BADNUM, pp );

-			delete inst;

-			return NULL;

-		}

-	}

-	if ( !IsOfType( p, ID_DOTS ))

-	{

-		pStack->SetError( TX_MISDOTS, p->GivStart() );

-		delete inst;

-		return NULL;

-	}

-

-	return inst;

-}

-

-// exécution de l'instruction "case"

-

-BOOL CBotCase::Execute(CBotStack* &pj)

-{

-	return TRUE;								// l'instruction "case" ne fait rien !

-}

-

-void CBotCase::RestoreState(CBotStack* &pj, BOOL bMain)

-{

-}

-

-// routine permettant de trouver le point d'entrée "case"

-// correspondant à la valeur cherchée

-

-BOOL CBotCase::CompCase(CBotStack* &pile, int val)

-{

-	if ( m_Value == NULL ) return TRUE;			// cas pour "default"

-

-	while (!m_Value->Execute(pile));			// met sur la pile la valeur correpondant (sans interruption)

-	return (pile->GivVal() == val);				// compare avec la valeur cherchée

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "break" ou "continu"

-

-CBotBreak::CBotBreak()

-{

-	name = "CBotBreak";		// debug

-}

-

-CBotBreak::~CBotBreak()

-{

-}

-

-CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-	int	type = p->GivType();

-

-	if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return NULL;	// ne devrait jamais arriver

-

-	if ( !ChkLvl(CBotString(), type ) )

-	{

-		pStack->SetError(TX_BREAK, pp);

-		return NULL;							// pas d'objet, l'erreur est sur la pile

-	}

-

-	CBotBreak*	inst = new CBotBreak();			// crée l'objet

-	inst->SetToken(pp);							// garde l'opération

-

-	pp = p;

-	if ( IsOfType( p, TokenTypVar ) )

-	{

-		inst->m_label = pp->GivString();		// enregistre le nom du label

-		if ( !ChkLvl(inst->m_label, type ) )

-		{

-			delete inst;

-			pStack->SetError(TX_NOLABEL, pp);

-			return NULL;							// pas d'objet, l'erreur est sur la pile

-		}

-	}

-

-	if (IsOfType(p, ID_SEP))

-	{

-		return	inst;							// et le donne à qui veux

-	}

-	delete inst;

-

-	pStack->SetError(TX_ENDOF, p->GivStart());

-	return NULL;							// pas d'objet, l'erreur est sur la pile

-}

-

-// exécution l'instructino "break" ou "continu"

-

-BOOL CBotBreak :: Execute(CBotStack* &pj)

-{

-	CBotStack* pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->IfStep() ) return FALSE;

-

-	pile->SetBreak(m_token.GivType()==ID_BREAK ? 1 : 2, m_label);

-	return pj->Return(pile);

-}

-

-void CBotBreak :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain ) pj->RestoreStack(this);

-}

-

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "try"

-

-CBotTry::CBotTry()

-{

-	m_ListCatch = NULL;

-	m_FinalInst =

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	name = "CBotTry";		// debug

-}

-

-CBotTry::~CBotTry()

-{

-	delete	m_ListCatch;	// libère la liste

-	delete	m_Block;		// libère le bloc d'instruction

-	delete	m_FinalInst;

-}	

-

-CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotTry*	inst = new CBotTry();			// crée l'objet

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_TRY)) return NULL;		// ne devrait jamais arriver

-

-	CBotCStack* pStk = pStack->TokenStack(pp);	// un petit bout de pile svp

-

-	inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk );

-	CBotCatch**	pn = &inst->m_ListCatch;

-	

-	while (pStk->IsOk() && p->GivType() == ID_CATCH)

-	{

-		CBotCatch*	i = CBotCatch::Compile(p, pStk);

-		*pn = i;

-		pn = &i->m_next;

-	}

-

-	if (pStk->IsOk() && IsOfType( p, ID_FINALLY) )

-	{

-		inst->m_FinalInst = CBotBlock::CompileBlkOrInst( p, pStk );

-	}

-

-	if (pStk->IsOk())

-	{

-		return pStack->Return(inst, pStk);	// rend l'objet à qui le demande

-	}

-

-	delete inst;								// erreur, libère la place

-	return pStack->Return(NULL, pStk);			// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute l'instruction Try

-// gère le retour d'exceptions

-// les arrêts par suspension

-// et les "finaly"

-

-BOOL CBotTry :: Execute(CBotStack* &pj)

-{

-	int		val;

-

-	CBotStack* pile1 = pj->AddStack(this);	// ajoute un élément à la pile

-//	if ( pile1 == EOX ) return TRUE;

-

-	if ( pile1->IfStep() ) return FALSE;

-													// ou le retrouve en cas de reprise

-	CBotStack* pile0 = pj->AddStack2();				// ajoute un élément à la pile secondaire

-	CBotStack* pile2 = pile0->AddStack();

-

-	if ( pile1->GivState() == 0 )

-	{

-		if ( m_Block->Execute(pile1) )

-		{

-			if ( m_FinalInst == NULL ) return pj->Return(pile1);

-			pile1->SetState(-2);								// passe au final

-		}

-

-		val = pile1->GivError();

-		if ( val == 0 && CBotStack::m_initimer == 0 )			// en mode de step ?

-			return FALSE;										// ne fait pas le catch

-

-		pile1->IncState();

-		pile2->SetState(val);									// mémorise le numéro de l'erreur

-		pile1->SetError(0);										// pour l'instant il n'y a plus d'erreur !

-

-		if ( val == 0 && CBotStack::m_initimer < 0 )			// en mode de step ?

-			return FALSE;										// ne fait pas le catch

-	}

-

-	// il y a eu une interruption

-	// voir de quoi il en retourne

-

-	CBotCatch*	pc = m_ListCatch;

-	int	state = (short)pile1->GivState();								// où en étions-nous ?

-	val	= pile2->GivState();									// pour quelle erreur ?

-	pile0->SetState(1);											// marquage pour GetRunPos

-

-	if ( val >= 0 && state > 0 ) while ( pc != NULL )

-	{

-		if ( --state <= 0 )

-		{

-			// demande au bloc catch s'il se sent concerné

-			if ( !pc->TestCatch(pile2, val) ) return FALSE;		// suspendu !

-			pile1->IncState();

-		}

-		if ( --state <= 0 )

-		{

-			if ( pile2->GivVal() == TRUE )

-			{

-//				pile0->SetState(1);

-

-				if ( !pc->Execute(pile2) ) return FALSE;		// exécute l'opération

-				if ( m_FinalInst == NULL )

-					return pj->Return(pile2);					// termine le try

-				

-				pile1->SetState(-2);							// passe au final

-				break;

-			}

-			pile1->IncState();

-		}

-		pc = pc->m_next;

-	}

-	if ( m_FinalInst != NULL && 

-		 pile1->GivState() > 0 && val != 0 ) pile1->SetState(-1);// si arret alors fait le final

-

-	if (pile1->GivState() <= -1)

-	{

-//		pile0->SetState(1);

-	

-		if (!m_FinalInst->Execute(pile2) && pile2->IsOk()) return FALSE;

-		if (!pile2->IsOk()) return pj->Return(pile2);			// garde cette exception

-		pile2->SetError(pile1->GivState()==-1 ? val : 0);		// remet l'erreur initiale

-		return pj->Return(pile2);

-	}

-

-	pile1->SetState(0);											// revient à l'évaluation

-	pile0->SetState(0);											// revient à l'évaluation

-	if ( val != 0 && m_ListCatch == NULL && m_FinalInst == NULL )

-							return pj->Return(pile2);			// termine le try sans exception aucune

-

-	pile1->SetError(val);										// remet l'erreur

-	return FALSE;												// ce n'est pas pour nous

-}

-

-

-void CBotTry :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	int		val;

-	CBotStack* pile1 = pj->RestoreStack(this);	// ajoute un élément à la pile

-	if ( pile1 == NULL ) return;

-													// ou le retrouve en cas de reprise

-	CBotStack* pile0 = pj->AddStack2();				// ajoute un élément à la pile secondaire

-	if ( pile0 == NULL ) return;

-

-	CBotStack* pile2 = pile0->RestoreStack();

-	if ( pile2 == NULL ) return;

-

-	m_Block->RestoreState(pile1, bMain);

-	if ( pile0->GivState() == 0 )

-	{

-		return;

-	}

-

-	// il y a eu une interruption

-	// voir de quoi il en retourne

-

-	CBotCatch*	pc = m_ListCatch;

-	int	state = pile1->GivState();								// où en étions-nous ?

-	val	= pile2->GivState();									// pour quelle erreur ?

-

-	if ( val >= 0 && state > 0 ) while ( pc != NULL )

-	{

-		if ( --state <= 0 )

-		{

-			// demande au bloc catch s'il se sent concerné

-			pc->RestoreCondState(pile2, bMain);		// suspendu !

-			return;

-		}

-		if ( --state <= 0 )

-		{

-			if ( pile2->GivVal() == TRUE )

-			{

-				pc->RestoreState(pile2, bMain);					// exécute l'opération

-				return;

-			}

-		}

-		pc = pc->m_next;

-	}

-

-	if (pile1->GivState() <= -1)

-	{

-		m_FinalInst->RestoreState(pile2, bMain);

-		return;

-	}

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "catch"

-

-CBotCatch::CBotCatch()

-{

-	m_Cond		=

-	m_Block		= NULL;		// NULL pour que delete soit possible sans autre

-	m_next		= NULL;

-

-	name = "CBotCatch";		// debug

-}

-

-CBotCatch::~CBotCatch()

-{

-	delete	m_Cond;			// libère la liste

-	delete	m_Block;		// libère le bloc d'instruction

-	delete	m_next;			// et la suite

-}

-

-CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	CBotCatch*	inst = new CBotCatch();			// crée l'objet

-	pStack->SetStartError(p->GivStart());

-

-	inst->SetToken(p);

-	if (!IsOfType(p, ID_CATCH)) return NULL;	// ne devrait jamais arriver

-

-	if (IsOfType(p, ID_OPENPAR))

-	{

-		inst->m_Cond = CBotExpression::Compile(p, pStack);

-		if (( pStack->GivType() < CBotTypLong ||

-			  pStack->GivTypResult().Eq(CBotTypBoolean) )&& pStack->IsOk() )

-		{

-			if (IsOfType(p, ID_CLOSEPAR))

-			{

-				inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStack );

-				if ( pStack->IsOk() )

-					return inst;				// rend l'objet à qui le demande

-			}

-			pStack->SetError(TX_CLOSEPAR, p->GivStart());

-		}

-		pStack->SetError(TX_BADTYPE, p->GivStart());

-	}

-	pStack->SetError(TX_OPENPAR, p->GivStart());

-	delete inst;								// erreur, libère la place

-	return NULL;								// pas d'objet, l'erreur est sur la pile

-}

-

-// exécution de "catch"

-

-BOOL CBotCatch :: Execute(CBotStack* &pj)

-{

-	if ( m_Block == NULL ) return TRUE;

-	return m_Block->Execute(pj);				// exécute le bloc associé

-}

-

-void CBotCatch :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( bMain && m_Block != NULL ) m_Block->RestoreState(pj, bMain);

-}

-

-void CBotCatch :: RestoreCondState(CBotStack* &pj, BOOL bMain)

-{

-	m_Cond->RestoreState(pj, bMain);

-}

-

-// routine pour savoir si le catch est à faire ou non

-

-BOOL CBotCatch :: TestCatch(CBotStack* &pile, int val)

-{

-	if ( !m_Cond->Execute(pile) ) return FALSE;

-

-	if ( val > 0 || pile->GivType() != CBotTypBoolean )

-	{

-		CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);

-		var->SetValInt( pile->GivVal() == val );

-		pile->SetVar(var);							// remet sur la pile

-	}

-	

-	return TRUE;

-}

-

-///////////////////////////////////////////////////////////////////////////

-

-///////////////////////////////////////////////////////////////////////////

-// compile une instruction "throw"

-

-CBotThrow::CBotThrow()

-{

-	m_Value		= NULL;		// NULL pour que delete soit possible sans autre

-

-	name = "CBotThrow";		// debug

-}

-

-CBotThrow::~CBotThrow()

-{

-	delete	m_Value;

-}

-

-CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-	pStack->SetStartError(p->GivStart());

-

-	CBotThrow*	inst = new CBotThrow();			// crée l'objet

-	inst->SetToken(p);

-

-	CBotToken*	pp = p;							// conserve le ^au token (position début)

-

-	if (!IsOfType(p, ID_THROW)) return NULL;	// ne devrait jamais arriver

-

-	inst->m_Value = CBotExpression::Compile( p, pStack );

-

-	if (pStack->GivType() < CBotTypLong && pStack->IsOk())

-	{

-		return inst;							// rend l'objet à qui le demande

-	}

-	pStack->SetError(TX_BADTYPE, pp);

-

-	delete inst;								// erreur, libère la place

-	return NULL;								// pas d'objet, l'erreur est sur la pile

-}

-

-// exécute l'instruction "throw"

-

-BOOL CBotThrow :: Execute(CBotStack* &pj)

-{

-	CBotStack*	pile = pj->AddStack(this);

-//	if ( pile == EOX ) return TRUE;

-

-	if ( pile->GivState() == 0 )

-	{

-		if ( !m_Value->Execute(pile) ) return FALSE;

-		pile->IncState();

-	}

-

-	if ( pile->IfStep() ) return FALSE;

-

-	int val = pile->GivVal();

-	if ( val < 0 ) val = TX_BADTHROW;

-	pile->SetError( val, &m_token );

-	return pj->Return( pile );

-}

-

-void CBotThrow :: RestoreState(CBotStack* &pj, BOOL bMain)

-{

-	if ( !bMain ) return;

-

-	CBotStack*	pile = pj->RestoreStack(this);

-	if ( pile == NULL ) return;

-

-	if ( pile->GivState() == 0 )

-	{

-		m_Value->RestoreState(pile, bMain);

-		return;

-	}

-}

-

-

-

-////////////////////////////////////////////////////////////

-

-

-CBotStartDebugDD::CBotStartDebugDD()

-{

-	name = "CBotStartDebugDD";		// debug

-}

-

-CBotStartDebugDD::~CBotStartDebugDD()

-{

-}

-

-CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack)

-{

-

-	if (!IsOfType(p, ID_DEBUGDD)) return NULL;	// ne devrait jamais arriver

-

-	return new CBotStartDebugDD();			// crée l'objet

-

-}

-

-// exécute l'instruction "throw"

-

-BOOL CBotStartDebugDD :: Execute(CBotStack* &pj)

-{

-	CBotProgram* p = pj->GivBotCall();

-	p->m_bDebugDD = TRUE;

-

-	return TRUE;

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+///////////////////////////////////////////////////////////////////////
+// This file defined the following statements:
+//      CBotWhile   "while (condition) {instructions}"
+//      CBotDo      "do {instructions} while (condition)"
+//      CBotFor     "for (init, condition, incr) {instructions}"
+//      CBotSwitch  "switch (val) {instructions}"
+//      CBotCase    "case val:"
+//      CBotBreak   "break", "break label", "continu", "continu label"
+//      CBotTry     "try {instructions}"
+//      CBotCatch   "catch (condition) {instructions}" or "finally"
+//      CBotThrow   "throw execption"
+
+
+#include "CBot.h"
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compile an instruction "while"
+
+CBotWhile::CBotWhile()
+{
+    m_Condition =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    name = "CBotWhile";     // debug
+}
+
+CBotWhile::~CBotWhile()
+{
+    delete  m_Condition;    // frees the condition
+    delete  m_Block;        // releases the block instruction
+}
+
+CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotWhile*  inst = new CBotWhile();         // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    if ( IsOfType( p, TokenTypVar ) &&
+         IsOfType( p, ID_DOTS ) )
+    {
+        inst->m_label = pp->GivString();        // records the name of the label
+    }
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_WHILE)) return NULL;    // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+                                                // a bit of battery please (??)
+
+    if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
+    {
+        // the condition exists
+
+        IncLvl(inst->m_label);
+        inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
+        DecLvl();
+
+        if ( pStk->IsOk() )
+        {
+            // the statement block is ok (it may be empty!
+
+            return pStack->Return(inst, pStk);  // return an object to the application
+                                                // makes the object to which the application
+        }
+    }
+
+    delete inst;                                // error, frees the place
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// executes a "while" instruction
+
+bool CBotWhile :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this);   // adds an item to the stack
+                                            // or find in case of recovery
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    while( true ) switch( pile->GivState() )    // executes the loop
+    {                                           // there are two possible states (depending on recovery)
+    case 0:
+        // evaluates the condition
+        if ( !m_Condition->Execute(pile) ) return false; // interrupted here?
+
+        // the result of the condition is on the stack
+
+        // terminates if an error or if the condition is false
+        if ( !pile->IsOk() || pile->GivVal() != true )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        // the condition is true, pass in the second mode
+
+        if (!pile->SetState(1)) return false;           // ready for further
+ 
+    case 1:
+        // evaluates the associated statement block
+        if ( m_Block != NULL && 
+            !m_Block->Execute(pile) )
+        {
+            if (pile->IfContinue(0, m_label)) continue; // if continued, will return to test
+            return pj->BreakReturn(pile, m_label);      // sends the results and releases the stack
+        }
+ 
+        // terminates if there is an error
+        if ( !pile->IsOk() )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        // returns to the test again
+        if (!pile->SetState(0, 0)) return false;
+        continue; 
+    }
+}
+
+void CBotWhile :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+    CBotStack* pile = pj->RestoreStack(this);   // adds an item to the stack
+    if ( pile == NULL ) return;
+
+    switch( pile->GivState() )  
+    {                                           // there are two possible states (depending on recovery)
+    case 0:
+        // evaluates the condition
+        m_Condition->RestoreState(pile, bMain); 
+        return;
+ 
+    case 1:
+        // evaluates the associated statement block
+        if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
+        return;
+    } 
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "repeat"
+
+CBotRepeat::CBotRepeat()
+{
+    m_NbIter =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    name = "CBotRepeat";        // debug
+}
+
+CBotRepeat::~CBotRepeat()
+{
+    delete  m_NbIter;   // frees the condition
+    delete  m_Block;        // frees the instruction block
+}
+
+CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotRepeat* inst = new CBotRepeat();            // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    if ( IsOfType( p, TokenTypVar ) &&
+         IsOfType( p, ID_DOTS ) )
+    {
+        inst->m_label = pp->GivString();        // register the name of label
+    }
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_REPEAT)) return NULL;   // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+
+    if ( IsOfType(p, ID_OPENPAR ) )
+    {
+        CBotToken*  ppp = p;                    // preserves the ^ token (starting position)
+        if ( NULL != (inst->m_NbIter = CBotExpression::Compile( p, pStk )) )
+        {
+            if ( pStk->GivType() < CBotTypLong )
+            {
+                if ( IsOfType(p, ID_CLOSEPAR ) )
+                {
+
+                    IncLvl(inst->m_label);
+                    inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
+                    DecLvl();
+
+                    if ( pStk->IsOk() )
+                    {
+                        // the statement block is ok (it may be empty!
+
+                        return pStack->Return(inst, pStk);  // return an object to the application
+                    }
+                }
+                pStack->SetError(TX_CLOSEPAR, p->GivStart());
+            }
+            pStk->SetStartError(ppp->GivStart());
+            pStk->SetError( TX_BADTYPE, p->GivStart() );
+        }
+        pStack->SetError(TX_ENDOF, p);
+    }
+    pStack->SetError(TX_OPENPAR, p->GivStart());    // missing parenthesis
+
+    delete inst;                                // error, frees up
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// execution of intruction "repeat"
+
+bool CBotRepeat :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this);   // adds an item to the stack
+                                            // or find in case of recovery
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    while( true ) switch( pile->GivState() )    // executes the loop
+    {                                           // there are two possible states (depending on recovery)
+    case 0:
+        // evaluates the number of iterations
+        if ( !m_NbIter->Execute(pile) ) return false; // interrupted here ?
+
+        // the result of the condition is on the stack
+
+        // terminates if an error or if the condition is false
+        int     n;
+        if ( !pile->IsOk() || ( n = pile->GivVal() ) < 1 )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        // puts the number of iterations +1 to the "state"
+
+        if (!pile->SetState(n+1)) return false;         // ready for further
+        continue;                                       // continue as a result
+
+    case 1:
+        // normal end of the loop
+        return pj->Return(pile);                    // sends the results and releases the stack
+ 
+    default:
+        // evaluates the associated statement block
+        if ( m_Block != NULL && 
+            !m_Block->Execute(pile) )
+        {
+            if (pile->IfContinue(pile->GivState()-1, m_label)) continue;    // if continued, will return to test
+            return pj->BreakReturn(pile, m_label);      // sends the results and releases the stack
+        }
+ 
+        // terminates if there is an error
+        if ( !pile->IsOk() )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        // returns to the test again
+        if (!pile->SetState(pile->GivState()-1, 0)) return false;
+        continue; 
+    }
+}
+
+void CBotRepeat :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+    CBotStack* pile = pj->RestoreStack(this);   // adds an item to the stack
+    if ( pile == NULL ) return;
+
+    switch( pile->GivState() )  
+    {                                           // there are two possible states (depending on recovery)
+    case 0:
+        // evaluates the condition
+        m_NbIter->RestoreState(pile, bMain); 
+        return;
+ 
+    case 1:
+        // evaluates the associated statement block
+        if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
+        return;
+    } 
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compile the instruction "do"
+
+CBotDo::CBotDo()
+{
+    m_Condition =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    name = "CBotDo";        // debug
+}
+
+CBotDo::~CBotDo()
+{
+    delete  m_Condition;    // frees the condition
+    delete  m_Block;        // frees the instruction block
+}
+
+CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotDo* inst = new CBotDo();                // creates the object
+
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    if ( IsOfType( p, TokenTypVar ) &&
+         IsOfType( p, ID_DOTS ) )
+    {
+        inst->m_label = pp->GivString();        // register the name of label
+    }
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_DO)) return NULL;       // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+
+
+    // looking for a statement block after the do
+    IncLvl(inst->m_label);
+    inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
+    DecLvl();
+
+    if ( pStk->IsOk() )
+    {
+        if (IsOfType(p, ID_WHILE))
+        {
+            if ( NULL != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
+            {
+                // the condition exists
+                if (IsOfType(p, ID_SEP))
+                {
+                    return pStack->Return(inst, pStk);  // return an object to the application
+                }
+                pStk->SetError(TX_ENDOF, p->GivStart());
+            }
+        }
+        pStk->SetError(TX_WHILE, p->GivStart());
+    }
+
+    delete inst;                                // error, frees up
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// executes instruction "do"
+
+bool CBotDo :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this);       // adds an item to the stack
+                                                // or find in case of recovery
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    while( true ) switch( pile->GivState() )            // executes the loop
+    {                                                   // there are two possible states (depending on recovery)
+    case 0:
+        // evaluates the associated statement block
+        if ( m_Block != NULL && 
+            !m_Block->Execute(pile) )
+        {
+            if (pile->IfContinue(1, m_label)) continue; // if continued, will return to test
+            return pj->BreakReturn(pile, m_label);      // sends the results and releases the stack
+        }
+ 
+        // terminates if there is an error
+        if ( !pile->IsOk() )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        if (!pile->SetState(1)) return false;           // ready for further
+ 
+    case 1:
+        // evaluates the condition
+        if ( !m_Condition->Execute(pile) ) return false; // interrupted here ?
+
+        // the result of the condition is on the stack
+
+        // terminates if an error or if the condition is false
+        if ( !pile->IsOk() || pile->GivVal() != true )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        // returns to instruction block to start
+        if (!pile->SetState(0, 0)) return false;
+        continue; 
+    }
+}
+
+void CBotDo :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack* pile = pj->RestoreStack(this);           // adds an item to the stack
+    if ( pile == NULL ) return;
+
+    switch( pile->GivState() )
+    {                                                   // there are two possible states (depending on recovery)
+    case 0:
+        // restores the assosiated statement's block
+        if ( m_Block != NULL ) m_Block->RestoreState(pile, bMain);
+        return;
+        
+    case 1:
+        // restores the condition
+        m_Condition->RestoreState(pile, bMain);
+        return;
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "for"
+
+CBotFor::CBotFor()
+{
+    m_Init      =
+    m_Test      =
+    m_Incr      =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    name = "CBotFor";       // debug
+}
+
+CBotFor::~CBotFor()
+{
+    delete  m_Init; 
+    delete  m_Test; 
+    delete  m_Incr; 
+    delete  m_Block;        // frees the instruction block
+}
+
+CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotFor*    inst = new CBotFor();           // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    if ( IsOfType( p, TokenTypVar ) &&
+         IsOfType( p, ID_DOTS ) )
+    {
+        inst->m_label = pp->GivString();        // register the name of label
+    }
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_FOR)) return NULL;      // should never happen
+
+    if ( !IsOfType(p, ID_OPENPAR))              // missing parenthesis ?
+    {
+        pStack->SetError(TX_OPENPAR, p->GivStart());
+        return NULL;
+    }
+
+    CBotCStack* pStk = pStack->TokenStack(pp, true);    // un petit bout de pile svp
+
+    // compiles instructions for initialization
+    inst->m_Init = CBotListExpression::Compile( p, pStk );
+    if ( pStk->IsOk() )
+    {
+        if ( !IsOfType(p, ID_SEP))                      // lack the semicolon?
+        {
+            pStack->SetError(TX_OPENPAR, p->GivStart());
+            delete inst;
+            return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+        }
+        inst->m_Test = CBotBoolExpr::Compile( p, pStk );
+        if ( pStk->IsOk() )
+        {
+            if ( !IsOfType(p, ID_SEP))                      // lack the semicolon?
+            {
+                pStack->SetError(TX_OPENPAR, p->GivStart());
+                delete inst;
+                return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+            }
+            inst->m_Incr = CBotListExpression::Compile( p, pStk );
+            if ( pStk->IsOk() )
+            {
+                if ( IsOfType(p, ID_CLOSEPAR))              // missing parenthesis ?
+                {
+                    IncLvl(inst->m_label);
+                    inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
+                    DecLvl();
+                    if ( pStk->IsOk() )
+                        return pStack->Return(inst, pStk);;
+                }
+                pStack->SetError(TX_CLOSEPAR, p->GivStart());
+            }
+        }
+    }
+
+    delete inst;                                // error, frees up
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// execution of instruction "for"
+
+bool CBotFor :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this, true);     // adds an item to the stack (variables locales)
+                                                    // or find in case of recovery
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    while( true ) switch( pile->GivState() )    // executes the loop
+    {                                           // there are four possible states (depending on recovery)
+    case 0:
+        // initialize
+        if ( m_Init != NULL &&
+             !m_Init->Execute(pile) ) return false;     // interrupted here ?
+        if (!pile->SetState(1)) return false;           // ready for further
+ 
+    case 1:
+        // evaluates the condition
+        if ( m_Test != NULL )                           // no strings attached? -> True!
+        {
+            if (!m_Test->Execute(pile) ) return false;  // interrupted here ?
+
+            // the result of the condition is on the stack
+
+            // terminates if an error or if the condition is false
+            if ( !pile->IsOk() || pile->GivVal() != true )
+            {
+                return pj->Return(pile);                // sends the results and releases the stack
+            }
+        }
+
+        // la condition est vrai, passe à la suite
+        if (!pile->SetState(2)) return false;           // ready for further
+    
+    case 2:
+        // evaluates the associated statement block
+        if ( m_Block != NULL && 
+            !m_Block->Execute(pile) )
+        {
+            if (pile->IfContinue(3, m_label)) continue; // if continued, going on to incrementation
+            return pj->BreakReturn(pile, m_label);      // sends the results and releases the stack
+        }
+
+        // terminates if there is an error
+        if ( !pile->IsOk() )
+        {
+            return pj->Return(pile);                    // sends the results and releases the stack
+        }
+
+        if (!pile->SetState(3)) return false;           // ready for further
+
+    case 3:
+        // evalutate the incrementation
+        if ( m_Incr != NULL &&
+            !m_Incr->Execute(pile) ) return false;      // interrupted here ?
+
+        // returns to the test again
+        if (!pile->SetState(1, 0)) return false;            // returns to the test
+        continue; 
+    }
+}
+
+void CBotFor :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack* pile = pj->RestoreStack(this);       // adds an item to the stack (variables locales)
+    if ( pile == NULL ) return;
+
+    switch( pile->GivState() )
+    {                                           // there are four possible states (depending on recovery)
+    case 0:
+        // initialize
+        if ( m_Init != NULL ) m_Init->RestoreState(pile, true);     // interrupted here !
+        return;
+        
+    case 1:
+        if ( m_Init != NULL ) m_Init->RestoreState(pile, false);    // variables definitions
+
+        // evaluates the condition
+        if ( m_Test != NULL ) m_Test->RestoreState(pile, true);     // interrupted here !
+        return;
+
+    case 2:
+        if ( m_Init != NULL ) m_Init->RestoreState(pile, false);    // variable definitions
+
+        // evaluates the associated statement block
+        if ( m_Block != NULL ) m_Block->RestoreState(pile, true);
+        return;
+
+    case 3:
+        if ( m_Init != NULL ) m_Init->RestoreState(pile, false);    // variable definitions
+
+        // evaluate the incrementation
+        if ( m_Incr != NULL ) m_Incr->RestoreState(pile, true);     // interrupted here !
+        return;
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// compiles a list of expressions
+// is used only in "for" statement
+// in incrementing and intitialisation
+
+CBotListExpression::CBotListExpression()
+{
+    m_Expr  = NULL;
+    name = "CBotListExpression";
+}
+
+CBotListExpression::~CBotListExpression()
+{
+    delete  m_Expr;
+}
+
+// seeks a declaration of variable or expression
+
+static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotInstr*  i = CBotInt::Compile( p, pStack, false, true );         // Is this a declaration of an integer?
+    if ( i== NULL ) i = CBotFloat::Compile( p, pStack, false, true );   // or a real number?
+    if ( i== NULL ) i = CBotBoolean::Compile( p, pStack, false, true ); // or a boolean?
+    if ( i== NULL ) i = CBotIString::Compile( p, pStack, false, true ); // ar a string?
+    if ( i== NULL ) i = CBotExpression::Compile( p, pStack );           // compiles an expression
+    return i;
+}
+
+CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotListExpression* inst = new CBotListExpression();
+
+    inst->m_Expr = CompileInstrOrDefVar( p, pStack );           // compile the first expression in a list
+    if (pStack->IsOk())
+    {
+        while ( IsOfType(p, ID_COMMA) )                         // more instructions?
+        {
+            CBotInstr*  i = CompileInstrOrDefVar( p, pStack );      // Is this a declaration of an integer?
+            inst->m_Expr->AddNext(i);                           // added after
+            if ( !pStack->IsOk() )
+            {
+                delete inst;
+                return NULL;                                    // no object, the error is on the stack
+            }
+        }
+        return inst;
+    }
+    delete inst;
+    return NULL;
+}
+
+bool CBotListExpression::Execute(CBotStack* &pj)
+{
+    CBotStack*  pile = pj->AddStack();                          // essential
+    CBotInstr*  p = m_Expr;                                     // the first expression
+
+    int     state = pile->GivState();
+    while (state-->0) p = p->GivNext();                         // returns to the interrupted operation
+
+    if ( p != NULL ) while (true)
+    {
+        if ( !p->Execute(pile) ) return false;
+        p = p->GivNext();
+        if ( p == NULL ) break;
+        if (!pile->IncState()) return false;                    // ready for next
+    }
+    return pj->Return(pile);
+}
+
+void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
+{
+    CBotStack*  pile = pj;
+    int     state = 0x7000;
+    
+    if ( bMain )
+    {
+        pile = pj->RestoreStack();
+        if ( pile == NULL ) return;
+        state = pile->GivState();
+    }
+
+    CBotInstr*  p = m_Expr;                                     // the first expression
+
+    while (p != NULL && state-->0)
+    {
+        p->RestoreState(pile, false);
+        p = p->GivNext();                           // returns to the interrupted operation
+    }
+
+    if ( p != NULL )
+    {
+        p->RestoreState(pile, bMain);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "switch"
+
+CBotSwitch::CBotSwitch()
+{
+    m_Value     =
+    m_Block     = NULL;         // NULL so that delete is not possible further
+    name = "CBotSwitch";        // debug
+}
+
+CBotSwitch::~CBotSwitch()
+{
+    delete  m_Value;        // frees the value
+    delete  m_Block;        // frees the instruction block
+}
+
+
+CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotSwitch* inst = new CBotSwitch();        // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_SWITCH)) return NULL;   // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+
+    if ( IsOfType(p, ID_OPENPAR ) )
+    {
+        if ( NULL != (inst->m_Value = CBotExpression::Compile( p, pStk )) )
+        {
+            if ( pStk->GivType() < CBotTypLong )
+            {
+                if ( IsOfType(p, ID_CLOSEPAR ) )
+                {
+                    if ( IsOfType(p, ID_OPBLK ) )
+                    {
+                        IncLvl();
+
+                        while( !IsOfType( p, ID_CLBLK ) )
+                        {
+                            if ( p->GivType() == ID_CASE || p->GivType() == ID_DEFAULT)
+                            {
+                                CBotCStack* pStk2 = pStk->TokenStack(p);    // un petit bout de pile svp
+
+                                CBotInstr* i = CBotCase::Compile( p, pStk2 );
+                                if (i == NULL)
+                                {
+                                    delete inst; 
+                                    return pStack->Return(NULL, pStk2);
+                                }
+                                delete pStk2;
+                                if ( inst->m_Block == NULL ) inst->m_Block = i;
+                                else inst->m_Block->AddNext(i);
+                                continue;
+                            }
+                            
+                            if ( inst->m_Block == NULL )
+                            {
+                                pStk->SetError(TX_NOCASE, p->GivStart());
+                                delete inst;
+                                return pStack->Return(NULL, pStk);
+                            }
+
+                            CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, true );
+                            if ( !pStk->IsOk() )
+                            {
+                                delete inst;
+                                return pStack->Return(NULL, pStk);
+                            }
+                            inst->m_Block->AddNext(i);
+
+                            if ( p == NULL )
+                            {
+                                pStk->SetError(TX_CLOSEBLK, -1);
+                                delete inst;
+                                return pStack->Return(NULL, pStk);
+                            }
+                        }
+                        DecLvl();
+                            
+                        if ( inst->m_Block == NULL )
+                        {
+                            pStk->SetError(TX_NOCASE, p->GivStart());
+                            delete inst;
+                            return pStack->Return(NULL, pStk);
+                        }
+                        // the statement block is ok
+                        return pStack->Return(inst, pStk);  // return an object to the application
+                    }
+                    pStk->SetError( TX_OPENBLK, p->GivStart() );
+                }
+                pStk->SetError( TX_CLOSEPAR, p->GivStart() );
+            }
+            pStk->SetError( TX_BADTYPE, p->GivStart() );
+        }
+    }
+    pStk->SetError( TX_OPENPAR, p->GivStart());
+
+    delete inst;                                // error, frees up
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// executes instruction "switch"
+
+bool CBotSwitch :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile1 = pj->AddStack(this);      // adds an item to the stack 
+//  if ( pile1 == EOX ) return true;
+
+    CBotInstr*  p = m_Block;                    // first expression
+
+    int     state = pile1->GivState();
+    if (state == 0)
+    {
+        if ( !m_Value->Execute(pile1) ) return false;
+        pile1->SetState(state = -1);
+    }
+
+    if ( pile1->IfStep() ) return false;
+
+    if ( state == -1 )
+    {
+        state = 0;
+        int val = pile1->GivVal();                      // result of the value
+
+        CBotStack* pile2 = pile1->AddStack();
+        while ( p != NULL )                             // search for the corresponding case in a list
+        {
+            state++;
+            if ( p->CompCase( pile2, val ) ) break;     // found the case
+            p = p->GivNext();
+        }
+        pile2->Delete();
+
+        if ( p == NULL ) return pj->Return(pile1);      // completed if nothing
+
+        if ( !pile1->SetState(state) ) return false;
+    }
+
+    p = m_Block;                                        // returns to the beginning
+    while (state-->0) p = p->GivNext();                 // advance in the list
+
+    while( p != NULL )
+    {
+        if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);
+        if ( !pile1->IncState() ) return false;
+        p = p->GivNext();
+    }
+    return pj->Return(pile1);
+}
+
+void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack* pile1 = pj->RestoreStack(this);  // adds an item to the stack 
+    if ( pile1 == NULL ) return;
+
+    CBotInstr*  p = m_Block;                    // first expression
+
+    int     state = pile1->GivState();
+    if (state == 0)
+    {
+        m_Value->RestoreState(pile1, bMain);
+        return;
+    }
+
+    if ( state == -1 )
+    {
+        return;
+    }
+
+//  p = m_Block;                                // returns to the beginning
+    while ( p != NULL && state-- > 0 )
+    {
+        p->RestoreState(pile1, false);
+        p = p->GivNext();                       // advance in the list
+    }
+
+    if( p != NULL )
+    {
+        p->RestoreState(pile1, true);
+        return;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "case"
+// we are bound to the statement block "switch"
+
+CBotCase::CBotCase()
+{
+    m_Value     = NULL;     // NULL so that delete is not possible further
+    name = "CBotCase";      // debug
+}
+
+CBotCase::~CBotCase()
+{
+    delete  m_Value;        // frees the value
+}
+
+
+CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCase*   inst = new CBotCase();          // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return NULL;     // should never happen
+
+    if ( pp->GivType() == ID_CASE )
+    {
+        pp = p;
+        inst->m_Value = CBotExprNum::Compile(p, pStack);
+        if ( inst->m_Value == NULL )
+        {
+            pStack->SetError( TX_BADNUM, pp );
+            delete inst;
+            return NULL;
+        }
+    }
+    if ( !IsOfType( p, ID_DOTS ))
+    {
+        pStack->SetError( TX_MISDOTS, p->GivStart() );
+        delete inst;
+        return NULL;
+    }
+
+    return inst;
+}
+
+// execution of instruction "case"
+
+bool CBotCase::Execute(CBotStack* &pj)
+{
+    return true;                                // the "case" statement does nothing!
+}
+
+void CBotCase::RestoreState(CBotStack* &pj, bool bMain)
+{
+}
+
+// routine to find the entry point of "case"
+// corresponding to the value seen
+
+bool CBotCase::CompCase(CBotStack* &pile, int val)
+{
+    if ( m_Value == NULL ) return true;         // "default" case
+
+    while (!m_Value->Execute(pile));            // puts the value on the correspondent stack (without interruption)
+    return (pile->GivVal() == val);             // compared with the given value
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "break" or "continu"
+
+CBotBreak::CBotBreak()
+{
+    name = "CBotBreak";     // debug
+}
+
+CBotBreak::~CBotBreak()
+{
+}
+
+CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+    int type = p->GivType();
+
+    if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return NULL;   // should never happen
+
+    if ( !ChkLvl(CBotString(), type ) )
+    {
+        pStack->SetError(TX_BREAK, pp);
+        return NULL;                            // no object, the error is on the stack
+    }
+
+    CBotBreak*  inst = new CBotBreak();         // creates the object
+    inst->SetToken(pp);                         // keeps the operation
+
+    pp = p;
+    if ( IsOfType( p, TokenTypVar ) )
+    {
+        inst->m_label = pp->GivString();        // register the name of label
+        if ( !ChkLvl(inst->m_label, type ) )
+        {
+            delete inst;
+            pStack->SetError(TX_NOLABEL, pp);
+            return NULL;                            // no object, the error is on the stack
+        }
+    }
+
+    if (IsOfType(p, ID_SEP))
+    {
+        return  inst;                           // return what it wants
+    }
+    delete inst;
+
+    pStack->SetError(TX_ENDOF, p->GivStart());
+    return NULL;                            // no object, the error is on the stack
+}
+
+// execution of statement "break" or "continu"
+
+bool CBotBreak :: Execute(CBotStack* &pj)
+{
+    CBotStack* pile = pj->AddStack(this);
+//  if ( pile == EOX ) return true;
+
+    if ( pile->IfStep() ) return false;
+
+    pile->SetBreak(m_token.GivType()==ID_BREAK ? 1 : 2, m_label);
+    return pj->Return(pile);
+}
+
+void CBotBreak :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( bMain ) pj->RestoreStack(this);
+}
+
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "try"
+
+CBotTry::CBotTry()
+{
+    m_ListCatch = NULL;
+    m_FinalInst =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    name = "CBotTry";       // debug
+}
+
+CBotTry::~CBotTry()
+{
+    delete  m_ListCatch;    // frees the list
+    delete  m_Block;        // frees the instruction block
+    delete  m_FinalInst;
+}   
+
+CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotTry*    inst = new CBotTry();           // creates the object
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_TRY)) return NULL;      // should never happen
+
+    CBotCStack* pStk = pStack->TokenStack(pp);  // un petit bout de pile svp
+
+    inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk );
+    CBotCatch** pn = &inst->m_ListCatch;
+    
+    while (pStk->IsOk() && p->GivType() == ID_CATCH)
+    {
+        CBotCatch*  i = CBotCatch::Compile(p, pStk);
+        *pn = i;
+        pn = &i->m_next;
+    }
+
+    if (pStk->IsOk() && IsOfType( p, ID_FINALLY) )
+    {
+        inst->m_FinalInst = CBotBlock::CompileBlkOrInst( p, pStk );
+    }
+
+    if (pStk->IsOk())
+    {
+        return pStack->Return(inst, pStk);  // return an object to the application
+    }
+
+    delete inst;                                // error, frees up
+    return pStack->Return(NULL, pStk);          // no object, the error is on the stack
+}
+
+// execution of instruction Try
+// manages the return of exceptions
+// stops (judgements) by suspension
+// and "finally"
+
+bool CBotTry :: Execute(CBotStack* &pj)
+{
+    int     val;
+
+    CBotStack* pile1 = pj->AddStack(this);  // adds an item to the stack
+//  if ( pile1 == EOX ) return true;
+
+    if ( pile1->IfStep() ) return false;
+                                                    // or find in case of recovery
+    CBotStack* pile0 = pj->AddStack2();             // adds an element to the secondary stack
+    CBotStack* pile2 = pile0->AddStack();
+
+    if ( pile1->GivState() == 0 )
+    {
+        if ( m_Block->Execute(pile1) )
+        {
+            if ( m_FinalInst == NULL ) return pj->Return(pile1);
+            pile1->SetState(-2);                                // passes final
+        }
+
+        val = pile1->GivError();
+        if ( val == 0 && CBotStack::m_initimer == 0 )           // mode step?
+            return false;                                       // does not make the catch
+
+        pile1->IncState();
+        pile2->SetState(val);                                   // stores the error number
+        pile1->SetError(0);                                     // for now there is are more errors!
+
+        if ( val == 0 && CBotStack::m_initimer < 0 )            // mode step?
+            return false;                                       // does not make the catch
+    }
+
+    // there was an interruption
+    // see what it returns
+
+    CBotCatch*  pc = m_ListCatch;
+    int state = (short)pile1->GivState();                       // where were we?
+    val = pile2->GivState();                                    // what error?
+    pile0->SetState(1);                                         // marking the GetRunPos
+
+    if ( val >= 0 && state > 0 ) while ( pc != NULL )
+    {
+        if ( --state <= 0 )
+        {
+            // request to the catch block if they feel concerned
+            // demande au bloc catch s'il se sent concerné
+            if ( !pc->TestCatch(pile2, val) ) return false;     // suspend !
+            pile1->IncState();
+        }
+        if ( --state <= 0 )
+        {
+            if ( pile2->GivVal() == true )
+            {
+//              pile0->SetState(1);
+
+                if ( !pc->Execute(pile2) ) return false;        // performs the operation
+                if ( m_FinalInst == NULL )
+                    return pj->Return(pile2);                   // ends the try
+                
+                pile1->SetState(-2);                            // passes final
+                break;
+            }
+            pile1->IncState();
+        }
+        pc = pc->m_next;
+    }
+    if ( m_FinalInst != NULL && 
+         pile1->GivState() > 0 && val != 0 ) pile1->SetState(-1);// if stop then made the final
+
+    if (pile1->GivState() <= -1)
+    {
+//      pile0->SetState(1);
+    
+        if (!m_FinalInst->Execute(pile2) && pile2->IsOk()) return false;
+        if (!pile2->IsOk()) return pj->Return(pile2);           // keep this exception
+        pile2->SetError(pile1->GivState()==-1 ? val : 0);       // gives the initial error
+        return pj->Return(pile2);
+    }
+
+    pile1->SetState(0);                                         // returns to the evaluation
+    pile0->SetState(0);                                         // returns to the evaluation
+    if ( val != 0 && m_ListCatch == NULL && m_FinalInst == NULL )
+                            return pj->Return(pile2);           // ends the try without exception
+
+    pile1->SetError(val);                                       // gives the error
+    return false;                                               // it's not for us
+}
+
+
+void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    int     val;
+    CBotStack* pile1 = pj->RestoreStack(this);  // adds an item to the stack
+    if ( pile1 == NULL ) return;
+                                                    // or find in case of recovery
+    CBotStack* pile0 = pj->AddStack2();             // adds an item to the secondary stack
+    if ( pile0 == NULL ) return;
+
+    CBotStack* pile2 = pile0->RestoreStack();
+    if ( pile2 == NULL ) return;
+
+    m_Block->RestoreState(pile1, bMain);
+    if ( pile0->GivState() == 0 )
+    {
+        return;
+    }
+
+    // there was an interruption
+    // see what it returns
+
+    CBotCatch*  pc = m_ListCatch;
+    int state = pile1->GivState();                              // where were we ?
+    val = pile2->GivState();                                    // what error ?
+
+    if ( val >= 0 && state > 0 ) while ( pc != NULL )
+    {
+        if ( --state <= 0 )
+        {
+            // request to the catch block if they feel concerned
+            // demande au bloc catch s'il se sent concerné
+            pc->RestoreCondState(pile2, bMain);     // suspend !
+            return;
+        }
+        if ( --state <= 0 )
+        {
+            if ( pile2->GivVal() == true )
+            {
+                pc->RestoreState(pile2, bMain);         // execute the operation
+                return;
+            }
+        }
+        pc = pc->m_next;
+    }
+
+    if (pile1->GivState() <= -1)
+    {
+        m_FinalInst->RestoreState(pile2, bMain);
+        return;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "catch"
+
+CBotCatch::CBotCatch()
+{
+    m_Cond      =
+    m_Block     = NULL;     // NULL so that delete is not possible further
+    m_next      = NULL;
+
+    name = "CBotCatch";     // debug
+}
+
+CBotCatch::~CBotCatch()
+{
+    delete  m_Cond;         // frees the list
+    delete  m_Block;        // frees the instruction block
+    delete  m_next;         // and subsequent
+}
+
+CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    CBotCatch*  inst = new CBotCatch();         // creates the object
+    pStack->SetStartError(p->GivStart());
+
+    inst->SetToken(p);
+    if (!IsOfType(p, ID_CATCH)) return NULL;    // should never happen
+
+    if (IsOfType(p, ID_OPENPAR))
+    {
+        inst->m_Cond = CBotExpression::Compile(p, pStack);
+        if (( pStack->GivType() < CBotTypLong ||
+              pStack->GivTypResult().Eq(CBotTypBoolean) )&& pStack->IsOk() )
+        {
+            if (IsOfType(p, ID_CLOSEPAR))
+            {
+                inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStack );
+                if ( pStack->IsOk() )
+                    return inst;                // return an object to the application
+            }
+            pStack->SetError(TX_CLOSEPAR, p->GivStart());
+        }
+        pStack->SetError(TX_BADTYPE, p->GivStart());
+    }
+    pStack->SetError(TX_OPENPAR, p->GivStart());
+    delete inst;                                // error, frees up
+    return NULL;                                // no object, the error is on the stack
+}
+
+// execution of "catch"
+
+bool CBotCatch :: Execute(CBotStack* &pj)
+{
+    if ( m_Block == NULL ) return true;
+    return m_Block->Execute(pj);                // executes the associated block
+}
+
+void CBotCatch :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( bMain && m_Block != NULL ) m_Block->RestoreState(pj, bMain);
+}
+
+void CBotCatch :: RestoreCondState(CBotStack* &pj, bool bMain)
+{
+    m_Cond->RestoreState(pj, bMain);
+}
+
+// routine to see if the catch is to do or not
+
+bool CBotCatch :: TestCatch(CBotStack* &pile, int val)
+{
+    if ( !m_Cond->Execute(pile) ) return false;
+
+    if ( val > 0 || pile->GivType() != CBotTypBoolean )
+    {
+        CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
+        var->SetValInt( pile->GivVal() == val );
+        pile->SetVar(var);                          // calls on the stack
+    }
+    
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////
+// compiles instruction "throw"
+
+CBotThrow::CBotThrow()
+{
+    m_Value     = NULL;     // NULL so that delete is not possible further
+
+    name = "CBotThrow";     // debug
+}
+
+CBotThrow::~CBotThrow()
+{
+    delete  m_Value;
+}
+
+CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+    pStack->SetStartError(p->GivStart());
+
+    CBotThrow*  inst = new CBotThrow();         // creates the object
+    inst->SetToken(p);
+
+    CBotToken*  pp = p;                         // preserves at the ^ token (starting position)
+
+    if (!IsOfType(p, ID_THROW)) return NULL;    // should never happen
+
+    inst->m_Value = CBotExpression::Compile( p, pStack );
+
+    if (pStack->GivType() < CBotTypLong && pStack->IsOk())
+    {
+        return inst;                            // return an object to the application
+    }
+    pStack->SetError(TX_BADTYPE, pp);
+
+    delete inst;                                // error, frees up
+    return NULL;                                // no object, the error is on the stack
+}
+
+// execution of instruction "throw"
+
+bool CBotThrow :: Execute(CBotStack* &pj)
+{
+    CBotStack*  pile = pj->AddStack(this);
+//  if ( pile == EOX ) return true;
+
+    if ( pile->GivState() == 0 )
+    {
+        if ( !m_Value->Execute(pile) ) return false;
+        pile->IncState();
+    }
+
+    if ( pile->IfStep() ) return false;
+
+    int val = pile->GivVal();
+    if ( val < 0 ) val = TX_BADTHROW;
+    pile->SetError( val, &m_token );
+    return pj->Return( pile );
+}
+
+void CBotThrow :: RestoreState(CBotStack* &pj, bool bMain)
+{
+    if ( !bMain ) return;
+
+    CBotStack*  pile = pj->RestoreStack(this);
+    if ( pile == NULL ) return;
+
+    if ( pile->GivState() == 0 )
+    {
+        m_Value->RestoreState(pile, bMain);
+        return;
+    }
+}
+
+
+
+////////////////////////////////////////////////////////////
+
+
+CBotStartDebugDD::CBotStartDebugDD()
+{
+    name = "CBotStartDebugDD";      // debug
+}
+
+CBotStartDebugDD::~CBotStartDebugDD()
+{
+}
+
+CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack)
+{
+
+    if (!IsOfType(p, ID_DEBUGDD)) return NULL;  // should never happen
+
+    return new CBotStartDebugDD();          // creates the object
+
+}
+
+// execution of instruction "throw"
+
+bool CBotStartDebugDD :: Execute(CBotStack* &pj)
+{
+    CBotProgram* p = pj->GivBotCall();
+    p->m_bDebugDD = true;
+
+    return true;
+}
+
diff --git a/src/CBot/CMakeLists.txt b/src/CBot/CMakeLists.txt
index 9933e9c..409ef3b 100644
--- a/src/CBot/CMakeLists.txt
+++ b/src/CBot/CMakeLists.txt
@@ -10,7 +10,6 @@ CBotToken.cpp
 CBotTwoOpExpr.cpp
 CBotVar.cpp
 CBotWhile.cpp
-CBot.rc
 )
 
 add_library(CBot SHARED ${SOURCES})
diff --git a/src/CBot/ClassFILE.cpp b/src/CBot/ClassFILE.cpp
index e4dd578..f73a1ac 100644
--- a/src/CBot/ClassFILE.cpp
+++ b/src/CBot/ClassFILE.cpp
@@ -1,426 +1,428 @@
-// * 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  http://www.gnu.org/licenses/.// ClassFile.cpp

-//

-// définition des méthodes pour la classe FILE

-

-

-

-// Variables statiques

-

-static CBotClass*	m_pClassFILE;

-static CBotProgram*	m_pFuncFile;

-static int			m_CompteurFileOpen = 0;

-

-

-

-// Prépare un nom de fichier.

-

-void PrepareFilename(CBotString &filename)  //DD!

-{

-	int			pos;

-

-	pos = filename.ReverseFind('\\');

-	if ( pos > 0 )

-	{

-		filename = filename.Mid(pos+1);		// enlève les dossiers

-	}

-

-	pos = filename.ReverseFind('/');

-	if ( pos > 0 )

-	{

-		filename = filename.Mid(pos+1);		// aussi ceux avec /

-	}

-

-	pos = filename.ReverseFind(':');

-	if ( pos > 0 )

-	{

-		filename = filename.Mid(pos+1);		// enlève aussi la lettre d'unité C:

-	}

-

-	filename = CBotString("files\\") + filename;

-}

-

-

-// constructeur de la classe

-// reçois le nom du fichier en paramètre

-

-// exécution

-BOOL rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) 

-{

-	CBotString	mode;

-

-	// accepte sans paramètre

-	if ( pVar == NULL ) return TRUE;

-

-	// qui doit être une chaîne de caractères

-	if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }

-

-	CBotString	filename = pVar->GivValString();

-	PrepareFilename(filename);  //DR

-

-	// il peut y avoir  un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar != NULL )

-	{

-		// récupère le mode

-		mode = pVar->GivValString();

-		if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }

-

-		// pas de 3e paramètre

-		if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; } 

-	}

-

-	// enregistre le nom du fichier

-	pVar = pThis->GivItem("filename");

-	pVar->SetValString(filename);

-

-	if ( ! mode.IsEmpty() )

-	{

-		// ouvre le ficher demandé

-		FILE*	pFile = fopen( filename, mode );

-		if ( pFile == NULL ) { Exception = CBotErrFileOpen; return FALSE; }

-

-		m_CompteurFileOpen ++;

-

-		// enregiste le canal du fichier

-		pVar = pThis->GivItem("handle");

-		pVar->SetValInt((long)pFile);

-	}

-

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)

-{

-	// accepte sans paramètre

-	if ( pVar == NULL ) return CBotTypResult( 0 );

-

-	// qui doit être une chaine

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( CBotErrBadString );

-

-	// il peut y avoir un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar != NULL )

-	{

-		// qui doit être une chaine

-		if ( pVar->GivType() != CBotTypString )

-							return CBotTypResult( CBotErrBadString );

-		// pas de 3e paramètre

-		if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );

-	}

-

-	// le résultat est de type void (constructeur)

-	return CBotTypResult( 0 );

-}

-

-

-// destructeur de la classe

-

-// exécution

-BOOL rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	// pas ouvert ? pas de problème

-	if ( pVar->GivInit() != IS_DEF) return TRUE;

-

-	FILE* pFile= (FILE*)pVar->GivValInt();

-	fclose(pFile);

-	m_CompteurFileOpen --;

-

-	pVar->SetInit(IS_NAN);

-

-	return TRUE;

-}

-

-

-// méthode FILE :: open

-// reçois le mode r/w en paramètre

-

-// exécution

-BOOL rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// il doit y avoir un paramètre

-	if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }

-

-	// qui doit être une chaîne de caractères

-	if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }

-

-	// il peut y avoir  un second paramètre

-	if ( pVar->GivNext() != NULL )

-	{

-		// dans ce cas le premier paramètre est le nom du fichier

-		CBotString	filename = pVar->GivValString();

-		PrepareFilename(filename);  //DR

-

-		// enregistre le nom du fichier

-		CBotVar* pVar2 = pThis->GivItem("filename");

-		pVar2->SetValString(filename);

-

-		// paramètre suivant est le mode

-		pVar = pVar -> GivNext();

-	}

-

-	CBotString	mode = pVar->GivValString();

-	if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return FALSE; }

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return FALSE; }

-

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	// qui doit pas être initialisé

-	if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return FALSE; }

-

-	// reprend le nom du fichier

-	pVar = pThis->GivItem("filename");

-	CBotString	filename = pVar->GivValString();

-

-	PrepareFilename(filename);  //DD! (si le nom a été attribué par h.filename = "...";

-

-	// ouvre le ficher demandé

-	FILE*	pFile = fopen( filename, mode );

-	if ( pFile == NULL )  //DR

-	{

-		pResult->SetValInt(FALSE);  //DR

-		return TRUE;  //DR

-	}

-

-	m_CompteurFileOpen ++;

-

-	// enregiste le canal du fichier

-	pVar = pThis->GivItem("handle");

-	pVar->SetValInt((long)pFile);

-

-	pResult->SetValInt(TRUE);  //DR

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)

-{

-	// il doit y avoir un paramètre

-	if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );

-

-	// qui doit être une chaine

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( CBotErrBadString );

-

-	// il peut y avoir  un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar != NULL )

-	{

-		// qui doit être une chaine

-		if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( CBotErrBadString );

-

-		// pas de 3e paramètre

-		if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );

-	}

-

-	// le résultat est de type bool

-	return CBotTypResult(CBotTypBoolean);  //DR

-}

-

-	

-// méthode FILE :: close

-

-// exécution

-BOOL rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) return CBotErrOverParam;

-

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }

-

-	FILE* pFile= (FILE*)pVar->GivValInt();

-	fclose(pFile);

-	m_CompteurFileOpen --;

-

-	pVar->SetInit(IS_NAN);

-

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );

-

-	// la fonction retourne un résultat "void"

-	return CBotTypResult( 0 );

-}

-

-// méthode FILE :: writeln

-

-// exécution

-BOOL rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// il doit y avoir un paramètre

-	if ( pVar == NULL ) { Exception = CBotErrLowParam; return FALSE; }

-

-	// qui doit être une chaîne de caractères

-	if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return FALSE; }

-

-	CBotString param = pVar->GivValString();

-

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }

-

-	FILE* pFile= (FILE*)pVar->GivValInt();

-	

-	int res = fputs(param+CBotString("\n"), pFile);

-

-	// en cas d'erreur génère une exception

-	if ( res < 0 ) { Exception = CBotErrWrite; return FALSE; }

-

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)

-{

-	// il doit y avoir un paramètre

-	if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );

-

-	// qui doit être une chaîne de caractères

-	if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );

-

-	// pas d'autre paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );

-

-	// la fonction retourne un résultat void

-	return CBotTypResult( 0 );

-}

-

-// méthode FILE :: readln

-

-// exécution

-BOOL rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }

-

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }

-

-	FILE* pFile= (FILE*)pVar->GivValInt();

-

-	char	chaine[2000];

-	int		i;

-	for ( i = 0 ; i < 2000 ; i++ ) chaine[i] = 0;

-

-	fgets(chaine, 1999, pFile);

-

-	for ( i = 0 ; i < 2000 ; i++ ) if (chaine[i] == '\n') chaine[i] = 0;

-

-	// en cas d'erreur génère une exception

-	if ( ferror(pFile) ) { Exception = CBotErrRead; return FALSE; }

-

-	pResult->SetValString( chaine );

-

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );

-

-	// la fonction retourne un résultat "string"

-	return CBotTypResult( CBotTypString );

-}

-// méthode FILE :: readln

-

-

-// exécution

-BOOL rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) { Exception = CBotErrOverParam; return FALSE; }

-

-	// récupère l'élément "handle"

-	pVar = pThis->GivItem("handle");

-

-	if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return FALSE; }

-

-	FILE* pFile= (FILE*)pVar->GivValInt();

-

-	pResult->SetValInt( feof( pFile ) );

-

-	return TRUE;

-}

-

-// compilation

-CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar)

-{

-	// il ne doit pas y avoir de paramètre

-	if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );

-

-	// la fonction retourne un résultat booleen

-	return CBotTypResult( CBotTypBoolean );

-}

-

-

-

-

-

-void InitClassFILE()

-{

-// crée une classe pour la gestion des fichiers

-// l'utilisation en est la suivante:

-// file canal( "NomFichier.txt" )

-// canal.open( "r" );	// ouvre en lecture

-// s = canal.readln( ); // lit une ligne

-// canal.close();		// referme le fichier

-

-	// crée la classe FILE

-	m_pClassFILE	= new CBotClass("file", NULL);

-	// ajoute le composant ".filename"

-	m_pClassFILE->AddItem("filename", CBotTypString);

-	// ajoute le composant ".handle"

-	m_pClassFILE->AddItem("handle", CBotTypInt, PR_PRIVATE);

-

-	// défini un constructeur et un destructeur

-	m_pClassFILE->AddFunction("file", rfconstruct, cfconstruct );

-	m_pClassFILE->AddFunction("~file", rfdestruct, NULL );

-

-	// défini les méthodes associées

-	m_pClassFILE->AddFunction("open", rfopen, cfopen );

-	m_pClassFILE->AddFunction("close", rfclose, cfclose );

-	m_pClassFILE->AddFunction("writeln", rfwrite, cfwrite );

-	m_pClassFILE->AddFunction("readln", rfread, cfread );

-	m_pClassFILE->AddFunction("eof", rfeof, cfeof );

-

-	m_pFuncFile = new CBotProgram( );

-	CBotStringArray ListFonctions;

-	m_pFuncFile->Compile( "public file openfile(string name, string mode) {return new file(name, mode);}", ListFonctions);

-	m_pFuncFile->SetIdent(-2);	// identificateur spécial pour RestoreState dans cette fonction

-}

-

+// * 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  http://www.gnu.org/licenses/.
+
+// ClassFile.cpp
+//
+// definition of methods for class FILE
+
+
+
+// Static variables
+
+static CBotClass*   m_pClassFILE;
+static CBotProgram* m_pFuncFile;
+static int          m_CompteurFileOpen = 0;
+
+
+
+// Prepares a file name.
+
+void PrepareFilename(CBotString &filename)  //DD!
+{
+    int         pos;
+
+    pos = filename.ReverseFind('\\');
+    if ( pos > 0 )
+    {
+        filename = filename.Mid(pos+1);     // remove the records (files)??
+    }
+
+    pos = filename.ReverseFind('/');
+    if ( pos > 0 )
+    {
+        filename = filename.Mid(pos+1);     // also those with /
+    }
+
+    pos = filename.ReverseFind(':');
+    if ( pos > 0 )
+    {
+        filename = filename.Mid(pos+1);     // also removes the drive letter C:
+    }
+
+    filename = CBotString("files\\") + filename;
+}
+
+
+// constructor of the class
+// gets the filename as a parameter
+
+// execution
+bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception) 
+{
+    CBotString  mode;
+
+    // accepts no parameters
+    if ( pVar == NULL ) return true;
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
+
+    CBotString  filename = pVar->GivValString();
+    PrepareFilename(filename);  //DR
+
+    // there may be a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar != NULL )
+    {
+        // recovers the mode
+        mode = pVar->GivValString();
+        if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
+
+        // no third parameter, only two or one possible
+        if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
+    }
+
+    // save the file name
+    pVar = pThis->GivItem("filename");
+    pVar->SetValString(filename);
+
+    if ( ! mode.IsEmpty() )
+    {
+        // open the called file
+        FILE*   pFile = fopen( filename, mode );
+        if ( pFile == NULL ) { Exception = CBotErrFileOpen; return false; }
+
+        m_CompteurFileOpen ++;
+
+        // save the handle of file
+        pVar = pThis->GivItem("handle");
+        pVar->SetValInt((long)pFile);
+    }
+
+    return true;
+}
+
+// compilation
+CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
+{
+    // accepts no parameters
+    if ( pVar == NULL ) return CBotTypResult( 0 );
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( CBotErrBadString );
+
+    // there may be a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar != NULL )
+    {
+        // must be a string
+        if ( pVar->GivType() != CBotTypString )
+                            return CBotTypResult( CBotErrBadString );
+        // no third parameter
+        if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
+    }
+
+    // le r�sultat est de type void (constructeur)
+    return CBotTypResult( 0 );
+}
+
+
+// destructor of the class
+
+// execution
+bool rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    // not open? no problem
+    if ( pVar->GivInit() != IS_DEF) return true;
+
+    FILE* pFile= (FILE*)pVar->GivValInt();
+    fclose(pFile);
+    m_CompteurFileOpen --;
+
+    pVar->SetInit(IS_NAN);
+
+    return true;
+}
+
+
+// FILE :: open method
+// get the r / w mode as a parameter
+
+// execution
+bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // there must be a parameter
+    if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
+
+    // there may be a second parameter
+    if ( pVar->GivNext() != NULL )
+    {
+        // in this case the first parameter is the file name
+        CBotString  filename = pVar->GivValString();
+        PrepareFilename(filename);  //DR
+
+        // saves the file name
+        CBotVar* pVar2 = pThis->GivItem("filename");
+        pVar2->SetValString(filename);
+
+        // next parameter is the mode
+        pVar = pVar -> GivNext();
+    }
+
+    CBotString  mode = pVar->GivValString();
+    if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
+
+    // No third parameter
+    if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
+
+    // retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    // which must not be initialized
+    if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return false; }
+
+    // contains filename
+    pVar = pThis->GivItem("filename");
+    CBotString  filename = pVar->GivValString();
+
+    PrepareFilename(filename);  //DD! (if the name was assigned by h.filename = "...";
+
+    // open requsted file
+    FILE*   pFile = fopen( filename, mode );
+    if ( pFile == NULL )  //DR
+    {
+        pResult->SetValInt(false);  //DR
+        return true;  //DR
+    }
+
+    m_CompteurFileOpen ++;
+
+    // saves the handle of file
+    pVar = pThis->GivItem("handle");
+    pVar->SetValInt((long)pFile);
+
+    pResult->SetValInt(true);  //DR
+    return true;
+}
+
+// compilation
+CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
+{
+    // there must be a parameter
+    if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( CBotErrBadString );
+
+    // there may be a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar != NULL )
+    {
+        // must be a string
+        if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( CBotErrBadString );
+
+        // no third parameter
+        if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
+    }
+
+    // the result is of type bool
+    return CBotTypResult(CBotTypBoolean);  //DR
+}
+
+    
+// FILE :: close method
+
+// execution
+bool rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // it should not be any parameter
+    if ( pVar != NULL ) return CBotErrOverParam;
+
+    // retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
+
+    FILE* pFile= (FILE*)pVar->GivValInt();
+    fclose(pFile);
+    m_CompteurFileOpen --;
+
+    pVar->SetInit(IS_NAN);
+
+    return true;
+}
+
+// compilation
+CBotTypResult cfclose (CBotVar* pThis, CBotVar* &pVar)
+{
+    // it should not be any parameter
+    if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
+
+    // function returns a result "void"
+    return CBotTypResult( 0 );
+}
+
+// FILE :: writeln method
+
+// execution
+bool rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // there must be a parameter
+    if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
+
+    CBotString param = pVar->GivValString();
+
+    //retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
+
+    FILE* pFile= (FILE*)pVar->GivValInt();
+    
+    int res = fputs(param+CBotString("\n"), pFile);
+
+    // on error throws an exception
+    if ( res < 0 ) { Exception = CBotErrWrite; return false; }
+
+    return true;
+}
+
+// compilation
+CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
+{
+    // there must be a parameter
+    if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
+
+    // must be a string
+    if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
+
+    // no other parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
+
+    // function returns "void" result
+    return CBotTypResult( 0 );
+}
+
+// FILE :: readln method
+
+// execution
+bool rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // there shouldn't be any parameter
+    if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
+
+    //retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
+
+    FILE* pFile= (FILE*)pVar->GivValInt();
+
+    char    chaine[2000];
+    int     i;
+    for ( i = 0 ; i < 2000 ; i++ ) chaine[i] = 0;
+
+    fgets(chaine, 1999, pFile);
+
+    for ( i = 0 ; i < 2000 ; i++ ) if (chaine[i] == '\n') chaine[i] = 0;
+
+    // on error throws an exception
+    if ( ferror(pFile) ) { Exception = CBotErrRead; return false; }
+
+    pResult->SetValString( chaine );
+
+    return true;
+}
+
+// compilation
+CBotTypResult cfread (CBotVar* pThis, CBotVar* &pVar)
+{
+    // there shouldn't be any parameter
+    if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
+
+    // function return "string" result
+    return CBotTypResult( CBotTypString );
+}
+// FILE :: readln method
+
+
+// execution
+bool rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
+{
+    // there shouldn't be any parameter
+    if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
+
+    // retrieves the element "handle"
+    pVar = pThis->GivItem("handle");
+
+    if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
+
+    FILE* pFile= (FILE*)pVar->GivValInt();
+
+    pResult->SetValInt( feof( pFile ) );
+
+    return true;
+}
+
+// compilation
+CBotTypResult cfeof (CBotVar* pThis, CBotVar* &pVar)
+{
+    // there shouldn't be any parameter
+    if ( pVar != NULL ) return CBotTypResult( CBotErrOverParam );
+
+    // function return boolean result
+    return CBotTypResult( CBotTypBoolean );
+}
+
+
+
+
+
+void InitClassFILE()
+{
+// creates a class for file management
+// the usage is as follows:
+// file canal( "NomFichier.txt" )
+// canal.open( "r" );   // open reading
+// s = canal.readln( ); // reads a line
+// canal.close();       // closes the file
+
+    // create class FILE
+    m_pClassFILE    = new CBotClass("file", NULL);
+    // add the component ".filename"
+    m_pClassFILE->AddItem("filename", CBotTypString);
+    // add the component ".handle"
+    m_pClassFILE->AddItem("handle", CBotTypInt, PR_PRIVATE);
+
+    // define a constructor and destructor
+    m_pClassFILE->AddFunction("file", rfconstruct, cfconstruct );
+    m_pClassFILE->AddFunction("~file", rfdestruct, NULL );
+
+    // defined associated methods
+    m_pClassFILE->AddFunction("open", rfopen, cfopen );
+    m_pClassFILE->AddFunction("close", rfclose, cfclose );
+    m_pClassFILE->AddFunction("writeln", rfwrite, cfwrite );
+    m_pClassFILE->AddFunction("readln", rfread, cfread );
+    m_pClassFILE->AddFunction("eof", rfeof, cfeof );
+
+    m_pFuncFile = new CBotProgram( );
+    CBotStringArray ListFonctions;
+    m_pFuncFile->Compile( "public file openfile(string name, string mode) {return new file(name, mode);}", ListFonctions);
+    m_pFuncFile->SetIdent(-2);  // restoreState as a special identifier for this function
+}
+
diff --git a/src/CBot/StringFunctions.cpp b/src/CBot/StringFunctions.cpp
index 2c3cfc2..39bafca 100644
--- a/src/CBot/StringFunctions.cpp
+++ b/src/CBot/StringFunctions.cpp
@@ -1,434 +1,436 @@
-// * 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  http://www.gnu.org/licenses/.// définition des fonctions sur les chaînes

-

-

-// donne la longueur d'une chaîne

-// exécution

-

-BOOL rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// pas de second paramètre

-	if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// met la longueur sur la pile

-	pResult->SetValInt( s.GivLength() );

-	return TRUE;

-}

-

-// int xxx ( string )

-// compilation

-

-CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADPARAM );

-

-	// pas de second paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// le résultat final est un nombre entier

-	return CBotTypResult( CBotTypInt );

-}

-

-

-// donne la partie gauche d'une chaîne

-// exécution

-

-BOOL rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être un nombre

-	if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }

-

-	// récupère ce nombre

-	int n = pVar->GivValInt();

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }

-

-	// prend la partie intéressante

-	s = s.Left( n );

-

-	// la met sur la pile

-	pResult->SetValString( s );

-	return TRUE;

-}

-

-// string xxx ( string, int )

-// compilation

-

-CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être un nombre

-	if ( pVar->GivType() > CBotTypDouble )

-						return CBotTypResult( TX_BADNUM );

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// le résultat final est une string

-	return CBotTypResult( CBotTypString );

-}

-

-// donne la partie droite d'une chaîne

-// exécution

-

-BOOL rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être un nombre

-	if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }

-

-	// récupère ce nombre

-	int n = pVar->GivValInt();

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }

-

-	// prend la partie intéressante

-	s = s.Right( n );

-

-	// la met sur la pile

-	pResult->SetValString( s );

-	return TRUE;

-}

-

-// donne la partie centrale d'une chaîne

-// exécution

-

-BOOL rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être un nombre

-	if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }

-

-	// récupère ce nombre

-	int n = pVar->GivValInt();

-

-	// 3e paramètre optionnel

-	if ( pVar->GivNext() != NULL )

-	{

-		pVar = pVar->GivNext();

-	

-		// qui doit être un nombre

-		if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return TRUE; }

-	

-		// récupère ce nombre

-		int l = pVar->GivValInt();

-

-		// mais pas de 4e paramètre

-		if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }

-

-		// prend la partie intéressante

-		s = s.Mid( n, l );

-	}

-	else

-	{

-		// prend la partie intéressante

-		s = s.Mid( n );

-	}

-

-	// la met sur la pile

-	pResult->SetValString( s );

-	return TRUE;

-}

-

-// donne la partie centrale d'une chaîne

-// compilation

-

-CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être un nombre

-	if ( pVar->GivType() > CBotTypDouble )

-						return CBotTypResult( TX_BADNUM );

-

-	// 3e paramètre optionnel

-	if ( pVar->GivNext() != NULL )

-	{

-	

-		pVar = pVar->GivNext();

-		// qui doit être un nombre

-		if ( pVar->GivType() > CBotTypDouble )

-							return CBotTypResult( TX_BADNUM );

-

-		// pas de 4e paramètre

-		if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-	}

-

-	// le résultat final est une string

-	return CBotTypResult( CBotTypString );

-}

-

-

-// donne le nombre contenu dans une chaîne

-// exécution

-

-BOOL rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// mais pas de 2e paramètre

-	if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }

-

-	float val = GivNumFloat(s);

-

-	// la met la valeur sur la pile

-	pResult->SetValFloat( val );

-	return TRUE;

-}

-

-// float xxx ( string )

-// compilation

-

-CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// pas de 2e paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// le résultat final est un nombre

-	return CBotTypResult( CBotTypFloat );

-}

-

-

-// trouve une chaine dans une autre

-// exécution

-

-BOOL rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// récupère ce nombre

-	CBotString s2 = pVar->GivValString();

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return TRUE; }

-

-	// met le résultat sur la pile

-	int res = s.Find(s2);

-	pResult->SetValInt( res );

-	if ( res < 0 ) pResult->SetInit( IS_NAN );

-	return TRUE;

-}

-

-// int xxx ( string, string )

-// compilation

-

-CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// il faut un second paramètre

-	pVar = pVar->GivNext();

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// pas de 3e paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// le résultat final est un nombre

-	return CBotTypResult( CBotTypInt );

-}

-

-// donne une chaine en majuscule

-// exécution

-

-BOOL rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// mais pas de 2e paramètre

-	if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }

-

-

-	s.MakeUpper();

-

-	// la met la valeur sur la pile

-	pResult->SetValString( s );

-	return TRUE;

-}

-

-// donne une chaine en minuscules

-// exécution

-

-BOOL rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) { ex = TX_LOWPARAM ; return TRUE; }

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return TRUE; }

-

-	// recupére le contenu de la string

-	CBotString	s = pVar->GivValString();

-

-	// mais pas de 2e paramètre

-	if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return TRUE; }

-

-

-	s.MakeLower();

-

-	// la met la valeur sur la pile

-	pResult->SetValString( s );

-	return TRUE;

-}

-

-// string xxx ( string )

-// compilation

-

-CBotTypResult cStrStr( CBotVar* &pVar, void* pUser )

-{

-	// il faut un paramètre

-	if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );

-

-	// qui doit être une string

-	if ( pVar->GivType() != CBotTypString )

-						return CBotTypResult( TX_BADSTRING );

-

-	// pas de 2e paramètre

-	if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );

-

-	// le résultat final est une string

-	return CBotTypResult( CBotTypString );

-}

-

-

-void InitStringFunctions()

-{

-	CBotProgram::AddFunction("strlen",   rStrLen,   cIntStr );

-	CBotProgram::AddFunction("strleft",  rStrLeft,  cStrStrInt );

-	CBotProgram::AddFunction("strright", rStrRight, cStrStrInt );

-	CBotProgram::AddFunction("strmid",   rStrMid,   cStrStrIntInt );

-

-	CBotProgram::AddFunction("strval",   rStrVal,   cFloatStr );

-	CBotProgram::AddFunction("strfind",  rStrFind,  cIntStrStr );

-

-	CBotProgram::AddFunction("strupper", rStrUpper, cStrStr );

-	CBotProgram::AddFunction("strlower", rStrLower, cStrStr );

-}

+// * 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  http://www.gnu.org/licenses/.
+
+// definition of string functions
+
+
+// gives the length of a chain
+// execution
+
+bool rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // no second parameter
+    if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // puts the length of the stack
+    pResult->SetValInt( s.GivLength() );
+    return true;
+}
+
+// int xxx ( string )
+// compilation
+
+CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADPARAM );
+
+    // no second parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // the end result is an integer
+    return CBotTypResult( CBotTypInt );
+}
+
+
+// gives the left side of a chain
+// execution
+
+bool rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // which must be a number
+    if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
+
+    // retrieves this number
+    int n = pVar->GivValInt();
+
+    // no third parameter
+    if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
+
+    // takes the interesting part
+    s = s.Left( n );
+
+    // puts on the stack
+    pResult->SetValString( s );
+    return true;
+}
+
+// string xxx ( string, int )
+// compilation
+
+CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // which must be a number
+    if ( pVar->GivType() > CBotTypDouble )
+                        return CBotTypResult( TX_BADNUM );
+
+    // no third parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // the end result is a string
+    return CBotTypResult( CBotTypString );
+}
+
+// gives the right of a string
+// execution
+
+bool rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // which must be a number
+    if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
+
+    // retrieves this number
+    int n = pVar->GivValInt();
+
+    // no third parameter
+    if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
+
+    // takes the interesting part
+    s = s.Right( n );
+
+    // puts on the stack
+    pResult->SetValString( s );
+    return true;
+}
+
+// gives the central part of a chain
+// execution
+
+bool rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // which must be a number
+    if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
+
+    // retrieves this number
+    int n = pVar->GivValInt();
+
+    // third parameter optional
+    if ( pVar->GivNext() != NULL )
+    {
+        pVar = pVar->GivNext();
+    
+        // which must be a number
+        if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
+    
+        // retrieves this number
+        int l = pVar->GivValInt();
+
+        // but no fourth parameter
+        if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
+
+        // takes the interesting part
+        s = s.Mid( n, l );
+    }
+    else
+    {
+        // takes the interesting part
+        s = s.Mid( n );
+    }
+
+    // puts on the stack
+    pResult->SetValString( s );
+    return true;
+}
+
+// gives the central part of a chain
+// compilation
+
+CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // which must be a number
+    if ( pVar->GivType() > CBotTypDouble )
+                        return CBotTypResult( TX_BADNUM );
+
+    // third parameter optional
+    if ( pVar->GivNext() != NULL )
+    {
+    
+        pVar = pVar->GivNext();
+        // which must be a number
+        if ( pVar->GivType() > CBotTypDouble )
+                            return CBotTypResult( TX_BADNUM );
+
+        // no fourth parameter
+        if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+    }
+
+    // the end result is a string
+    return CBotTypResult( CBotTypString );
+}
+
+
+// gives the number stored in a string
+// execution
+
+bool rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // but no second parameter
+    if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
+
+    float val = GivNumFloat(s);
+
+    // puts the value on the stack
+    pResult->SetValFloat( val );
+    return true;
+}
+
+// float xxx ( string )
+// compilation
+
+CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // no second parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // the end result is a number
+    return CBotTypResult( CBotTypFloat );
+}
+
+
+// find string in other
+// exécution
+
+bool rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // retrieves this number
+    CBotString s2 = pVar->GivValString();
+
+    // no third parameter
+    if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
+
+    // puts the result on the stack
+    int res = s.Find(s2);
+    pResult->SetValInt( res );
+    if ( res < 0 ) pResult->SetInit( IS_NAN );
+    return true;
+}
+
+// int xxx ( string, string )
+// compilation
+
+CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // it takes a second parameter
+    pVar = pVar->GivNext();
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // no third parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // the end result is a number
+    return CBotTypResult( CBotTypInt );
+}
+
+// gives a string to uppercase
+// exécution
+
+bool rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // but no second parameter
+    if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
+
+
+    s.MakeUpper();
+
+    // puts the value on the stack
+    pResult->SetValString( s );
+    return true;
+}
+
+// gives a string to lowercase
+// exécution
+
+bool rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
+
+    // get the contents of the string
+    CBotString  s = pVar->GivValString();
+
+    // but no second parameter
+    if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
+
+
+    s.MakeLower();
+
+    // puts the value on the stack
+    pResult->SetValString( s );
+    return true;
+}
+
+// string xxx ( string )
+// compilation
+
+CBotTypResult cStrStr( CBotVar* &pVar, void* pUser )
+{
+    // it takes a parameter
+    if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
+
+    // to be a string
+    if ( pVar->GivType() != CBotTypString )
+                        return CBotTypResult( TX_BADSTRING );
+
+    // no second parameter
+    if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
+
+    // the end result is a string
+    return CBotTypResult( CBotTypString );
+}
+
+
+void InitStringFunctions()
+{
+    CBotProgram::AddFunction("strlen",   rStrLen,   cIntStr );
+    CBotProgram::AddFunction("strleft",  rStrLeft,  cStrStrInt );
+    CBotProgram::AddFunction("strright", rStrRight, cStrStrInt );
+    CBotProgram::AddFunction("strmid",   rStrMid,   cStrStrIntInt );
+
+    CBotProgram::AddFunction("strval",   rStrVal,   cFloatStr );
+    CBotProgram::AddFunction("strfind",  rStrFind,  cIntStrStr );
+
+    CBotProgram::AddFunction("strupper", rStrUpper, cStrStr );
+    CBotProgram::AddFunction("strlower", rStrLower, cStrStr );
+}
diff --git a/src/CBot/_Copy.bat b/src/CBot/_Copy.bat
deleted file mode 100644
index 510dc5a..0000000
--- a/src/CBot/_Copy.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-copy debug\cbot.dll "F:\Program Files\Ceebot\cbot.dll" 

-cls
\ No newline at end of file
diff --git a/src/CBot/colobot.ini b/src/CBot/colobot.ini
deleted file mode 100644
index 32163db..0000000
--- a/src/CBot/colobot.ini
+++ /dev/null
@@ -1,49 +0,0 @@
-[Directory]

-scene=scene

-savegame=savegame

-public=program

-user=user

-[Setup]

-TotoMode=1

-Tooltips=1

-InterfaceGlint=1

-NiceMouse=0

-Movies=1

-NiceReset=1

-HimselfDamage=1

-CameraScroll=1

-CameraInvertX=0

-InterfaceEffect=1

-GroundShadow=1

-GroundSpot=1

-ObjectDirty=1

-FogMode=1

-LensMode=1

-SkyMode=1

-PlanetMode=1

-LightMode=1

-UseJoystick=0

-ParticuleDensity=1.00

-ClippingDistance=1.00

-ObjectDetail=2.00

-GadgetQuantity=1.00

-TextureQuality=1

-AudioVolume=20

-MidiVolume=15

-Sound3D=0

-EditIndentMode=1

-EditIndentValue=4

-KeyMap=37+0 39+0 38+0 40+0 16+0 17+0 32+258 96+262 13+257 107+261 109+260 9+259 36+263 27+0 112+0 113+0 110+0 115+0 116+0 117+0 

-[Engine]

-AlphaMode=1

-StateColor=-1

-BlackSrcBlend=0

-BlackDestBlend=0

-WhiteSrcBlend=0

-WhiteDestBlend=0

-DiffuseSrcBlend=0

-DiffuseDestBlend=0

-AlphaSrcBlend=0

-AlphaDestBlend=0

-[Gamer]

-LastName=Player

diff --git a/src/CBot/idees.txt b/src/CBot/idees.txt
index 7153789..3966ee1 100644
--- a/src/CBot/idees.txt
+++ b/src/CBot/idees.txt
@@ -1,39 +1,41 @@
-pour la gestion des instances d'une classe.

 

-l'objet créé actuellement avec CBotVar::Create(nom, pClasse)

-est a conserver tel quel, en dehors des vars sur la pile

+for managing instances of a class.

 

-il faut un autre type de variable pour garder les pointeurs

-CBotTypPtClass par exemple

+the object being created with CBotVar :: Create (name, pClasse)

+    is to keep as is, outside the vars on the stack

 

-L'instance de la classe doit avoir un compteur d'utilisation

-qui est le nombre d'objet de classe CBotTypPtClass qui y réfèrent.

-Le compteur est décrémenté lorsque le pointeur est détruit,

-l'objet supprimé lorsqu'il n'y a plus de pointeurs.

+    we need another type of variable to keep the pointers

+    For example CBotTypPtClass

 

+    The instance of the class must have a usage count

+    which is the number of class object to which they refer CBotTypPtClass.

+    The counter is decremented when the pointer is destroyed,

+    be deleted when there is more pointers.

 

-Dans le cas des robots, Daniel crée une instance de sa classe "Object"

-et peut retourner des pointeurs à cette instance par des routines genre FindRobot()

 

-Object FindRobot(int n) { }

+    In the case of robots, Daniel creates an instance of class "Object"

+    and can return pointers to this proceeding by routines such FindRobot ()

 

-pResult dans ce cas est un pointeur CBotTypPtClass

-lorsqu'il a trouvé le robot concerné, il lui faudra faire

+    Object FindRobot (int n) {}

 

-pResult->SetPointeur(InstanceDeLaClassObject);

+    pResult in this case is a pointer CBotTypPtClass

+    when he found the robot concerned, it must make

 

-cette opération incrémente le compteur des références

+    pResult-> SetPointeur (InstanceDeLaClassObject);

 

---

+    this operation increments the reference

 

-lorsque le robot est détruit, l'instance de la classe Object correspondant

-est détruit également.

-s'il reste des pointeurs à cet objet, et l'on risque la planté

+    -

 

-solution 1:

-	garder non pas le pointeur à l'objet directement, mais

-	un index dans une tables de pointeurs

+    when the robot is destroyed, the instance of the Object class corresponding

+    is also destroyed.

+    if there are pointers to that object, and we planted the risk

+

+    Solution 1:

+    not keep the pointer to the object directly, but

+    an index into a table of pointers

+

+    Solution 2:

+    not destroy the object when there imédiatement pointers

+    but marked as virtually destroyed

 

-solution 2:

-	ne pas détruire l'objet imédiatement lorsqu'il reste des pointeurs

-	mais le marqué comme virtuellement détruit
\ No newline at end of file
diff --git a/src/CBot/old b/src/CBot/old
deleted file mode 100644
index ea18736..0000000
--- a/src/CBot/old
+++ /dev/null
@@ -1,15 +0,0 @@
-// * 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  http://www.gnu.org/licenses/.
\ No newline at end of file
diff --git a/src/CBot/resource.h b/src/CBot/resource.h
index 7e57d32..96a01ba 100644
--- a/src/CBot/resource.h
+++ b/src/CBot/resource.h
@@ -1,180 +1,177 @@
-// * 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  http://www.gnu.org/licenses/.//{{NO_DEPENDENCIES}}

-// Microsoft Developer Studio generated include file.

-// Used by CBot.rc

-//

-#define ID_KEYWORDS                     2000

-#define ID_IF                           2000

-#define ID_ELSE                         2001

-#define ID_WHILE                        2002

-#define ID_DO                           2003

-#define ID_FOR                          2004

-#define ID_BREAK                        2005

-#define ID_CONTINUE                     2006

-#define ID_SWITCH                       2007

-#define ID_CASE                         2008

-#define ID_DEFAULT                      2009

-#define ID_TRY                          2010

-#define ID_THROW                        2011

-#define ID_CATCH                        2012

-#define ID_FINALLY                      2013

-#define ID_TXT_AND                      2014

-#define ID_TXT_OR                       2015

-#define ID_TXT_NOT                      2016

-#define ID_RETURN                       2017

-#define ID_CLASS                        2018

-#define ID_EXTENDS                      2019

-#define ID_SYNCHO                       2020

-#define ID_NEW                          2021

-#define ID_PUBLIC                       2022

-#define ID_EXTERN                       2023

-#define ID_FINAL                        2024

-#define ID_STATIC                       2025

-#define ID_PROTECTED                    2026

-#define ID_PRIVATE                      2027

-#define ID_REPEAT                       2028

-#define ID_DEBUGDD                      2099

-#define ID_INT                          2100

-#define ID_FLOAT                        2101

-#define ID_BOOLEAN                      2102

-#define ID_STRING                       2103

-#define ID_VOID                         2104

-#define ID_BOOL                         2105

-#define ID_TRUE                         2200

-#define ID_FALSE                        2201

-#define ID_NULL                         2202

-#define ID_NAN                          2203

-#define ID_OPENPAR                      2300

-#define ID_CLOSEPAR                     2301

-#define ID_OPBLK                        2302

-#define ID_CLBLK                        2303

-#define ID_SEP                          2304

-#define ID_COMMA                        2305

-#define ID_DOTS                         2306

-#define ID_DOT                          2307

-#define ID_OPBRK                        2308

-#define ID_CLBRK                        2309

-#define ID_DBLDOTS                      2310

-#define ID_LOGIC                        2311

-#define ID_ADD                          2312

-#define ID_SUB                          2313

-#define ID_MUL                          2314

-#define ID_DIV                          2315

-#define ID_ASS                          2316

-#define ID_ASSADD                       2317

-#define ID_ASSSUB                       2318

-#define ID_ASSMUL                       2319

-#define ID_ASSDIV                       2320

-#define ID_ASSOR                        2321

-#define ID_ASSAND                       2322

-#define ID_ASSXOR                       2323

-#define ID_ASSSL                        2324

-#define ID_ASSSR                        2325

-#define ID_ASSASR                       2326

-#define ID_SL                           2327

-#define ID_SR                           2328

-#define ID_ASR                          2329

-#define ID_INC                          2330

-#define ID_DEC                          2331

-#define ID_LO                           2332

-#define ID_HI                           2333

-#define ID_LS                           2334

-#define ID_HS                           2335

-#define ID_EQ                           2336

-#define ID_NE                           2337

-#define ID_AND                          2338

-#define ID_XOR                          2339

-#define ID_OR                           2340

-#define ID_LOG_AND                      2341

-#define ID_LOG_OR                       2342

-#define ID_LOG_NOT                      2343

-#define ID_NOT                          2344

-#define ID_MODULO                       2345

-#define ID_POWER                        2346

-#define ID_ASSMODULO                    2347

-#define TX_UNDEF                        4000

-#define TX_NAN                          4001

-#define TX_OPENPAR                      5000

-#define TX_CLOSEPAR                     5001

-#define TX_NOTBOOL                      5002

-#define TX_UNDEFVAR                     5003

-#define TX_BADLEFT                      5004

-#define TX_ENDOF                        5005

-#define TX_OUTCASE                      5006

-#define TX_NOTERM                       5007

-#define TX_CLOSEBLK                     5008

-#define TX_ELSEWITHOUTIF                5009

-#define TX_OPENBLK                      5010

-#define TX_BADTYPE                      5011

-#define TX_REDEFVAR                     5012

-#define TX_BAD2TYPE                     5013

-#define TX_UNDEFCALL                    5014

-#define TX_MISDOTS                      5015

-#define TX_WHILE                        5016

-#define TX_BREAK                        5017

-#define TX_LABEL                        5018

-#define TX_NOLABEL                      5019

-#define TX_NOCASE                       5020

-#define TX_BADNUM                       5021

-#define TX_VOID                         5022

-#define TX_NOTYP                        5023

-#define TX_NOVAR                        5024

-#define TX_NOFONC                       5025

-#define TX_OVERPARAM                    5026

-#define TX_REDEF                        5027

-#define TX_LOWPARAM                     5028

-#define TX_BADPARAM                     5029

-#define TX_NUMPARAM                     5030

-#define TX_NOITEM                       5031

-#define TX_DOT                          5032

-#define TX_NOCONST                      5033

-#define TX_REDEFCLASS                   5034

-#define TX_CLBRK                        5035

-#define TX_RESERVED                     5036

-#define TX_BADNEW                       5037

-#define TX_OPBRK                        5038

-#define TX_BADSTRING                    5039

-#define TX_BADINDEX                     5040

-#define TX_PRIVATE                      5041

-#define TX_NOPUBLIC                     5042

-#define TX_DIVZERO                      6000

-#define TX_NOTINIT                      6001

-#define TX_BADTHROW                     6002

-#define TX_NORETVAL                     6003

-#define TX_NORUN                        6004

-#define TX_NOCALL                       6005

-#define TX_NOCLASS                      6006

-#define TX_NULLPT                       6007

-#define TX_OPNAN                        6008

-#define TX_OUTARRAY                     6009

-#define TX_STACKOVER                    6010

-#define TX_DELETEDPT                    6011

-#define TX_FILEOPEN                     6012

-#define TX_NOTOPEN                      6013

-#define TX_ERRREAD                      6014

-#define TX_ERRWRITE                     6015

-#define ID_SUPER                        62020

-

-// Next default values for new objects

-// 

-#ifdef APSTUDIO_INVOKED

-#ifndef APSTUDIO_READONLY_SYMBOLS

-#define _APS_NEXT_RESOURCE_VALUE        101

-#define _APS_NEXT_COMMAND_VALUE         40001

-#define _APS_NEXT_CONTROL_VALUE         1000

-#define _APS_NEXT_SYMED_VALUE           101

-#endif

-#endif

+// * 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  http://www.gnu.org/licenses/.
+
+#pragma once
+#ifndef _RESOURCE_H_
+#define _RESOURCE_H_
+
+enum EID
+{
+    ID_IF = 2000,
+    ID_ELSE,
+    ID_WHILE,
+    ID_DO,
+    ID_FOR,
+    ID_BREAK,
+    ID_CONTINUE,
+    ID_SWITCH,
+    ID_CASE,
+    ID_DEFAULT,
+    ID_TRY,
+    ID_THROW,
+    ID_CATCH,
+    ID_FINALLY,
+    ID_TXT_AND,
+    ID_TXT_OR,
+    ID_TXT_NOT,
+    ID_RETURN,
+    ID_CLASS,
+    ID_EXTENDS,
+    ID_SYNCHO,
+    ID_NEW,
+    ID_PUBLIC,
+    ID_EXTERN,
+    ID_FINAL,
+    ID_STATIC,
+    ID_PROTECTED,
+    ID_PRIVATE,
+    ID_REPEAT,
+    ID_DEBUGDD,
+    ID_INT,
+    ID_FLOAT,
+    ID_BOOLEAN,
+    ID_STRING,
+    ID_VOID,
+    ID_BOOL,
+
+    ID_TRUE = 2200,
+    ID_FALSE,
+    ID_NULL,
+    ID_NAN,
+
+    ID_OPENPAR = 2300,
+    ID_CLOSEPAR,
+    ID_OPBLK,
+    ID_CLBLK,
+    ID_SEP,
+    ID_COMMA,
+    ID_DOTS,
+    ID_DOT,
+    ID_OPBRK,
+    ID_CLBRK,
+    ID_DBLDOTS,
+    ID_LOGIC,
+    ID_ADD,
+    ID_SUB,
+    ID_MUL,
+    ID_DIV,
+    ID_ASS,
+    ID_ASSADD,
+    ID_ASSSUB,
+    ID_ASSMUL,
+    ID_ASSDIV,
+    ID_ASSOR,
+    ID_ASSAND,
+    ID_ASSXOR,
+    ID_ASSSL,
+    ID_ASSSR,
+    ID_ASSASR,
+    ID_SL,
+    ID_SR,
+    ID_ASR,
+    ID_INC,
+    ID_DEC,
+    ID_LO,
+    ID_HI,
+    ID_LS,
+    ID_HS,
+    ID_EQ,
+    ID_NE,
+    ID_AND,
+    ID_XOR,
+    ID_OR,
+    ID_LOG_AND,
+    ID_LOG_OR,
+    ID_LOG_NOT,
+    ID_NOT,
+    ID_MODULO,
+    ID_POWER,
+    ID_ASSMODULO,
+    TX_UNDEF = 4000,
+    TX_NAN,
+    ID_SUPER = 6000
+};
+#define TX_OPENPAR                      5000
+#define TX_CLOSEPAR                     5001
+#define TX_NOTBOOL                      5002
+#define TX_UNDEFVAR                     5003
+#define TX_BADLEFT                      5004
+#define TX_ENDOF                        5005
+#define TX_OUTCASE                      5006
+#define TX_NOTERM                       5007
+#define TX_CLOSEBLK                     5008
+#define TX_ELSEWITHOUTIF                5009
+#define TX_OPENBLK                      5010
+#define TX_BADTYPE                      5011
+#define TX_REDEFVAR                     5012
+#define TX_BAD2TYPE                     5013
+#define TX_UNDEFCALL                    5014
+#define TX_MISDOTS                      5015
+#define TX_WHILE                        5016
+#define TX_BREAK                        5017
+#define TX_LABEL                        5018
+#define TX_NOLABEL                      5019
+#define TX_NOCASE                       5020
+#define TX_BADNUM                       5021
+#define TX_VOID                         5022
+#define TX_NOTYP                        5023
+#define TX_NOVAR                        5024
+#define TX_NOFONC                       5025
+#define TX_OVERPARAM                    5026
+#define TX_REDEF                        5027
+#define TX_LOWPARAM                     5028
+#define TX_BADPARAM                     5029
+#define TX_NUMPARAM                     5030
+#define TX_NOITEM                       5031
+#define TX_DOT                          5032
+#define TX_NOCONST                      5033
+#define TX_REDEFCLASS                   5034
+#define TX_CLBRK                        5035
+#define TX_RESERVED                     5036
+#define TX_BADNEW                       5037
+#define TX_OPBRK                        5038
+#define TX_BADSTRING                    5039
+#define TX_BADINDEX                     5040
+#define TX_PRIVATE                      5041
+#define TX_NOPUBLIC                     5042
+#define TX_DIVZERO                      6000
+#define TX_NOTINIT                      6001
+#define TX_BADTHROW                     6002
+#define TX_NORETVAL                     6003
+#define TX_NORUN                        6004
+#define TX_NOCALL                       6005
+#define TX_NOCLASS                      6006
+#define TX_NULLPT                       6007
+#define TX_OPNAN                        6008
+#define TX_OUTARRAY                     6009
+#define TX_STACKOVER                    6010
+#define TX_DELETEDPT                    6011
+#define TX_FILEOPEN                     6012
+#define TX_NOTOPEN                      6013
+#define TX_ERRREAD                      6014
+#define TX_ERRWRITE                     6015
+
+#endif //_RESOURCE_H_
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.cpp b/src/CBot/tests/TestCBot/CBotConsoleDlg.cpp
index 55a271a..55a271a 100644
--- a/src/CBot/TestCBot/CBotConsoleDlg.cpp
+++ b/src/CBot/tests/TestCBot/CBotConsoleDlg.cpp
diff --git a/src/CBot/TestCBot/CBotConsoleDlg.h b/src/CBot/tests/TestCBot/CBotConsoleDlg.h
index f289a4d..f289a4d 100644
--- a/src/CBot/TestCBot/CBotConsoleDlg.h
+++ b/src/CBot/tests/TestCBot/CBotConsoleDlg.h
diff --git a/src/CBot/TestCBot/ChildFrm.cpp b/src/CBot/tests/TestCBot/ChildFrm.cpp
index 4c40f90..4c40f90 100644
--- a/src/CBot/TestCBot/ChildFrm.cpp
+++ b/src/CBot/tests/TestCBot/ChildFrm.cpp
diff --git a/src/CBot/TestCBot/ChildFrm.h b/src/CBot/tests/TestCBot/ChildFrm.h
index 2ad57b6..2ad57b6 100644
--- a/src/CBot/TestCBot/ChildFrm.h
+++ b/src/CBot/tests/TestCBot/ChildFrm.h
diff --git a/src/CBot/TestCBot/MainFrm.cpp b/src/CBot/tests/TestCBot/MainFrm.cpp
index 6669350..6669350 100644
--- a/src/CBot/TestCBot/MainFrm.cpp
+++ b/src/CBot/tests/TestCBot/MainFrm.cpp
diff --git a/src/CBot/TestCBot/MainFrm.h b/src/CBot/tests/TestCBot/MainFrm.h
index a1d34f4..a1d34f4 100644
--- a/src/CBot/TestCBot/MainFrm.h
+++ b/src/CBot/tests/TestCBot/MainFrm.h
diff --git a/src/CBot/TestCBot/PerformDlg.cpp b/src/CBot/tests/TestCBot/PerformDlg.cpp
index 8abbb4b..8abbb4b 100644
--- a/src/CBot/TestCBot/PerformDlg.cpp
+++ b/src/CBot/tests/TestCBot/PerformDlg.cpp
diff --git a/src/CBot/TestCBot/PerformDlg.h b/src/CBot/tests/TestCBot/PerformDlg.h
index 29d567f..29d567f 100644
--- a/src/CBot/TestCBot/PerformDlg.h
+++ b/src/CBot/tests/TestCBot/PerformDlg.h
diff --git a/src/CBot/TestCBot/Routines.cpp b/src/CBot/tests/TestCBot/Routines.cpp
index b37f027..b37f027 100644
--- a/src/CBot/TestCBot/Routines.cpp
+++ b/src/CBot/tests/TestCBot/Routines.cpp
diff --git a/src/CBot/TestCBot/StdAfx.cpp b/src/CBot/tests/TestCBot/StdAfx.cpp
index 7dd0f00..7dd0f00 100644
--- a/src/CBot/TestCBot/StdAfx.cpp
+++ b/src/CBot/tests/TestCBot/StdAfx.cpp
diff --git a/src/CBot/TestCBot/StdAfx.h b/src/CBot/tests/TestCBot/StdAfx.h
index c3659fb..c3659fb 100644
--- a/src/CBot/TestCBot/StdAfx.h
+++ b/src/CBot/tests/TestCBot/StdAfx.h
diff --git a/src/CBot/TestCBot/TestCBot.clw b/src/CBot/tests/TestCBot/TestCBot.clw
index 13f20f4..13f20f4 100644
--- a/src/CBot/TestCBot/TestCBot.clw
+++ b/src/CBot/tests/TestCBot/TestCBot.clw
diff --git a/src/CBot/TestCBot/TestCBot.cpp b/src/CBot/tests/TestCBot/TestCBot.cpp
index a76040a..a76040a 100644
--- a/src/CBot/TestCBot/TestCBot.cpp
+++ b/src/CBot/tests/TestCBot/TestCBot.cpp
diff --git a/src/CBot/TestCBot/TestCBot.dsp b/src/CBot/tests/TestCBot/TestCBot.dsp
index 8ed9b11..8ed9b11 100644
--- a/src/CBot/TestCBot/TestCBot.dsp
+++ b/src/CBot/tests/TestCBot/TestCBot.dsp
diff --git a/src/CBot/TestCBot/TestCBot.h b/src/CBot/tests/TestCBot/TestCBot.h
index b3b15db..c2595b6 100644
--- a/src/CBot/TestCBot/TestCBot.h
+++ b/src/CBot/tests/TestCBot/TestCBot.h
@@ -26,7 +26,7 @@
 	#error include 'stdafx.h' before including this file for PCH

 #endif

 

-#include "resource.h"       // main symbols

+#include "resource.h"       	// main symbols

 //#include "../CbotDll.h"	// librairie CBot

 #include "../Cbot.h"		// complet pour Browse

 

@@ -43,7 +43,7 @@ public:
 	CTestCBotApp();

 

 	CEdit*			m_pConsole;

-	CTestCBotView*	m_LastActive;

+	CTestCBotView*		m_LastActive;

 	CBotClass*		m_pClassPoint;

 	CBotClass*		m_pClassPointIntr;

 

diff --git a/src/CBot/TestCBot/TestCBot.rc b/src/CBot/tests/TestCBot/TestCBot.rc
index 137458c..137458c 100644
--- a/src/CBot/TestCBot/TestCBot.rc
+++ b/src/CBot/tests/TestCBot/TestCBot.rc
diff --git a/src/CBot/TestCBot/TestCBotDoc.cpp b/src/CBot/tests/TestCBot/TestCBotDoc.cpp
index 8880c57..8880c57 100644
--- a/src/CBot/TestCBot/TestCBotDoc.cpp
+++ b/src/CBot/tests/TestCBot/TestCBotDoc.cpp
diff --git a/src/CBot/TestCBot/TestCBotDoc.h b/src/CBot/tests/TestCBot/TestCBotDoc.h
index 548607f..548607f 100644
--- a/src/CBot/TestCBot/TestCBotDoc.h
+++ b/src/CBot/tests/TestCBot/TestCBotDoc.h
diff --git a/src/CBot/TestCBot/TestCBotView.cpp b/src/CBot/tests/TestCBot/TestCBotView.cpp
index bca3c56..bca3c56 100644
--- a/src/CBot/TestCBot/TestCBotView.cpp
+++ b/src/CBot/tests/TestCBot/TestCBotView.cpp
diff --git a/src/CBot/TestCBot/TestCBotView.h b/src/CBot/tests/TestCBot/TestCBotView.h
index 065ee08..065ee08 100644
--- a/src/CBot/TestCBot/TestCBotView.h
+++ b/src/CBot/tests/TestCBot/TestCBotView.h
diff --git a/src/CBot/TestCBot/a§1.txt b/src/CBot/tests/TestCBot/a§1.txt~
index 0c57950..0c57950 100644
--- a/src/CBot/TestCBot/a§1.txt
+++ b/src/CBot/tests/TestCBot/a§1.txt~
diff --git a/src/CBot/TestCBot/res/TestCBot.ico b/src/CBot/tests/TestCBot/res/TestCBot.ico
index 06a649d..06a649d 100644
--- a/src/CBot/TestCBot/res/TestCBot.ico
+++ b/src/CBot/tests/TestCBot/res/TestCBot.ico
diff --git a/src/CBot/TestCBot/res/TestCBot.rc2 b/src/CBot/tests/TestCBot/res/TestCBot.rc2
index b55f0d9..b55f0d9 100644
--- a/src/CBot/TestCBot/res/TestCBot.rc2
+++ b/src/CBot/tests/TestCBot/res/TestCBot.rc2
diff --git a/src/CBot/TestCBot/res/TestCBotDoc.ico b/src/CBot/tests/TestCBot/res/TestCBotDoc.ico
index 3545614..3545614 100644
--- a/src/CBot/TestCBot/res/TestCBotDoc.ico
+++ b/src/CBot/tests/TestCBot/res/TestCBotDoc.ico
diff --git a/src/CBot/TestCBot/res/Toolbar.bmp b/src/CBot/tests/TestCBot/res/Toolbar.bmp
index 04a71af..04a71af 100644
--- a/src/CBot/TestCBot/res/Toolbar.bmp
+++ b/src/CBot/tests/TestCBot/res/Toolbar.bmp
diff --git a/src/CBot/TestCBot/resource.h b/src/CBot/tests/TestCBot/resource.h
index d661201..d661201 100644
--- a/src/CBot/TestCBot/resource.h
+++ b/src/CBot/tests/TestCBot/resource.h
diff --git a/src/CBot/TestCBot/B.txt b/src/CBot/tests/TestCBot/scenarios/B.txt
index 53715f8..53715f8 100644
--- a/src/CBot/TestCBot/B.txt
+++ b/src/CBot/tests/TestCBot/scenarios/B.txt
diff --git a/src/CBot/TestCBot/BUG2.txt b/src/CBot/tests/TestCBot/scenarios/BUG2.txt
index 44de05a..44de05a 100644
--- a/src/CBot/TestCBot/BUG2.txt
+++ b/src/CBot/tests/TestCBot/scenarios/BUG2.txt
diff --git a/src/CBot/TestCBot/Deleted.txt b/src/CBot/tests/TestCBot/scenarios/Deleted.txt
index 469a624..469a624 100644
--- a/src/CBot/TestCBot/Deleted.txt
+++ b/src/CBot/tests/TestCBot/scenarios/Deleted.txt
diff --git a/src/CBot/TestCBot/MaClass.txt b/src/CBot/tests/TestCBot/scenarios/MaClass.txt
index ac472b4..ac472b4 100644
--- a/src/CBot/TestCBot/MaClass.txt
+++ b/src/CBot/tests/TestCBot/scenarios/MaClass.txt
diff --git a/src/CBot/TestCBot/Mc2.txt b/src/CBot/tests/TestCBot/scenarios/Mc2.txt
index 172c259..172c259 100644
--- a/src/CBot/TestCBot/Mc2.txt
+++ b/src/CBot/tests/TestCBot/scenarios/Mc2.txt
diff --git a/src/CBot/TestCBot/Mon fichier.txt b/src/CBot/tests/TestCBot/scenarios/Mon fichier.txt
index 6b35bf8..6b35bf8 100644
--- a/src/CBot/TestCBot/Mon fichier.txt
+++ b/src/CBot/tests/TestCBot/scenarios/Mon fichier.txt
diff --git a/src/CBot/TestCBot/Nop.txt b/src/CBot/tests/TestCBot/scenarios/Nop.txt
index 6a66f6f..6a66f6f 100644
--- a/src/CBot/TestCBot/Nop.txt
+++ b/src/CBot/tests/TestCBot/scenarios/Nop.txt
diff --git a/src/CBot/TestCBot/POS.txt b/src/CBot/tests/TestCBot/scenarios/POS.txt
index 688e4fb..688e4fb 100644
--- a/src/CBot/TestCBot/POS.txt
+++ b/src/CBot/tests/TestCBot/scenarios/POS.txt
diff --git a/src/CBot/TestCBot/T.txt b/src/CBot/tests/TestCBot/scenarios/T.txt
index 50a792b..50a792b 100644
--- a/src/CBot/TestCBot/T.txt
+++ b/src/CBot/tests/TestCBot/scenarios/T.txt
diff --git a/src/CBot/TestCBot/TESTALL.txt b/src/CBot/tests/TestCBot/scenarios/TESTALL.txt
index 82247a0..82247a0 100644
--- a/src/CBot/TestCBot/TESTALL.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TESTALL.txt
diff --git a/src/CBot/TestCBot/TestCB1.txt b/src/CBot/tests/TestCBot/scenarios/TestCB1.txt
index 516db47..516db47 100644
--- a/src/CBot/TestCBot/TestCB1.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestCB1.txt
diff --git a/src/CBot/TestCBot/TestCBot1.txt b/src/CBot/tests/TestCBot/scenarios/TestCBot1.txt
index d27b4f8..d27b4f8 100644
--- a/src/CBot/TestCBot/TestCBot1.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestCBot1.txt
diff --git a/src/CBot/TestCBot/TestCBot3.txt b/src/CBot/tests/TestCBot/scenarios/TestCBot3.txt
index b915f96..b915f96 100644
--- a/src/CBot/TestCBot/TestCBot3.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestCBot3.txt
diff --git a/src/CBot/TestCBot/TestNull.txt b/src/CBot/tests/TestCBot/scenarios/TestNull.txt
index f447245..f447245 100644
--- a/src/CBot/TestCBot/TestNull.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestNull.txt
diff --git a/src/CBot/TestCBot/TestRestoreState.txt b/src/CBot/tests/TestCBot/scenarios/TestRestoreState.txt
index 1e49e37..1e49e37 100644
--- a/src/CBot/TestCBot/TestRestoreState.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestRestoreState.txt
diff --git a/src/CBot/TestCBot/TestStatic.txt b/src/CBot/tests/TestCBot/scenarios/TestStatic.txt
index f501aa5..f501aa5 100644
--- a/src/CBot/TestCBot/TestStatic.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestStatic.txt
diff --git a/src/CBot/TestCBot/TestStr.txt b/src/CBot/tests/TestCBot/scenarios/TestStr.txt
index 683ec1b..683ec1b 100644
--- a/src/CBot/TestCBot/TestStr.txt
+++ b/src/CBot/tests/TestCBot/scenarios/TestStr.txt
diff --git a/src/CBot/TestCBot/Z.txt b/src/CBot/tests/TestCBot/scenarios/Z.txt
index 714119b..714119b 100644
--- a/src/CBot/TestCBot/Z.txt
+++ b/src/CBot/tests/TestCBot/scenarios/Z.txt
diff --git a/src/CBot/TestCBot/až1.txt b/src/CBot/tests/TestCBot/scenarios/a1.txt
index 165bc95..165bc95 100644
--- a/src/CBot/TestCBot/až1.txt
+++ b/src/CBot/tests/TestCBot/scenarios/a1.txt
diff --git a/src/CBot/TestCBot/array.txt b/src/CBot/tests/TestCBot/scenarios/array.txt
index 081b60e..081b60e 100644
--- a/src/CBot/TestCBot/array.txt
+++ b/src/CBot/tests/TestCBot/scenarios/array.txt
diff --git a/src/CBot/tests/TestCBot/scenarios/až1.txt b/src/CBot/tests/TestCBot/scenarios/až1.txt
new file mode 100644
index 0000000..165bc95
--- /dev/null
+++ b/src/CBot/tests/TestCBot/scenarios/až1.txt
@@ -0,0 +1,96 @@
+object radarGuepe(point orig, float dist)
+{
+	int i;
+	object pr, r;
+	float mindist;
+	
+	i = 0;
+	mindist = 1000;
+	while (i<30)
+	{
+		pr = radar(i);
+		if (pr != null)
+		{
+			
+			if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
+			{
+				mindist = distance(orig, pr.position);
+				r = pr;
+			}
+		}
+		i = i+1;
+	}
+	if (mindist < dist) return(r); else return(null);
+}
+
+
+class Guepe
+{
+	
+	point pos;
+	
+	
+	void cherche(point orig, float dist)
+	{
+		object p;
+		point o;
+		
+		p = radarGuepe(orig, dist);
+		while (p == null)
+		{
+			wait(0.1);
+			p = radarGuepe(orig, dist);
+		}
+		
+		pos.x = p.position.x;
+		pos.y = p.position.y;
+		pos.z = p.position.z;
+		
+		//o = p.position;
+		//wait(0.1);
+		
+		//vitessex = (p.position.x - o.x)/0.1;
+		//vitessey = (p.position.y - o.y)/0.1;
+		//vitessez = (p.position.z - o.z)/0.1;
+		
+	}
+	
+	
+	void tire(point orig, float orient)
+	{
+		//float t = 3;          //temps d'anticipation
+		float angle;
+		point cible;
+		
+		cible.x = pos.x;// + t*vitessex;
+		cible.y = pos.y;// + t*vitessey;
+		cible.z = pos.z;// + t*vitessez;
+		
+		if (cible.x == 0) angle = 90; else
+		  angle = atan(cible.y / cible.x);
+		if (cible.x < 0) angle = angle + 180;
+		angle = angle - orient;
+		if (angle > 180) angle = angle - 360;
+		if (angle < -180) angle = angle + 360;
+		turn(angle);
+		
+		angle = atan((cible.z-orig.z) / distance2d(orig, cible));
+		aim(angle);
+		
+		fire(0.1);
+		
+	}
+}
+
+extern void object::Fourmi6()
+{
+	//fps(1000);
+	Guepe guepe = new Guepe();
+	
+	while (true)
+	{
+		guepe.cherche(position, 50);
+		
+		guepe.tire(position, orientation);
+	}
+}
diff --git a/src/CBot/tests/TestCBot/scenarios/a§1.txt b/src/CBot/tests/TestCBot/scenarios/a§1.txt
new file mode 100644
index 0000000..0c57950
--- /dev/null
+++ b/src/CBot/tests/TestCBot/scenarios/a§1.txt
@@ -0,0 +1,96 @@
+object radarGuepe(point orig, float dist)

+{

+	int i;

+	object pr, r;

+	float mindist;

+	

+	i = 0;

+	mindist = 1000;

+	while (i<30)

+	{

+		pr = radar(i);

+		if (pr != null)

+		{

+			

+			if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)

+			{

+				mindist = distance(orig, pr.position);

+				r = pr;

+			}

+		}

+		i = i+1;

+	}

+	if (mindist < dist) return(r); else return(null);

+}

+

+

+class Guepe

+{

+	

+	point pos;

+	

+	

+	void cherche(point orig, float dist)

+	{

+		object p;

+		point o;

+		

+		p = radarGuepe(orig, dist);

+		while (p == null)

+		{

+			wait(0.1);

+			p = radarGuepe(orig, dist);

+		}

+		

+		pos.x = p.position.x;

+		pos.y = p.position.y;

+		pos.z = p.position.z;

+		

+		//o = p.position;

+		//wait(0.1);

+		

+		//vitessex = (p.position.x - o.x)/0.1;

+		//vitessey = (p.position.y - o.y)/0.1;

+		//vitessez = (p.position.z - o.z)/0.1;

+		

+	}

+	

+	

+	void tire(point orig, float orient)

+	{

+		//float t = 3;          //temps d'anticipation

+		float angle;

+		point cible;

+		

+		cible.x = pos.x;// + t*vitessex;

+		cible.y = pos.y;// + t*vitessey;

+		cible.z = pos.z;// + t*vitessez;

+		

+		if (cible.x == 0) angle = 90; else

+		  angle = atan(cible.y / cible.x);

+		if (cible.x < 0) angle = angle + 180;

+		angle = angle - orient;

+		if (angle > 180) angle = angle - 360;

+		if (angle < -180) angle = angle + 360;

+		turn(angle);

+		

+		angle = atan((cible.z-orig.z) / distance2d(orig, cible));

+		aim(angle);

+		

+		fire(0.1);

+		

+	}

+}

+

+extern void object::Fourmi6()

+{

+	//fps(1000);

+	Guepe guepe = new Guepe();

+	

+	while (true)

+	{

+		guepe.cherche(position, 50);

+		

+		guepe.tire(position, orientation);

+	}

+}

diff --git a/src/CBot/TestCBot/bug.txt b/src/CBot/tests/TestCBot/scenarios/bug.txt
index 4ec6eb3..4ec6eb3 100644
--- a/src/CBot/TestCBot/bug.txt
+++ b/src/CBot/tests/TestCBot/scenarios/bug.txt
diff --git a/src/CBot/TestCBot/bugmw.txt b/src/CBot/tests/TestCBot/scenarios/bugmw.txt
index 284ee43..284ee43 100644
--- a/src/CBot/TestCBot/bugmw.txt
+++ b/src/CBot/tests/TestCBot/scenarios/bugmw.txt
diff --git a/src/CBot/TestCBot/ccc.txt b/src/CBot/tests/TestCBot/scenarios/ccc.txt
index dbcd1d5..dbcd1d5 100644
--- a/src/CBot/TestCBot/ccc.txt
+++ b/src/CBot/tests/TestCBot/scenarios/ccc.txt
diff --git a/src/CBot/TestCBot/enum.txt b/src/CBot/tests/TestCBot/scenarios/enum.txt
index a592a7f..a592a7f 100644
--- a/src/CBot/TestCBot/enum.txt
+++ b/src/CBot/tests/TestCBot/scenarios/enum.txt
diff --git a/src/CBot/TestCBot/fibo.txt b/src/CBot/tests/TestCBot/scenarios/fibo.txt
index 88f5357..88f5357 100644
--- a/src/CBot/TestCBot/fibo.txt
+++ b/src/CBot/tests/TestCBot/scenarios/fibo.txt
diff --git a/src/CBot/TestCBot/file.txt b/src/CBot/tests/TestCBot/scenarios/file.txt
index 2a22dd9..2a22dd9 100644
--- a/src/CBot/TestCBot/file.txt
+++ b/src/CBot/tests/TestCBot/scenarios/file.txt
diff --git a/src/CBot/TestCBot/h.txt b/src/CBot/tests/TestCBot/scenarios/h.txt
index c395319..c395319 100644
--- a/src/CBot/TestCBot/h.txt
+++ b/src/CBot/tests/TestCBot/scenarios/h.txt
diff --git a/src/CBot/TestCBot/include.txt b/src/CBot/tests/TestCBot/scenarios/include.txt
index e8f8cc9..e8f8cc9 100644
--- a/src/CBot/TestCBot/include.txt
+++ b/src/CBot/tests/TestCBot/scenarios/include.txt
diff --git a/src/CBot/TestCBot/intrinsic.txt b/src/CBot/tests/TestCBot/scenarios/intrinsic.txt
index f215791..f215791 100644
--- a/src/CBot/TestCBot/intrinsic.txt
+++ b/src/CBot/tests/TestCBot/scenarios/intrinsic.txt
diff --git a/src/CBot/TestCBot/methode1.txt b/src/CBot/tests/TestCBot/scenarios/methode1.txt
index 080bba2..080bba2 100644
--- a/src/CBot/TestCBot/methode1.txt
+++ b/src/CBot/tests/TestCBot/scenarios/methode1.txt
diff --git a/src/CBot/TestCBot/methode2.txt b/src/CBot/tests/TestCBot/scenarios/methode2.txt
index 76ce7f4..76ce7f4 100644
--- a/src/CBot/TestCBot/methode2.txt
+++ b/src/CBot/tests/TestCBot/scenarios/methode2.txt
diff --git a/src/CBot/TestCBot/mp1.txt b/src/CBot/tests/TestCBot/scenarios/mp1.txt
index 599cfc4..599cfc4 100644
--- a/src/CBot/TestCBot/mp1.txt
+++ b/src/CBot/tests/TestCBot/scenarios/mp1.txt
diff --git a/src/CBot/TestCBot/mp2.txt b/src/CBot/tests/TestCBot/scenarios/mp2.txt
index 1c2972c..1c2972c 100644
--- a/src/CBot/TestCBot/mp2.txt
+++ b/src/CBot/tests/TestCBot/scenarios/mp2.txt
diff --git a/src/CBot/TestCBot/mw.txt b/src/CBot/tests/TestCBot/scenarios/mw.txt
index c237670..c237670 100644
--- a/src/CBot/TestCBot/mw.txt
+++ b/src/CBot/tests/TestCBot/scenarios/mw.txt
diff --git a/src/CBot/TestCBot/null.txt b/src/CBot/tests/TestCBot/scenarios/null.txt
index ae76b74..ae76b74 100644
--- a/src/CBot/TestCBot/null.txt
+++ b/src/CBot/tests/TestCBot/scenarios/null.txt
diff --git a/src/CBot/TestCBot/opnew.txt b/src/CBot/tests/TestCBot/scenarios/opnew.txt
index 7d6838c..7d6838c 100644
--- a/src/CBot/TestCBot/opnew.txt
+++ b/src/CBot/tests/TestCBot/scenarios/opnew.txt
diff --git a/src/CBot/TestCBot/plante.txt b/src/CBot/tests/TestCBot/scenarios/plante.txt
index 363461b..363461b 100644
--- a/src/CBot/TestCBot/plante.txt
+++ b/src/CBot/tests/TestCBot/scenarios/plante.txt
diff --git a/src/CBot/TestCBot/pointer.txt b/src/CBot/tests/TestCBot/scenarios/pointer.txt
index 2d4d907..2d4d907 100644
--- a/src/CBot/TestCBot/pointer.txt
+++ b/src/CBot/tests/TestCBot/scenarios/pointer.txt
diff --git a/src/CBot/TestCBot/postinc.txt b/src/CBot/tests/TestCBot/scenarios/postinc.txt
index cdf6ab5..cdf6ab5 100644
--- a/src/CBot/TestCBot/postinc.txt
+++ b/src/CBot/tests/TestCBot/scenarios/postinc.txt
diff --git a/src/CBot/TestCBot/radar.txt b/src/CBot/tests/TestCBot/scenarios/radar.txt
index 09d84a2..09d84a2 100644
--- a/src/CBot/TestCBot/radar.txt
+++ b/src/CBot/tests/TestCBot/scenarios/radar.txt
diff --git a/src/CBot/TestCBot/solution.txt b/src/CBot/tests/TestCBot/scenarios/solution.txt
index f78cf12..f78cf12 100644
--- a/src/CBot/TestCBot/solution.txt
+++ b/src/CBot/tests/TestCBot/scenarios/solution.txt
diff --git a/src/CBot/TestCBot/test.txt b/src/CBot/tests/TestCBot/scenarios/test.txt
index a912415..a912415 100644
--- a/src/CBot/TestCBot/test.txt
+++ b/src/CBot/tests/TestCBot/scenarios/test.txt
diff --git a/src/CBot/TestCBot/test23.txt b/src/CBot/tests/TestCBot/scenarios/test23.txt
index d6e1ddd..d6e1ddd 100644
--- a/src/CBot/TestCBot/test23.txt
+++ b/src/CBot/tests/TestCBot/scenarios/test23.txt
diff --git a/src/CBot/TestCBot/testmw.txt b/src/CBot/tests/TestCBot/scenarios/testmw.txt
index 6570f6d..6570f6d 100644
--- a/src/CBot/TestCBot/testmw.txt
+++ b/src/CBot/tests/TestCBot/scenarios/testmw.txt
diff --git a/src/CBot/TestCBot/this.txt b/src/CBot/tests/TestCBot/scenarios/this.txt
index b8a9e04..b8a9e04 100644
--- a/src/CBot/TestCBot/this.txt
+++ b/src/CBot/tests/TestCBot/scenarios/this.txt
diff --git a/src/CBot/TestCBot/tt.txt b/src/CBot/tests/TestCBot/scenarios/tt.txt
index cd13c9d..cd13c9d 100644
--- a/src/CBot/TestCBot/tt.txt
+++ b/src/CBot/tests/TestCBot/scenarios/tt.txt
diff --git a/src/CBot/TestCBot/tt2.txt b/src/CBot/tests/TestCBot/scenarios/tt2.txt
index ad9dc1d..ad9dc1d 100644
--- a/src/CBot/TestCBot/tt2.txt
+++ b/src/CBot/tests/TestCBot/scenarios/tt2.txt
diff --git a/src/CBot/TestCBot/vide.txt b/src/CBot/tests/TestCBot/scenarios/vide.txt
index e69de29..e69de29 100644
--- a/src/CBot/TestCBot/vide.txt
+++ b/src/CBot/tests/TestCBot/scenarios/vide.txt
diff --git a/src/CBot/TestCBot/zz.txt b/src/CBot/tests/TestCBot/scenarios/zz.txt
index da764ac..da764ac 100644
--- a/src/CBot/TestCBot/zz.txt
+++ b/src/CBot/tests/TestCBot/scenarios/zz.txt
diff --git a/src/CBot/TestCBot/xTestCBot.clw b/src/CBot/tests/TestCBot/xTestCBot.clw
index 5b84c16..5b84c16 100644
--- a/src/CBot/TestCBot/xTestCBot.clw
+++ b/src/CBot/tests/TestCBot/xTestCBot.clw
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.cpp b/src/CBot/tests/old TstCBot/BotConsoleDlg.cpp
index 077f080..077f080 100644
--- a/src/CBot/old TstCBot/BotConsoleDlg.cpp
+++ b/src/CBot/tests/old TstCBot/BotConsoleDlg.cpp
diff --git a/src/CBot/old TstCBot/BotConsoleDlg.h b/src/CBot/tests/old TstCBot/BotConsoleDlg.h
index 9b54ff2..9b54ff2 100644
--- a/src/CBot/old TstCBot/BotConsoleDlg.h
+++ b/src/CBot/tests/old TstCBot/BotConsoleDlg.h
diff --git a/src/CBot/old TstCBot/BotErrorDlg.cpp b/src/CBot/tests/old TstCBot/BotErrorDlg.cpp
index 87d56f0..87d56f0 100644
--- a/src/CBot/old TstCBot/BotErrorDlg.cpp
+++ b/src/CBot/tests/old TstCBot/BotErrorDlg.cpp
diff --git a/src/CBot/old TstCBot/BotErrorDlg.h b/src/CBot/tests/old TstCBot/BotErrorDlg.h
index 522afad..522afad 100644
--- a/src/CBot/old TstCBot/BotErrorDlg.h
+++ b/src/CBot/tests/old TstCBot/BotErrorDlg.h
diff --git a/src/CBot/old TstCBot/CBotTest.txt b/src/CBot/tests/old TstCBot/CBotTest.txt
index ce20e26..ce20e26 100644
--- a/src/CBot/old TstCBot/CBotTest.txt
+++ b/src/CBot/tests/old TstCBot/CBotTest.txt
diff --git a/src/CBot/old TstCBot/CMyThread.cpp b/src/CBot/tests/old TstCBot/CMyThread.cpp
index ca92c77..ca92c77 100644
--- a/src/CBot/old TstCBot/CMyThread.cpp
+++ b/src/CBot/tests/old TstCBot/CMyThread.cpp
diff --git a/src/CBot/old TstCBot/CMyThread.h b/src/CBot/tests/old TstCBot/CMyThread.h
index 1134077..1134077 100644
--- a/src/CBot/old TstCBot/CMyThread.h
+++ b/src/CBot/tests/old TstCBot/CMyThread.h
diff --git a/src/CBot/old TstCBot/MainFrm.cpp b/src/CBot/tests/old TstCBot/MainFrm.cpp
index 6c0962c..6c0962c 100644
--- a/src/CBot/old TstCBot/MainFrm.cpp
+++ b/src/CBot/tests/old TstCBot/MainFrm.cpp
diff --git a/src/CBot/old TstCBot/MainFrm.h b/src/CBot/tests/old TstCBot/MainFrm.h
index 56b9c41..56b9c41 100644
--- a/src/CBot/old TstCBot/MainFrm.h
+++ b/src/CBot/tests/old TstCBot/MainFrm.h
diff --git a/src/CBot/old TstCBot/ReadMe.txt b/src/CBot/tests/old TstCBot/ReadMe.txt
index 67dc05b..67dc05b 100644
--- a/src/CBot/old TstCBot/ReadMe.txt
+++ b/src/CBot/tests/old TstCBot/ReadMe.txt
diff --git a/src/CBot/old TstCBot/Resource.h b/src/CBot/tests/old TstCBot/Resource.h
index 6863fd8..6863fd8 100644
--- a/src/CBot/old TstCBot/Resource.h
+++ b/src/CBot/tests/old TstCBot/Resource.h
diff --git a/src/CBot/old TstCBot/StdAfx.cpp b/src/CBot/tests/old TstCBot/StdAfx.cpp
index ae0ec93..ae0ec93 100644
--- a/src/CBot/old TstCBot/StdAfx.cpp
+++ b/src/CBot/tests/old TstCBot/StdAfx.cpp
diff --git a/src/CBot/old TstCBot/StdAfx.h b/src/CBot/tests/old TstCBot/StdAfx.h
index 7d46ace..7d46ace 100644
--- a/src/CBot/old TstCBot/StdAfx.h
+++ b/src/CBot/tests/old TstCBot/StdAfx.h
diff --git a/src/CBot/old TstCBot/TstCBot.clw b/src/CBot/tests/old TstCBot/TstCBot.clw
index 4c54168..4c54168 100644
--- a/src/CBot/old TstCBot/TstCBot.clw
+++ b/src/CBot/tests/old TstCBot/TstCBot.clw
diff --git a/src/CBot/old TstCBot/TstCBot.cpp b/src/CBot/tests/old TstCBot/TstCBot.cpp
index 8ac4557..8ac4557 100644
--- a/src/CBot/old TstCBot/TstCBot.cpp
+++ b/src/CBot/tests/old TstCBot/TstCBot.cpp
diff --git a/src/CBot/old TstCBot/TstCBot.dsp b/src/CBot/tests/old TstCBot/TstCBot.dsp
index 35e5c0b..35e5c0b 100644
--- a/src/CBot/old TstCBot/TstCBot.dsp
+++ b/src/CBot/tests/old TstCBot/TstCBot.dsp
diff --git a/src/CBot/old TstCBot/TstCBot.h b/src/CBot/tests/old TstCBot/TstCBot.h
index 616db43..616db43 100644
--- a/src/CBot/old TstCBot/TstCBot.h
+++ b/src/CBot/tests/old TstCBot/TstCBot.h
diff --git a/src/CBot/old TstCBot/TstCBot.rc b/src/CBot/tests/old TstCBot/TstCBot.rc
index 9e91c76..9e91c76 100644
--- a/src/CBot/old TstCBot/TstCBot.rc
+++ b/src/CBot/tests/old TstCBot/TstCBot.rc
diff --git a/src/CBot/old TstCBot/TstCBotDoc.cpp b/src/CBot/tests/old TstCBot/TstCBotDoc.cpp
index 7d7e2ef..7d7e2ef 100644
--- a/src/CBot/old TstCBot/TstCBotDoc.cpp
+++ b/src/CBot/tests/old TstCBot/TstCBotDoc.cpp
diff --git a/src/CBot/old TstCBot/TstCBotDoc.h b/src/CBot/tests/old TstCBot/TstCBotDoc.h
index ae1d0f7..ae1d0f7 100644
--- a/src/CBot/old TstCBot/TstCBotDoc.h
+++ b/src/CBot/tests/old TstCBot/TstCBotDoc.h
diff --git a/src/CBot/old TstCBot/TstCBotView.cpp b/src/CBot/tests/old TstCBot/TstCBotView.cpp
index 3ee9094..3ee9094 100644
--- a/src/CBot/old TstCBot/TstCBotView.cpp
+++ b/src/CBot/tests/old TstCBot/TstCBotView.cpp
diff --git a/src/CBot/old TstCBot/TstCBotView.h b/src/CBot/tests/old TstCBot/TstCBotView.h
index d5aede5..d5aede5 100644
--- a/src/CBot/old TstCBot/TstCBotView.h
+++ b/src/CBot/tests/old TstCBot/TstCBotView.h
diff --git a/src/CBot/old TstCBot/res/TstCBot.ico b/src/CBot/tests/old TstCBot/res/TstCBot.ico
index 7eef0bc..7eef0bc 100644
--- a/src/CBot/old TstCBot/res/TstCBot.ico
+++ b/src/CBot/tests/old TstCBot/res/TstCBot.ico
diff --git a/src/CBot/old TstCBot/res/TstCBot.rc2 b/src/CBot/tests/old TstCBot/res/TstCBot.rc2
index 2186272..2186272 100644
--- a/src/CBot/old TstCBot/res/TstCBot.rc2
+++ b/src/CBot/tests/old TstCBot/res/TstCBot.rc2
diff --git a/src/CBot/old TstCBot/res/TstCBotDoc.ico b/src/CBot/tests/old TstCBot/res/TstCBotDoc.ico
index 2a1f1ae..2a1f1ae 100644
--- a/src/CBot/old TstCBot/res/TstCBotDoc.ico
+++ b/src/CBot/tests/old TstCBot/res/TstCBotDoc.ico
diff --git a/src/CBot/old TstCBot/test complet 1.txt b/src/CBot/tests/old TstCBot/test complet 1.txt
index 0fd4fa5..0fd4fa5 100644
--- a/src/CBot/old TstCBot/test complet 1.txt
+++ b/src/CBot/tests/old TstCBot/test complet 1.txt
diff --git a/src/CBot/old TstCBot/x.txt b/src/CBot/tests/old TstCBot/x.txt
index 95856e0..95856e0 100644
--- a/src/CBot/old TstCBot/x.txt
+++ b/src/CBot/tests/old TstCBot/x.txt
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 03bb03c..9bcd288 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,35 +1,63 @@
 # CBot shared library is built separately
-# add_subdirectory(CBot) -- not yet WinAPI-independent
+add_subdirectory(CBot) 
 
 
 # Configure options
 option(DEBUG "Enable debug output" ON)
 
+set(PLATFORM_LIBS "")
+
 if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   set(PLATFORM_WINDOWS 1)
   set(PLATFORM_LINUX   0)
   set(PLATFORM_OTHER   0)
+  # On Windows, GLEW is required
+  if (${USE_GLEW} MATCHES "auto")
+    set(USE_GLEW 1)
+  endif()
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   set(PLATFORM_WINDOWS 0)
   set(PLATFORM_LINUX   1)
   set(PLATFORM_OTHER   0)
+  # On Linux, we should be fine without GLEW
+  if (${USE_GLEW} MATCHES "auto")
+    set(USE_GLEW 0)
+  endif()
+  # for clock_gettime
+  set(PLATFORM_LIBS "-lrt")
 else()
   set(PLATFORM_WINDOWS 0)
   set(PLATFORM_LINUX   0)
   set(PLATFORM_OTHER   1)
+  # Use GLEW to be safe
+  if (${USE_GLEW} MATCHES "auto")
+    set(USE_GLEW 1)
+  endif()
+endif()
+
+set(OPTIONAL_LIBS "")
+set(OPTIONAL_INCLUDE_DIRS "")
+
+if(${USE_GLEW} EQUAL 1)
+  find_package(GLEW REQUIRED)
+  set(OPTIONAL_LIBS ${OPTIONAL_LIBS} ${GLEW_LIBRARY})
+  set(OPTIONAL_INCLUDE_DIRS ${OPTIONAL_INCLUDE_DIRS} ${GLEW_INCLUDE_PATH})
 endif()
 
+
 # Configure file
 configure_file(common/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/common/config.h)
 
 
 # Source files
 # Commented out files are still dependent on DirectX or WinAPI
+
 set(SOURCES
 app/app.cpp
 app/main.cpp
 app/system.cpp
 common/event.cpp
+common/image.cpp
 common/logger.cpp
 common/iman.cpp
 # common/metafile.cpp
@@ -37,23 +65,21 @@ common/iman.cpp
 # common/modfile.cpp
 # common/profile.cpp
 # common/restext.cpp
-graphics/common/camera.cpp
-graphics/common/cloud.cpp
-graphics/common/color.cpp
-graphics/common/device.cpp
-graphics/common/engine.cpp
-graphics/common/light.cpp
-graphics/common/lightning.cpp
-graphics/common/model.cpp
-graphics/common/modfile.cpp
-graphics/common/particle.cpp
-graphics/common/planet.cpp
-graphics/common/pyro.cpp
-graphics/common/terrain.cpp
-graphics/common/text.cpp
-graphics/common/water.cpp
+common/stringutils.cpp
+graphics/core/color.cpp
+# graphics/engine/camera.cpp # new code but depends on other modules
+graphics/engine/cloud.cpp
+graphics/engine/engine.cpp
+graphics/engine/lightman.cpp
+graphics/engine/lightning.cpp
+graphics/engine/modelfile.cpp
+graphics/engine/particle.cpp
+graphics/engine/planet.cpp
+graphics/engine/pyro.cpp
+graphics/engine/terrain.cpp
+graphics/engine/text.cpp
+graphics/engine/water.cpp
 graphics/opengl/gldevice.cpp
-graphics/opengl/glengine.cpp
 # object/auto/auto.cpp
 # object/auto/autobase.cpp
 # object/auto/autoconvert.cpp
@@ -151,10 +177,19 @@ set(LIBS
 ${SDL_LIBRARY}
 ${SDLIMAGE_LIBRARY}
 ${OPENGL_LIBRARY}
-#CBot  -- not yet WinAPI-independent
+${PNG_LIBRARIES}
+${OPTIONAL_LIBS}
+${PLATFORM_LIBS}
+CBot
 )
 
-include_directories(. ${CMAKE_CURRENT_BINARY_DIR})
+include_directories(. ${CMAKE_CURRENT_BINARY_DIR}
+${SDL_INCLUDE_DIR}
+${SDL_IMAGE_INCLUDE_DIR}
+${SDLTTF_INCLUDE_DIR}
+${PNG_INCLUDE_DIRS}
+${OPTIONAL_INCLUDE_DIRS}
+)
 
 link_directories(${CMAKE_CURRENT_SOURCE_DIR}/CBot)
 
diff --git a/src/app/app.cpp b/src/app/app.cpp
index 68131fc..d20232d 100644
--- a/src/app/app.cpp
+++ b/src/app/app.cpp
@@ -20,12 +20,27 @@
 #include "app/app.h"
 
 #include "app/system.h"
+#include "common/logger.h"
 #include "common/iman.h"
+#include "common/image.h"
+#include "graphics/opengl/gldevice.h"
 
 
 #include <SDL/SDL.h>
 #include <SDL/SDL_image.h>
 
+#include <stdio.h>
+
+
+template<> CApplication* CSingleton<CApplication>::mInstance = NULL;
+
+
+//! Interval of timer called to update joystick state
+const int JOYSTICK_TIMER_INTERVAL = 1000/30;
+
+//! Function called by the timer
+Uint32 JoystickTimerCallback(Uint32 interval, void *);
+
 
 /**
  * \struct ApplicationPrivate
@@ -41,57 +56,44 @@ struct ApplicationPrivate
     SDL_Event currentEvent;
     //! Joystick
     SDL_Joystick *joystick;
-    //! Index of joystick device
-    int joystickDevice;
+    //! Id of joystick timer
+    SDL_TimerID joystickTimer;
 
     ApplicationPrivate()
     {
         memset(&currentEvent, 0, sizeof(SDL_Event));
         surface = NULL;
         joystick = NULL;
-        joystickDevice = 0;
+        joystickTimer = 0;
     }
 };
 
 
+
 CApplication::CApplication()
 {
-    m_private = new ApplicationPrivate();
-    m_exitCode = 0;
+    m_private    = new ApplicationPrivate();
+    m_iMan       = new CInstanceManager();
+    m_eventQueue = new CEventQueue(m_iMan);
 
-    m_iMan = new CInstanceManager();
-    m_event = new CEvent(m_iMan);
-
-    m_engine = 0;
-    m_robotMain = 0;
-    m_sound     = 0;
+    m_engine    = NULL;
+    m_device    = NULL;
+    m_robotMain = NULL;
+    m_sound     = NULL;
 
     m_keyState = 0;
-    m_axeKey = Math::Vector(0.0f, 0.0f, 0.0f);
-    m_axeJoy = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_axeKey   = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_axeJoy   = Math::Vector(0.0f, 0.0f, 0.0f);
 
-    m_vidMemTotal  = 0;
-    m_active      = false;
-    m_activateApp = false;
-    m_ready       = false;
-    m_joystick    = false;
-    m_time        = 0.0f;
+    m_exitCode  = 0;
+    m_active    = false;
+    m_debugMode = false;
 
-    for (int i = 0; i < 32; i++)
-    {
-        m_joyButton[i] = false;
-    }
+    m_windowTitle = "COLOBOT";
 
-    m_windowTitle  = "COLOBOT";
+    m_joystickEnabled = false;
 
-    m_appUseZBuffer  = true;
-    m_appUseStereo   = true;
-    m_showStats      = false;
-    m_debugMode      = false;
-    m_audioState     = true;
-    m_audioTrack     = true;
-    m_niceMouse      = false;
-    m_setupMode      = true;
+    m_dataPath = "./data";
 
     ResetKey();
 }
@@ -101,93 +103,163 @@ CApplication::~CApplication()
     delete m_private;
     m_private = NULL;
 
+    delete m_eventQueue;
+    m_eventQueue = NULL;
+
     delete m_iMan;
     m_iMan = NULL;
 }
 
-Error CApplication::ParseArguments(int argc, char *argv[])
+bool CApplication::ParseArguments(int argc, char *argv[])
 {
+    bool waitDataDir = false;
+
     for (int i = 1; i < argc; ++i)
     {
         std::string arg = argv[i];
 
+        if (waitDataDir)
+        {
+            waitDataDir = false;
+            m_dataPath = arg;
+        }
+
         if (arg == "-debug")
         {
-            m_showStats = true;
             SetDebugMode(true);
         }
-        else if (arg == "-audiostate")
+        else if (arg == "-datadir")
         {
-            m_audioState = false;
+            waitDataDir = true;
         }
-        else if (arg == "-audiotrack")
+        else
         {
-            m_audioTrack = false;
+            m_exitCode = 1;
+            return false;
         }
-        // TODO else {} report invalid argument
     }
 
-    return ERR_OK;
+    // Data dir not given?
+    if (waitDataDir)
+        return false;
+
+    return true;
 }
 
 bool CApplication::Create()
 {
-/*
-TODO
-    Full screen by default unless in debug mode
-    if (! m_debugMode)
-        m_deviceConfig.fullScreen = true;
-
-    int full = 0;
-    if (GetProfileInt("Device", "FullScreen", full))
-        m_deviceConfig.fullScreen = full == 1;
-*/
+    // TODO: verify that data directory exists
 
     // Temporarily -- only in windowed mode
     m_deviceConfig.fullScreen = false;
 
-/*
-TODO
-    // Create the 3D engine.
-    m_engine = new CEngine(m_iMan, this);
+    // Create the 3D engine
+    m_engine = new Gfx::CEngine(m_iMan, this);
 
-    // Initialize the app's custom scene stuff
-    if (! m_engine->OneTimeSceneInit())
-    {
-        SystemDialog(SDT_ERROR, "COLOBOT - Error", m_engine->RetError());
-        return false;
-    }
 
-    // Create the sound instance.
+/*    // Create the sound instance.
     m_sound = new CSound(m_iMan);
 
     // Create the robot application.
-    m_robotMain = new CRobotMain(m_iMan);
-*/
+    m_robotMain = new CRobotMain(m_iMan); */
 
 
-    Uint32 initFlags = SDL_INIT_VIDEO;
-    if (m_joystick)
-        initFlags |= SDL_INIT_JOYSTICK;
+
+    /* SDL initialization sequence */
+
+
+    Uint32 initFlags = SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_TIMER;
 
     if (SDL_Init(initFlags) < 0)
     {
-        SystemDialog( SDT_ERROR, "COLOBOT - Error", "SDL initialization error:\n" +  std::string(SDL_GetError()) );
+        SystemDialog( SDT_ERROR, "COLOBOT - Fatal Error",
+                      "SDL initialization error:\n" +
+                      std::string(SDL_GetError()) );
+        m_exitCode = 2;
+        return false;
+    }
+
+    if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) == 0)
+    {
+        SystemDialog( SDT_ERROR, "COLOBOT - Fatal Error",
+                      std::string("SDL_Image initialization error:\n") +
+                      std::string(IMG_GetError()) );
+        m_exitCode = 3;
+        return false;
+    }
+
+    if (! CreateVideoSurface())
+        return false; // dialog is in function
+
+    if (m_private->surface == NULL)
+    {
+        SystemDialog( SDT_ERROR, "COLOBT - Fatal Error",
+                      std::string("SDL error while setting video mode:\n") +
+                      std::string(SDL_GetError()) );
+        m_exitCode = 2;
+        return false;
+    }
+
+    SDL_WM_SetCaption(m_windowTitle.c_str(), m_windowTitle.c_str());
+
+    // Enable translating key codes of key press events to unicode chars
+    SDL_EnableUNICODE(1);
+
+    // Don't generate joystick events
+    SDL_JoystickEventState(SDL_IGNORE);
+
+
+    // For now, enable joystick for testing
+    SetJoystickEnabled(true);
+
+
+    // The video is ready, we can create and initalize the graphics device
+    m_device = new Gfx::CGLDevice(m_deviceConfig);
+    if (! m_device->Create() )
+    {
+        SystemDialog( SDT_ERROR, "COLOBT - Fatal Error",
+                      std::string("Error in CDevice::Create() :\n") +
+                      std::string(m_device->GetError()) );
+        m_exitCode = 1;
         return false;
     }
 
+    m_engine->SetDevice(m_device);
+    if (! m_engine->Create() )
+    {
+        SystemDialog( SDT_ERROR, "COLOBT - Fatal Error",
+                      std::string("Error in CEngine::Create() :\n") +
+                      std::string(m_engine->GetError()) );
+        m_exitCode = 1;
+        return false;
+    }
+
+    if (! m_engine->AfterDeviceSetInit() )
+    {
+        SystemDialog( SDT_ERROR, "COLOBT - Fatal Error",
+                      std::string("Error in CEngine::AfterDeviceSetInit() :\n") +
+                      std::string(m_engine->GetError()) );
+        m_exitCode = 1;
+        return false;
+    }
+
+    return true;
+}
+
+bool CApplication::CreateVideoSurface()
+{
     const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
-    if (! videoInfo)
+    if (videoInfo == NULL)
     {
-        SystemDialog( SDT_ERROR, "COLOBOT - Error", "SDL error while getting video info:\n " + std::string(SDL_GetError()) );
+        SystemDialog( SDT_ERROR, "COLOBOT - Fatal Error",
+                      std::string("SDL error while getting video info:\n ") +
+                      std::string(SDL_GetError()) );
+        m_exitCode = 2;
         return false;
     }
 
     Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
 
-    if (m_deviceConfig.resizeable)
-        videoFlags |= SDL_RESIZABLE;
-
     // Use hardware surface if available
     if (videoInfo->hw_available)
         videoFlags |= SDL_HWSURFACE;
@@ -201,134 +273,320 @@ TODO
     if (m_deviceConfig.fullScreen)
         videoFlags |= SDL_FULLSCREEN;
 
-    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+    if (m_deviceConfig.resizeable)
+        videoFlags |= SDL_RESIZABLE;
 
-    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    // Set OpenGL attributes
 
-    if ((IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG) == 0)
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   m_deviceConfig.redSize);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, m_deviceConfig.greenSize);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  m_deviceConfig.blueSize);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, m_deviceConfig.alphaSize);
+
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, m_deviceConfig.depthSize);
+
+    if (m_deviceConfig.doubleBuf)
+        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    /* If hardware acceleration specifically requested, this will force the hw accel
+       and fail with error if not available */
+    if (m_deviceConfig.hardwareAccel)
+        SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
+
+    m_private->surface = SDL_SetVideoMode(m_deviceConfig.size.w, m_deviceConfig.size.h,
+                                          m_deviceConfig.bpp, videoFlags);
+
+    return true;
+}
+
+void CApplication::Destroy()
+{
+    /*if (m_robotMain != NULL)
     {
-        SystemDialog( SDT_ERROR, "COLOBOT - Error", std::string("SDL_Image initialization error:\n") +
-                                                    std::string(IMG_GetError()) );
-        return false;
+        delete m_robotMain;
+        m_robotMain = NULL;
     }
 
-    m_private->surface = SDL_SetVideoMode(m_deviceConfig.width, m_deviceConfig.height,
-                                          m_deviceConfig.bpp, videoFlags);
+    if (m_sound != NULL)
+    {
+        delete m_sound;
+        m_sound = NULL;
+    }*/
 
-    if (! m_private->surface)
+    if (m_engine != NULL)
     {
-        SystemDialog( SDT_ERROR, "COLOBT - Error", std::string("SDL error while setting video mode:\n") +
-                                                   std::string(SDL_GetError()) );
-        return false;
+        if (m_engine->GetWasInit())
+            m_engine->Destroy();
+
+        delete m_engine;
+        m_engine = NULL;
     }
 
-    SDL_WM_SetCaption(m_windowTitle.c_str(), m_windowTitle.c_str());
+    if (m_device != NULL)
+    {
+        if (m_device->GetWasInit())
+            m_device->Destroy();
 
-    SDL_EnableUNICODE(1);
+        delete m_device;
+        m_device = NULL;
+    }
 
+    if (m_private->joystick != NULL)
+    {
+        SDL_JoystickClose(m_private->joystick);
+        m_private->joystick = NULL;
+    }
 
-/*
-TODO
+    if (m_private->surface != NULL)
+    {
+        SDL_FreeSurface(m_private->surface);
+        m_private->surface = NULL;
+    }
+
+    IMG_Quit();
 
-    InitJoystick();
+    SDL_Quit();
+}
+
+bool CApplication::ChangeVideoConfig(const Gfx::GLDeviceConfig &newConfig)
+{
+    static bool restore = false;
+
+    m_lastDeviceConfig = m_deviceConfig;
+    m_deviceConfig = newConfig;
+
+
+    SDL_FreeSurface(m_private->surface);
 
-    if ( !GetProfileInt("Setup", "Sound3D", b3D) )
+    if (! CreateVideoSurface())
     {
-        b3D = true;
+        // Fatal error, so post the quit event
+        m_eventQueue->AddEvent(Event(EVENT_QUIT));
+        return false;
     }
-    m_pSound->SetDebugMode(m_bDebugMode);
-    m_pSound->Create(m_hWnd, b3D);
-    m_pSound->CacheAll();
-    m_pSound->SetState(m_bAudioState);
-    m_pSound->SetAudioTrack(m_bAudioTrack);
-    m_pSound->SetCDpath(m_CDpath);
 
-    // First execution?
-    if ( !GetProfileInt("Setup", "ObjectDirty", iValue) )
+    if (m_private->surface == NULL)
     {
-        m_pD3DEngine->FirstExecuteAdapt(true);
+        if (! restore)
+        {
+            SystemDialog( SDT_ERROR, "COLOBT - Error",
+                          std::string("SDL error while setting video mode:\n") +
+                          std::string(SDL_GetError()) + std::string("\n") +
+                          std::string("Previous mode will be restored") );
+
+            restore = true;
+            ChangeVideoConfig(m_lastDeviceConfig);
+            return false;
+        }
+        else
+        {
+            restore = false;
+
+            SystemDialog( SDT_ERROR, "COLOBT - Fatal Error",
+                          std::string("SDL error while restoring previous video mode:\n") +
+                          std::string(SDL_GetError()) );
+
+
+            // Fatal error, so post the quit event
+            m_eventQueue->AddEvent(Event(EVENT_QUIT));
+            return false;
+        }
     }
 
-    // Creates the file colobot.ini at the first execution.
-    m_pRobotMain->CreateIni();
+    ( static_cast<Gfx::CGLDevice*>(m_device) )->ConfigChanged(m_deviceConfig);
+
+    m_engine->ResetAfterDeviceChanged();
+
+    return true;
+}
+
+bool CApplication::OpenJoystick()
+{
+    if ( (m_joystick.index < 0) || (m_joystick.index >= SDL_NumJoysticks()) )
+        return false;
+
+    m_private->joystick = SDL_JoystickOpen(m_joystick.index);
+    if (m_private->joystick == NULL)
+        return false;
 
-    m_pRobotMain->ChangePhase(PHASE_WELCOME2);
+    m_joystick.axisCount   = SDL_JoystickNumAxes(m_private->joystick);
+    m_joystick.buttonCount = SDL_JoystickNumButtons(m_private->joystick);
 
-    m_engine->TimeInit();
-*/
+    // Create the vectors with joystick axis & button states to exactly the required size
+    m_joyAxeState = std::vector<int>(m_joystick.axisCount, 0);
+    m_joyButtonState = std::vector<bool>(m_joystick.buttonCount, false);
 
-    // The app is ready to go
-    m_ready = true;
+    // Create a timer for polling joystick state
+    m_private->joystickTimer = SDL_AddTimer(JOYSTICK_TIMER_INTERVAL, JoystickTimerCallback, NULL);
 
     return true;
 }
 
-void CApplication::Destroy()
+void CApplication::CloseJoystick()
+{
+    // Timer will remove itself automatically
+
+    SDL_JoystickClose(m_private->joystick);
+    m_private->joystick = NULL;
+}
+
+bool CApplication::ChangeJoystick(const JoystickDevice &newJoystick)
 {
+    if ( (newJoystick.index < 0) || (newJoystick.index >= SDL_NumJoysticks()) )
+        return false;
+
     if (m_private->joystick != NULL)
+        CloseJoystick();
+
+    return OpenJoystick();
+}
+
+Uint32 JoystickTimerCallback(Uint32 interval, void *)
+{
+    CApplication *app = CApplication::GetInstancePointer();
+    if ((app == NULL) || (! app->GetJoystickEnabled()))
+        return 0; // don't run the timer again
+
+    app->UpdateJoystick();
+
+    return interval; // run for the same interval again
+}
+
+/** Updates the state info in CApplication and on change, creates SDL events and pushes them to SDL event queue.
+    This way, the events get handled properly in the main event loop and besides, SDL_PushEvent() ensures thread-safety. */
+void CApplication::UpdateJoystick()
+{
+    if (! m_joystickEnabled)
+        return;
+
+    SDL_JoystickUpdate();
+
+    for (int axis = 0; axis < static_cast<int>( m_joyAxeState.size() ); ++axis)
     {
-        SDL_JoystickClose(m_private->joystick);
-        m_private->joystick = NULL;
+        int newValue = SDL_JoystickGetAxis(m_private->joystick, axis);
+
+        if (m_joyAxeState[axis] != newValue)
+        {
+            m_joyAxeState[axis] = newValue;
+
+            SDL_Event joyAxisEvent;
+
+            joyAxisEvent.jaxis.type = SDL_JOYAXISMOTION;
+            joyAxisEvent.jaxis.which = 0;
+            joyAxisEvent.jaxis.axis = axis;
+            joyAxisEvent.jaxis.value = newValue;
+
+            SDL_PushEvent(&joyAxisEvent);
+        }
     }
 
-    SDL_FreeSurface(m_private->surface);
-    m_private->surface = NULL;
+    for (int button = 0; button < static_cast<int>( m_joyButtonState.size() ); ++button)
+    {
+        bool newValue = SDL_JoystickGetButton(m_private->joystick, button) == 1;
 
-    IMG_Quit();
+        if (m_joyButtonState[button] != newValue)
+        {
+            m_joyButtonState[button] = newValue;
 
-    SDL_Quit();
+            SDL_Event joyButtonEvent;
+
+            if (newValue)
+            {
+                joyButtonEvent.jbutton.type = SDL_JOYBUTTONDOWN;
+                joyButtonEvent.jbutton.state = SDL_PRESSED;
+            }
+            else
+            {
+                joyButtonEvent.jbutton.type = SDL_JOYBUTTONUP;
+                joyButtonEvent.jbutton.state = SDL_RELEASED;
+            }
+            joyButtonEvent.jbutton.which = 0;
+            joyButtonEvent.jbutton.button = button;
+
+            SDL_PushEvent(&joyButtonEvent);
+        }
+    }
 }
 
 int CApplication::Run()
 {
     m_active = true;
 
-    while (m_private->currentEvent.type != SDL_QUIT)
+    while (true)
     {
-        // Use SDL_PeepEvents() if the app is active, so we can use idle time to
-        // render the scene. Else, use SDL_PollEvent() to avoid eating CPU time.
-        int count = 0;
+        // To be sure no old event remains
+        m_private->currentEvent.type = SDL_NOEVENT;
+
+        // Call SDL_PumpEvents() only once here
+        // (SDL_PeepEvents() doesn't call it)
         if (m_active)
-        {
             SDL_PumpEvents();
-            count = SDL_PeepEvents(&m_private->currentEvent, 1, SDL_GETEVENT, SDL_ALLEVENTS);
-        }
-        else
-        {
-            SDL_PollEvent(&m_private->currentEvent);
-        }
 
-        // If received an event
-        if ((m_active && count > 0) || (!m_active))
+        bool haveEvent = true;
+        while (haveEvent)
         {
-            ParseEvent();
+            haveEvent = false;
+
+            int count = 0;
+            // Use SDL_PeepEvents() if the app is active, so we can use idle time to
+            // render the scene. Else, use SDL_WaitEvent() to avoid eating CPU time.
+            if (m_active)
+                count = SDL_PeepEvents(&m_private->currentEvent, 1, SDL_GETEVENT, SDL_ALLEVENTS);
+            else
+                count = SDL_WaitEvent(&m_private->currentEvent);
+
+            // If received an event
+            if (count > 0)
+            {
+                haveEvent = true;
+
+                Event event = ParseEvent();
+
+                if (event.type == EVENT_QUIT)
+                    goto end; // exit the loop
+
+                if (event.type != EVENT_NULL)
+                {
+                    bool passOn = ProcessEvent(event);
+
+                    if (m_engine != NULL && passOn)
+                        passOn = m_engine->ProcessEvent(event);
+
+                    if (passOn)
+                        m_eventQueue->AddEvent(event);
+                }
+            }
         }
 
-        // Render a frame during idle time (no messages are waiting)
-        if (m_active && m_ready)
+        // Enter game update & frame rendering only if active
+        if (m_active)
         {
             Event event;
-            while (m_event->GetEvent(event))
+            while (m_eventQueue->GetEvent(event))
             {
-                if (event.event == EVENT_QUIT)
-                {
+                if (event.type == EVENT_QUIT)
                     goto end; // exit both loops
+
+                bool passOn = true;
+
+                // Skip system events (they have been processed earlier)
+                if (! event.systemEvent)
+                {
+                    passOn = ProcessEvent(event);
+
+                    if (passOn && m_engine != NULL)
+                        passOn = m_engine->ProcessEvent(event);
                 }
 
-                //m_robotMain->EventProcess(event);
+                /*if (passOn && m_robotMain != NULL)
+                    m_robotMain->ProcessEvent(event); */
             }
 
-            //if ( !RetNiceMouse())
-            //{
-            //  SetMouseType(m_engine->RetMouseType());
-            //}
+            // Update game and render a frame during idle time (no messages are waiting)
+            bool ok = Render();
 
             // If an error occurs, push quit event to the queue
-            if (! Render())
+            if (! ok)
             {
                 SDL_Event quitEvent;
                 memset(&quitEvent, 0, sizeof(SDL_Event));
@@ -339,7 +597,6 @@ int CApplication::Run()
     }
 
 end:
-    //m_sound->StopMusic();
     Destroy();
 
     return m_exitCode;
@@ -350,54 +607,174 @@ int CApplication::GetExitCode()
     return m_exitCode;
 }
 
-void CApplication::ParseEvent()
+//! Translates SDL press state to PressState
+PressState TranslatePressState(unsigned char state)
+{
+    if (state == SDL_PRESSED)
+        return STATE_PRESSED;
+    else
+        return STATE_RELEASED;
+}
+
+/** Conversion of the position of the mouse from window coords to interface coords:
+     - x: 0=left, 1=right
+     - y: 0=down, 1=up */
+Math::Point CApplication::WindowToInterfaceCoords(Math::IntPoint pos)
+{
+    return Math::Point(        static_cast<float>(pos.x) / static_cast<float>(m_deviceConfig.size.w),
+                        1.0f - static_cast<float>(pos.y) / static_cast<float>(m_deviceConfig.size.h)  );
+}
+
+Math::IntPoint CApplication::InterfaceToWindowCoords(Math::Point pos)
+{
+    return Math::IntPoint(static_cast<int>(pos.x * m_deviceConfig.size.w),
+                          static_cast<int>((1.0f - pos.y) * m_deviceConfig.size.h));
+}
+
+/** The SDL event parsed is stored internally.
+    If event is not available or is not understood, returned event is of type EVENT_NULL. */
+Event CApplication::ParseEvent()
 {
-/*  Event event;
+    Event event;
 
-    if (m_private->currentEvent.type == SDL_MOUSEBUTTONDOWN)
+    event.systemEvent = true;
+
+    if (m_private->currentEvent.type == SDL_QUIT)
     {
-        if (m_private->currentEvent.button.button == SDL_BUTTON_LEFT)
-            event.event = EVENT_LBUTTONDOWN;
-        else if (m_private->currentEvent.button.button == SDL_BUTTON_RIGHT)
-            event.event = EVENT_RBUTTONDOWN;
+        event.type = EVENT_QUIT;
     }
-    else if (m_private->currentEvent.type == SDL_MOUSEBUTTONUP)
+    else if ( (m_private->currentEvent.type == SDL_KEYDOWN) ||
+              (m_private->currentEvent.type == SDL_KEYUP) )
     {
-        if (m_private->currentEvent.button.button == SDL_BUTTON_LEFT)
-            event.event = EVENT_LBUTTONUP;
-        else if (m_private->currentEvent.button.button == SDL_BUTTON_RIGHT)
-            event.event = EVENT_RBUTTONUP;
+        if (m_private->currentEvent.type == SDL_KEYDOWN)
+            event.type = EVENT_KEY_DOWN;
+        else
+            event.type = EVENT_KEY_UP;
+
+        event.key.key = m_private->currentEvent.key.keysym.sym;
+        event.key.mod = m_private->currentEvent.key.keysym.mod;
+        event.key.state = TranslatePressState(m_private->currentEvent.key.state);
+        event.key.unicode = m_private->currentEvent.key.keysym.unicode;
     }
-    else if (m_private->currentEvent.type == SDL_MOUSEMOTION)
+    else if ( (m_private->currentEvent.type == SDL_MOUSEBUTTONDOWN) ||
+         (m_private->currentEvent.type == SDL_MOUSEBUTTONUP) )
     {
-        event.event = EVENT_MOUSEMOVE;
+        if (m_private->currentEvent.type == SDL_MOUSEBUTTONDOWN)
+            event.type = EVENT_MOUSE_BUTTON_DOWN;
+        else
+            event.type = EVENT_MOUSE_BUTTON_UP;
+
+        event.mouseButton.button = m_private->currentEvent.button.button;
+        event.mouseButton.state = TranslatePressState(m_private->currentEvent.button.state);
+        event.mouseButton.pos = WindowToInterfaceCoords(Math::IntPoint(m_private->currentEvent.button.x, m_private->currentEvent.button.y));
     }
-    else if (m_private->currentEvent.type == SDL_KEYDOWN)
+    else if (m_private->currentEvent.type == SDL_MOUSEMOTION)
     {
-        event.event = EVENT_KEYDOWN;
+        event.type = EVENT_MOUSE_MOVE;
+
+        event.mouseMove.state = TranslatePressState(m_private->currentEvent.button.state);
+        event.mouseMove.pos = WindowToInterfaceCoords(Math::IntPoint(m_private->currentEvent.button.x, m_private->currentEvent.button.y));
     }
-    else if (m_private->currentEvent.type == SDL_KEYUP)
+    else if (m_private->currentEvent.type == SDL_JOYAXISMOTION)
     {
-        event.event = EVENT_KEYUP;
-    }
+        event.type = EVENT_JOY_AXIS;
 
-    if (m_robotMain != NULL && event.event != EVENT_NULL)
+        event.joyAxis.axis = m_private->currentEvent.jaxis.axis;
+        event.joyAxis.value = m_private->currentEvent.jaxis.value;
+    }
+    else if ( (m_private->currentEvent.type == SDL_JOYBUTTONDOWN) ||
+              (m_private->currentEvent.type == SDL_JOYBUTTONUP) )
     {
-        m_robotMain->EventProcess(event);
+        if (m_private->currentEvent.type == SDL_JOYBUTTONDOWN)
+            event.type = EVENT_JOY_BUTTON_DOWN;
+        else
+            event.type = EVENT_JOY_BUTTON_UP;
+
+        event.joyButton.button = m_private->currentEvent.jbutton.button;
+        event.joyButton.state = TranslatePressState(m_private->currentEvent.jbutton.state);
     }
-    if (m_engine != NULL)
+    else if (m_private->currentEvent.type == SDL_ACTIVEEVENT)
     {
-        m_engine->MsgProc( hWnd, uMsg, wParam, lParam );
+        event.type = EVENT_ACTIVE;
+
+        if (m_private->currentEvent.active.type & SDL_APPINPUTFOCUS)
+            event.active.flags |= ACTIVE_INPUT;
+        if (m_private->currentEvent.active.type & SDL_APPMOUSEFOCUS)
+            event.active.flags |= ACTIVE_MOUSE;
+        if (m_private->currentEvent.active.type & SDL_APPACTIVE)
+            event.active.flags |= ACTIVE_APP;
+
+        event.active.gain = m_private->currentEvent.active.gain == 1;
     }
 
-    ProcessEvent(event);*/
+    return event;
 }
 
-void CApplication::ProcessEvent(Event event)
+/** Processes incoming events. It is the first function called after an event is captures.
+    Function returns \c true if the event is to be passed on to other processing functions
+    or \c false if not. */
+bool CApplication::ProcessEvent(const Event &event)
 {
+    CLogger *l = GetLogger();
+
+    if (event.type == EVENT_ACTIVE)
+    {
+        m_active = event.active.gain;
+        if (m_debugMode)
+            l->Info("Focus change: active = %s\n", m_active ? "true" : "false");
+    }
 
+    // Print the events in debug mode to test the code
+    if (m_debugMode)
+    {
+        switch (event.type)
+        {
+            case EVENT_KEY_DOWN:
+            case EVENT_KEY_UP:
+                l->Info("EVENT_KEY_%s:\n", (event.type == EVENT_KEY_DOWN) ? "DOWN" : "UP");
+                l->Info(" key     = %4x\n", event.key.key);
+                l->Info(" state   = %s\n", (event.key.state == STATE_PRESSED) ? "STATE_PRESSED" : "STATE_RELEASED");
+                l->Info(" mod     = %4x\n", event.key.mod);
+                l->Info(" unicode = %4x\n", event.key.unicode);
+                break;
+            case EVENT_MOUSE_MOVE:
+                l->Info("EVENT_MOUSE_MOVE:\n");
+                l->Info(" state  = %s\n", (event.mouseMove.state == STATE_PRESSED) ? "STATE_PRESSED" : "STATE_RELEASED");
+                l->Info(" pos    = (%f, %f)\n", event.mouseMove.pos.x, event.mouseMove.pos.y);
+                break;
+            case EVENT_MOUSE_BUTTON_DOWN:
+            case EVENT_MOUSE_BUTTON_UP:
+                l->Info("EVENT_MOUSE_BUTTON_%s:\n", (event.type == EVENT_MOUSE_BUTTON_DOWN) ? "DOWN" : "UP");
+                l->Info(" button = %d\n", event.mouseButton.button);
+                l->Info(" state  = %s\n", (event.mouseButton.state == STATE_PRESSED) ? "STATE_PRESSED" : "STATE_RELEASED");
+                l->Info(" pos    = (%f, %f)\n", event.mouseButton.pos.x, event.mouseButton.pos.y);
+                break;
+            case EVENT_JOY_AXIS:
+                l->Info("EVENT_JOY_AXIS:\n");
+                l->Info(" axis  = %d\n", event.joyAxis.axis);
+                l->Info(" value = %d\n", event.joyAxis.value);
+                break;
+            case EVENT_JOY_BUTTON_DOWN:
+            case EVENT_JOY_BUTTON_UP:
+                l->Info("EVENT_JOY_BUTTON_%s:\n", (event.type == EVENT_JOY_BUTTON_DOWN) ? "DOWN" : "UP");
+                l->Info(" button = %d\n", event.joyButton.button);
+                l->Info(" state  = %s\n", (event.joyButton.state == STATE_PRESSED) ? "STATE_PRESSED" : "STATE_RELEASED");
+                break;
+            case EVENT_ACTIVE:
+                l->Info("EVENT_ACTIVE:\n");
+                l->Info(" flags = 0x%x\n", event.active.flags);
+                l->Info(" gain  = %s\n", event.active.gain ? "true" : "false");
+                break;
+            default:
+                break;
+        }
+    }
+
+    // By default, pass on all events
+    return true;
 }
 
+/** Renders the frame and swaps buffers as necessary. Returns \c false on error. */
 bool CApplication::Render()
 {
     bool result = m_engine->Render();
@@ -410,47 +787,62 @@ bool CApplication::Render()
     return true;
 }
 
-void CApplication::Pause(bool pause)
+void CApplication::StepSimulation(float rTime)
 {
     // TODO
 }
 
-void CApplication::SetMousePos(Math::Point pos)
+VideoQueryResult CApplication::GetVideoResolutionList(std::vector<Math::IntSize> &resolutions,
+                                                      bool fullScreen, bool resizeable)
 {
-    // TODO
-}
+    resolutions.clear();
 
-void CApplication::StepSimulation(float rTime)
-{
-    // TODO
-}
+    const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+    if (videoInfo == NULL)
+        return VIDEO_QUERY_ERROR;
 
-void SetShowStat(bool show)
-{
-    // TODO
-}
+    Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
 
-bool CApplication::RetShowStat()
-{
-    // TODO
-    return false;
-}
+    // Use hardware surface if available
+    if (videoInfo->hw_available)
+        videoFlags |= SDL_HWSURFACE;
+    else
+        videoFlags |= SDL_SWSURFACE;
 
-void CApplication::SetDebugMode(bool mode)
-{
-    // TODO
+    // Enable hardware blit if available
+    if (videoInfo->blit_hw)
+        videoFlags |= SDL_HWACCEL;
+
+    if (resizeable)
+        videoFlags |= SDL_RESIZABLE;
+
+    if (fullScreen)
+        videoFlags |= SDL_FULLSCREEN;
+
+
+    SDL_Rect **modes = SDL_ListModes(NULL, videoFlags);
+
+    if (modes == reinterpret_cast<SDL_Rect **>(0) )
+        return VIDEO_QUERY_NONE; // no modes available
+
+    if (modes == reinterpret_cast<SDL_Rect **>(-1) )
+        return VIDEO_QUERY_ALL; // all resolutions are possible
+
+
+    for (int i = 0; modes[i] != NULL; ++i)
+        resolutions.push_back(Math::IntSize(modes[i]->w, modes[i]->h));
+
+    return VIDEO_QUERY_OK;
 }
 
-bool CApplication::RetDebugMode()
+void CApplication::SetDebugMode(bool mode)
 {
-    // TODO
-    return false;
+    m_debugMode = mode;
 }
 
-bool CApplication::RetSetupMode()
+bool CApplication::GetDebugMode()
 {
-    // TODO
-    return false;
+    return m_debugMode;
 }
 
 void CApplication::FlushPressKey()
@@ -468,64 +860,92 @@ void CApplication::SetKey(int keyRank, int option, int key)
     // TODO
 }
 
-int CApplication::RetKey(int keyRank, int option)
+int CApplication::GetKey(int keyRank, int option)
 {
     // TODO
     return 0;
 }
 
-void CApplication::SetJoystick(bool enable)
+void CApplication::SetGrabInput(bool grab)
 {
-    // TODO
+    SDL_WM_GrabInput(grab ? SDL_GRAB_ON : SDL_GRAB_OFF);
 }
 
-bool CApplication::RetJoystick()
+bool CApplication::GetGrabInput()
 {
-    // TODO
-    return false;
+    int result = SDL_WM_GrabInput(SDL_GRAB_QUERY);
+    return result == SDL_GRAB_ON;
 }
 
-void SetMouseType(Gfx::MouseType type)
+void CApplication::SetSystemMouseVisible(bool visible)
 {
-    // TODO
+    SDL_ShowCursor(visible ? SDL_ENABLE : SDL_DISABLE);
 }
 
-void SetNiceMouse(bool nice)
+bool CApplication::GetSystemMouseVisibile()
 {
-    // TODO
+    int result = SDL_ShowCursor(SDL_QUERY);
+    return result == SDL_ENABLE;
 }
 
-bool CApplication::RetNiceMouse()
+
+void CApplication::SetSystemMousePos(Math::Point pos)
 {
-    return false;
+    Math::IntPoint windowPos = InterfaceToWindowCoords(pos);
+    SDL_WarpMouse(windowPos.x, windowPos.y);
+    m_systemMousePos = pos;
 }
 
-bool CApplication::RetNiceMouseCap()
+Math::Point CApplication::GetSystemMousePos()
 {
-    return false;
+    return m_systemMousePos;
 }
 
-bool CApplication::WriteScreenShot(char *filename, int width, int height)
+std::vector<JoystickDevice> CApplication::GetJoystickList()
 {
-    // TODO
+    std::vector<JoystickDevice> result;
+
+    int count = SDL_NumJoysticks();
+
+    for (int index = 0; index < count; ++index)
+    {
+        JoystickDevice device;
+        device.index = index;
+        device.name = SDL_JoystickName(index);
+        result.push_back(device);
+    }
+
+    return result;
 }
 
-void CApplication::InitText()
+JoystickDevice CApplication::GetJoystick()
 {
-    // TODO
+    return m_joystick;
 }
 
-void CApplication::DrawSuppl()
+void CApplication::SetJoystickEnabled(bool enable)
 {
-    // TODO
+    m_joystickEnabled = enable;
+
+    if (m_joystickEnabled)
+    {
+        if (! OpenJoystick())
+        {
+            m_joystickEnabled = false;
+        }
+    }
+    else
+    {
+        CloseJoystick();
+    }
 }
 
-void CApplication::ShowStats()
+bool CApplication::GetJoystickEnabled()
 {
-    // TODO
+    return m_joystickEnabled;
 }
 
-void CApplication::OutputText(long x, long y, char* str)
+std::string CApplication::GetDataFilePath(const std::string& dirName, const std::string& fileName)
 {
-    // TODO
+    return m_dataPath + "/" + dirName + "/" + fileName;
 }
diff --git a/src/app/app.h b/src/app/app.h
index f776b10..483aa55 100644
--- a/src/app/app.h
+++ b/src/app/app.h
@@ -21,10 +21,14 @@
 
 
 #include "common/misc.h"
-#include "graphics/common/device.h"
-#include "graphics/common/engine.h"
+#include "common/singleton.h"
+#include "graphics/core/device.h"
+#include "graphics/engine/engine.h"
+#include "graphics/opengl/gldevice.h"
+#include "math/intsize.h"
 
 #include <string>
+#include <vector>
 
 
 class CInstanceManager;
@@ -32,19 +36,82 @@ class CEvent;
 class CRobotMain;
 class CSound;
 
-struct ApplicationPrivate;
+/**
+  \struct JoystickDevice
+  \brief Information about a joystick device */
+struct JoystickDevice
+{
+    //! Device index (-1 = invalid device)
+    int index;
+    //! Device name
+    std::string name;
+    //! Number of axes (only available after joystick opened)
+    int axisCount;
+    //! Number of buttons (only available after joystick opened)
+    int buttonCount;
+
+    JoystickDevice()
+        : index(-1), axisCount(0), buttonCount(0) {}
+};
+
+/**
+  \enum VideoQueryResult
+  \brief Result of querying for available video resolutions */
+enum VideoQueryResult
+{
+    VIDEO_QUERY_ERROR,
+    VIDEO_QUERY_NONE,
+    VIDEO_QUERY_ALL,
+    VIDEO_QUERY_OK
+};
 
 
+struct ApplicationPrivate;
+
 /**
  * \class CApplication
  * \brief Main application
  *
- * This class is responsible for creating and handling main application window,
- * receiving events, etc.
+ * This class is responsible for main application execution, including creating
+ * and handling main application window, receiving events, etc.
+ *
+ * It is a singleton class with only one instance that can be created.
+ *
+ * \section Creation Creation of other main objects
+ *
+ * The class creates the only instance of CInstanceManager, CEventQueue, CEngine,
+ * CRobotMain and CSound classes.
+ *
+ * \section Window Window management
+ *
+ * The class is responsible for creating app window, setting and changing the video mode,
+ * joystick management, grabbing input and changing the system mouse cursor
+ * position and visibility.
+ * ("System mouse cursor" means the cursor displayed by the OS in constrast to the cursor
+ * displayed by CEngine).
+ *
+ * \section Events Events
+ *
+ * Events are taken from SDL event queue, translated to common events from src/common.h
+ * and pushed to global event queue CEventQueue.
+ *
+ * Joystick events are generated somewhat differently, by running a separate timer,
+ * polling the device for changes and synthesising events on change. It avoids flooding
+ * the event queue with too many joystick events and the granularity of the timer can be
+ * adjusted.
+ *
+ * The events are passed to ProcessEvent() of classes in this order: CApplication, CEngine
+ * and CRobotMain. CApplication and CEngine's ProcessEvent() functions return bool, which
+ * means whether to pass the event on, or stop the chain. This is to enable handling some
+ * events which are internal to CApplication or CEngine.
+ *
+ * \section Portability Portability
+ *
+ * Currently, the class only handles OpenGL devices. SDL can be used with DirectX, but
+ * for that to work, video initialization and video setting must be done differently.
  *
- * ...
  */
-class CApplication
+class CApplication : public CSingleton<CApplication>
 {
 public:
     //! Constructor (can only be called once!)
@@ -54,104 +121,145 @@ public:
 
 public:
     //! Parses commandline arguments
-    Error       ParseArguments(int argc, char *argv[]);
+    bool        ParseArguments(int argc, char *argv[]);
     //! Initializes the application
     bool        Create();
     //! Main event loop
     int         Run();
-
     //! Returns the code to be returned at main() exit
     int         GetExitCode();
 
-protected:
     //! Cleans up before exit
     void        Destroy();
-    //! Processes an SDL event to Event struct
-    void        ParseEvent();
-    //! Handles some incoming events
-    void        ProcessEvent(Event event);
-    //! Renders the image in window
-    bool        Render();
 
-public:
-    void        Pause(bool pause);
+    //! Returns a list of possible video modes
+    VideoQueryResult GetVideoResolutionList(std::vector<Math::IntSize> &resolutions,
+                                            bool fullScreen, bool resizeable);
+
+    //! Returns the current video mode
+    Gfx::GLDeviceConfig GetVideoConfig();
+
+    //! Change the video mode to given mode
+    bool        ChangeVideoConfig(const Gfx::GLDeviceConfig &newConfig);
+
+    //! Updates the simulation state
     void        StepSimulation(float rTime);
 
-    void        SetMousePos(Math::Point pos);
+    //! Returns a list of available joystick devices
+    std::vector<JoystickDevice> GetJoystickList();
 
-    void        SetShowStat(bool show);
-    bool        RetShowStat();
-    void        SetDebugMode(bool mode);
-    bool        RetDebugMode();
-    bool        RetSetupMode();
+    //! Returns info about the current joystick
+    JoystickDevice GetJoystick();
+
+    //! Change the current joystick device
+    bool        ChangeJoystick(const JoystickDevice &newJoystick);
+
+    //! Enables/disables joystick
+    void        SetJoystickEnabled(bool enable);
+    //! Returns whether joystick is enabled
+    bool        GetJoystickEnabled();
+
+    //! Polls the state of joystick axes and buttons
+    void        UpdateJoystick();
 
     void        FlushPressKey();
     void        ResetKey();
     void        SetKey(int keyRank, int option, int key);
-    int         RetKey(int keyRank, int option);
+    int         GetKey(int keyRank, int option);
+
+    //! Sets the grab mode for input (keyboard & mouse)
+    void        SetGrabInput(bool grab);
+    //! Returns the grab mode
+    bool        GetGrabInput();
 
-    void        SetJoystick(bool enable);
-    bool        RetJoystick();
+    //! Sets the visiblity of system mouse cursor
+    void        SetSystemMouseVisible(bool visible);
+    //! Returns the visiblity of system mouse cursor
+    bool        GetSystemMouseVisibile();
 
-    void        SetMouseType(Gfx::MouseType type);
-    void        SetNiceMouse(bool nice);
-    bool        RetNiceMouse();
-    bool        RetNiceMouseCap();
+    //! Sets the position of system mouse cursor (in interface coords)
+    void        SetSystemMousePos(Math::Point pos);
+    //! Returns the position of system mouse cursor (in interface coords)
+    Math::Point GetSystemMousePos();
+
+    //! Enables/disables debug mode (prints more info in logger)
+    void        SetDebugMode(bool mode);
+    //! Returns whether debug mode is enabled
+    bool        GetDebugMode();
 
-    bool        WriteScreenShot(char *filename, int width, int height);
+    //! Returns the full path to a file in data directory
+    std::string GetDataFilePath(const std::string &dirName, const std::string &fileName);
 
 protected:
-    //HRESULT       ConfirmDevice( DDCAPS* pddDriverCaps, D3DDEVICEDESC7* pd3dDeviceDesc );
-    //HRESULT       Initialize3DEnvironment();
-    //HRESULT       Change3DEnvironment();
-    //HRESULT       CreateZBuffer(GUID* pDeviceGUID);
-    //HRESULT       Render3DEnvironment();
-    //VOID      Cleanup3DEnvironment();
-    //VOID      DeleteDeviceObjects();
-    //VOID      DisplayFrameworkError( HRESULT, DWORD );
-
-    void        InitText();
-    void        DrawSuppl();
-    void        ShowStats();
-    void        OutputText(long x, long y, char* str);
+    //! Creates the window's SDL_Surface
+    bool CreateVideoSurface();
+
+    //! Processes the captured SDL event to Event struct
+    Event       ParseEvent();
+    //! Handles some incoming events
+    bool        ProcessEvent(const Event &event);
+    //! Renders the image in window
+    bool        Render();
+
+    //! Opens the joystick device
+    bool OpenJoystick();
+    //! Closes the joystick device
+    void CloseJoystick();
+
+    //! Converts window coords to interface coords
+    Math::Point WindowToInterfaceCoords(Math::IntPoint pos);
+    //! Converts the interface coords to window coords
+    Math::IntPoint InterfaceToWindowCoords(Math::Point pos);
 
 protected:
+    //! Instance manager
+    CInstanceManager*       m_iMan;
     //! Private (SDL-dependent data)
     ApplicationPrivate*     m_private;
-    CInstanceManager*       m_iMan;
-    Gfx::DeviceConfig       m_deviceConfig;
+    //! Global event queue
+    CEventQueue*            m_eventQueue;
+    //! Graphics engine
     Gfx::CEngine*           m_engine;
-    CEvent*                 m_event;
-    CRobotMain*             m_robotMain;
+    //! Graphics device
+    Gfx::CDevice*           m_device;
+    //! Sound subsystem
     CSound*                 m_sound;
+    //! Main class of the proper game engine
+    CRobotMain*             m_robotMain;
 
     //! Code to return at exit
     int             m_exitCode;
-
+    //! Whether application window is active
     bool            m_active;
-    bool            m_activateApp;
-    bool            m_ready;
-    bool            m_joystick;
+    //! Whether debug mode is enabled
+    bool            m_debugMode;
+
+    //! Current configuration of OpenGL display device
+    Gfx::GLDeviceConfig m_deviceConfig;
+    //! Previous configuration of OpenGL display device
+    Gfx::GLDeviceConfig m_lastDeviceConfig;
 
+    //! Text set as window title
     std::string     m_windowTitle;
-    long            m_vidMemTotal;
-    bool            m_appUseZBuffer;
-    bool            m_appUseStereo;
-    bool            m_showStats;
-    bool            m_debugMode;
-    bool            m_audioState;
-    bool            m_audioTrack;
-    bool            m_niceMouse;
-    bool            m_setupMode;
 
     int             m_keyState;
     Math::Vector    m_axeKey;
     Math::Vector    m_axeJoy;
-    bool            m_joyButton[32];
-    Math::Point     m_mousePos;
+    Math::Point     m_systemMousePos;
     long            m_mouseWheel;
 
-    float           m_time;
     long            m_key[50][2];
+
+    //! Info about current joystick device
+    JoystickDevice  m_joystick;
+    //! Whether joystick is enabled
+    bool            m_joystickEnabled;
+    //! Current state of joystick axes; may be updated from another thread
+    std::vector<int> m_joyAxeState;
+    //! Current state of joystick buttons; may be updated from another thread
+    std::vector<bool> m_joyButtonState;
+
+    //! Path to directory with data files
+    std::string     m_dataPath;
 };
 
diff --git a/src/app/main.cpp b/src/app/main.cpp
index 151cd20..dce13da 100644
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -24,6 +24,48 @@
 #include "common/restext.h"
 
 
+/* Doxygen main page */
+
+/**
+
+\mainpage
+
+Doxygen documentation of Colobot project
+
+\section Intro Introduction
+
+The source code released by Epitec was sparsely documented. This documentation, written from scratch,
+will aim to describe the various components of the code.
+
+Currently, the only documented classes are the ones written from scratch or the old ones rewritten
+to match the new code.
+In time, the documentation will be extended to cover every major part of the code.
+
+\section Structure Code structure
+
+The source code was split from the original all-in-one directory to subdirectories,
+each containing one major part of the project.
+The current layout is the following:
+ - src/CBot - separate library with CBot language
+ - src/app - class CApplication and everything concerned with SDL plus other system-dependent
+   code such as displaying a message box, finding files, etc.
+ - src/common - shared structs, enums, defines, etc.; should not have any external dependencies
+ - src/graphics/core - abstract interface of graphics device (abstract CDevice class)
+   (split from old src/graphics/common)
+ - src/graphics/engine - main graphics engine based on abstract graphics device; is composed
+   of CEngine class and associated classes implementing the 3D engine (split from old src/graphics/common)
+ - src/graphics/opengl - concrete implementation of CDevice class in OpenGL: CGLDevice
+ - src/graphics/d3d - in (far) future - perhaps a newer implementation in DirectX (9? 10?)
+ - src/math - mathematical structures and functions
+ - src/object - non-graphical game engine, that is robots, buildings, etc.
+ - src/ui - 2D user interface (menu, buttons, check boxes, etc.)
+ - src/sound - sound and music engine written using fmod library
+ - src/physics - physics engine
+ - src/script - link with the CBot library
+ - src/metafile - separate program for packing data files to .dat format
+*/
+
+
 //! Entry point to the program
 int main(int argc, char *argv[])
 {
@@ -33,16 +75,17 @@ int main(int argc, char *argv[])
 
     CApplication app; // single instance of the application
 
-    Error err = app.ParseArguments(argc, argv);
-    if (err != ERR_OK)
+    if (! app.ParseArguments(argc, argv))
     {
         SystemDialog(SDT_ERROR, "COLOBOT", "Invalid commandline arguments!\n");
+        return app.GetExitCode();
     }
 
     int code = 0;
 
     if (! app.Create())
     {
+        app.Destroy(); // ensure a clean exit
         code = app.GetExitCode();
         logger.Info("Didn't run main loop. Exiting with code %d\n", code);
         return code;
diff --git a/src/app/system.cpp b/src/app/system.cpp
index a765e11..eb0321b 100644
--- a/src/app/system.cpp
+++ b/src/app/system.cpp
@@ -21,19 +21,21 @@
 
 #include "common/config.h"
 
+
 #if defined(PLATFORM_WINDOWS)
-#include <windows.h>
+#include "system_windows.h"
+
 #elif defined(PLATFORM_LINUX)
-#include <cstdlib>
+#include "system_linux.h"
+
 #else
-#include <iostream>
+#include "system_other.h"
+
 #endif
 
 
+#include <cassert>
 
-SystemDialogResult SystemDialog_Windows(SystemDialogType type, const std::string& title, const std::string& message);
-SystemDialogResult SystemDialog_Linux(SystemDialogType type, const std::string& title, const std::string& message);
-SystemDialogResult SystemDialog_Other(SystemDialogType type, const std::string& title, const std::string& message);
 
 /**
  * Displays a system dialog with info, error, question etc. message.
@@ -45,209 +47,103 @@ SystemDialogResult SystemDialog_Other(SystemDialogType type, const std::string&
  */
 SystemDialogResult SystemDialog(SystemDialogType type, const std::string& title, const std::string& message)
 {
-    #if defined(PLATFORM_WINDOWS)
+#if defined(PLATFORM_WINDOWS)
     return SystemDialog_Windows(type, title, message);
-    #elif defined(PLATFORM_LINUX)
+#elif defined(PLATFORM_LINUX)
     return SystemDialog_Linux(type, title, message);
-    #else
+#else
     return SystemDialog_Other(type, title, message);
-    #endif
+#endif
 }
 
-
-
-#if defined(PLATFORM_WINDOWS)
-
-// Convert a wide Unicode string to an UTF8 string
-std::string UTF8_Encode_Windows(const std::wstring &wstr)
+SystemTimeStamp* CreateTimeStamp()
 {
-    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
-    std::string strTo(size_needed, 0);
-    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
-    return strTo;
+    return new SystemTimeStamp();
 }
 
-// Convert an UTF8 string to a wide Unicode String
-std::wstring UTF8_Decode_Windows(const std::string &str)
+void DestroyTimeStamp(SystemTimeStamp *stamp)
 {
-    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
-    std::wstring wstrTo(size_needed, 0);
-    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
-    return wstrTo;
+    delete stamp;
 }
 
-SystemDialogResult SystemDialog_Windows(SystemDialogType type, const std::string& title, const std::string& message)
+void CopyTimeStamp(SystemTimeStamp *dst, SystemTimeStamp *src)
 {
-    unsigned int windowsType = 0;
-    std::wstring windowsMessage = UTF8_Decode_Windows(message);
-    std::wstring windowsTitle = UTF8_Decode_Windows(title);
-
-    switch (type)
-    {
-        case SDT_INFO:
-        default:
-            windowsType = MB_ICONINFORMATION|MB_OK;
-            break;
-        case SDT_WARNING:
-            windowsType = MB_ICONWARNING|MB_OK;
-            break;
-        case SDT_ERROR:
-            windowsType = MB_ICONERROR|MB_OK;
-            break;
-        case SDT_YES_NO:
-            windowsType = MB_ICONQUESTION|MB_YESNO;
-            break;
-        case SDT_OK_CANCEL:
-            windowsType = MB_ICONWARNING|MB_OKCANCEL;
-            break;
-    }
-
-    switch (MessageBoxW(NULL, windowsMessage.c_str(), windowsTitle.c_str(), windowsType))
-    {
-        case IDOK:
-            return SDR_OK;
-        case IDCANCEL:
-            return SDR_CANCEL;
-        case IDYES:
-            return SDR_YES;
-        case IDNO:
-            return SDR_NO;
-        default:
-            break;
-    }
-
-    return SDR_OK;
+    *dst = *src;
 }
 
+void GetCurrentTimeStamp(SystemTimeStamp *stamp)
+{
+#if defined(PLATFORM_WINDOWS)
+    GetCurrentTimeStamp_Windows(stamp);
 #elif defined(PLATFORM_LINUX)
+    GetCurrentTimeStamp_Linux(stamp);
+#else
+    GetCurrentTimeStamp_Other(stamp);
+#endif
+}
 
-SystemDialogResult SystemDialog_Linux(SystemDialogType type, const std::string& title, const std::string& message)
+float GetTimeStampResolution(SystemTimeUnit unit)
 {
-    std::string options = "";
-    switch (type)
-    {
-        case SDT_INFO:
-        default:
-            options = "--info";
-            break;
-        case SDT_WARNING:
-            options = "--warning";
-            break;
-        case SDT_ERROR:
-            options = "--error";
-            break;
-        case SDT_YES_NO:
-            options = "--question --ok-label=\"Yes\" --cancel-label=\"No\"";
-            break;
-        case SDT_OK_CANCEL:
-            options = "--question --ok-label=\"OK\" --cancel-label=\"Cancel\"";
-            break;
-    }
-
-    std::string command = "zenity " + options + " --text=\"" + message + "\" --title=\"" + title + "\"";
-    int code = system(command.c_str());
-
-    SystemDialogResult result = SDR_OK;
-    switch (type)
-    {
-        case SDT_YES_NO:
-            result = code ? SDR_NO : SDR_YES;
-            break;
-        case SDT_OK_CANCEL:
-            result = code ? SDR_CANCEL : SDR_OK;
-            break;
-        default:
-            break;
-    }
-
+    unsigned long long exact = 0;
+#if defined(PLATFORM_WINDOWS)
+    exact = GetTimeStampExactResolution_Windows();
+#elif defined(PLATFORM_LINUX)
+    exact = GetTimeStampExactResolution_Linux();
+#else
+    exact = GetTimeStampExactResolution_Other();
+#endif
+    float result = 0.0f;
+    if (unit == STU_SEC)
+        result = exact * 1e-9;
+    else if (unit == STU_MSEC)
+        result = exact * 1e-6;
+    else if (unit == STU_USEC)
+        result = exact * 1e-3;
+    else
+        assert(false);
     return result;
 }
 
+long long GetTimeStampExactResolution()
+{
+#if defined(PLATFORM_WINDOWS)
+    return GetTimeStampExactResolution_Windows();
+#elif defined(PLATFORM_LINUX)
+    return GetTimeStampExactResolution_Linux();
 #else
+    return GetTimeStampExactResolution_Other();
+#endif
+}
 
-SystemDialogResult SystemDialog_Other(SystemDialogType type, const std::string& title, const std::string& message)
+float TimeStampDiff(SystemTimeStamp *before, SystemTimeStamp *after, SystemTimeUnit unit)
 {
-    switch (type)
-    {
-        case SDT_INFO:
-            std::cout << "INFO: ";
-            break;
-        case SDT_WARNING:
-            std::cout << "WARNING:";
-            break;
-        case SDT_ERROR:
-            std::cout << "ERROR: ";
-            break;
-        case SDT_YES_NO:
-        case SDT_OK_CANCEL:
-            std::cout << "QUESTION: ";
-            break;
-    }
-
-    std::cout << message << std::endl;
-
-    std::string line;
-
-    SystemDialogResult result = SDR_OK;
-
-    bool done = false;
-    while (!done)
-    {
-        switch (type)
-        {
-            case SDT_INFO:
-            case SDT_WARNING:
-            case SDT_ERROR:
-                std::cout << "Press ENTER to continue";
-                break;
-
-            case SDT_YES_NO:
-                std::cout << "Type 'Y' for Yes or 'N' for No";
-                break;
-
-            case SDT_OK_CANCEL:
-                std::cout << "Type 'O' for OK or 'C' for Cancel";
-                break;
-        }
-
-        std::getline(std::cin, line);
-
-        switch (type)
-        {
-            case SDT_INFO:
-            case SDT_WARNING:
-            case SDT_ERROR:
-                done = true;
-                break;
-
-            case SDT_YES_NO:
-                if (line == "Y" || line == "y")
-                {
-                    result = SDR_YES;
-                    done = true;
-                }
-                else if (line == "N" || line == "n")
-                {
-                    result = SDR_NO;
-                    done = true;
-                }
-                break;
-
-            case SDT_OK_CANCEL:
-                if (line == "O" || line == "o")
-                {
-                    done = true;
-                    result = SDR_OK;
-                }
-                else if (line == "C" || line == "c")
-                {
-                    done = true;
-                    result = SDR_CANCEL;
-                }
-                break;
-        }
-    }
-
+    long long exact = 0;
+#if defined(PLATFORM_WINDOWS)
+    exact = TimeStampExactDiff_Windows(before, after);
+#elif defined(PLATFORM_LINUX)
+    exact = TimeStampExactDiff_Linux(before, after);
+#else
+    exact = TimeStampExactDiff_Other(before, after);
+#endif
+    float result = 0.0f;
+    if (unit == STU_SEC)
+        result = exact * 1e-9;
+    else if (unit == STU_MSEC)
+        result = exact * 1e-6;
+    else if (unit == STU_USEC)
+        result = exact * 1e-3;
+    else
+        assert(false);
     return result;
 }
-#endif // if defined(PLATFORM_WINDOWS)
+
+long long TimeStampExactDiff(SystemTimeStamp *before, SystemTimeStamp *after)
+{
+#if defined(PLATFORM_WINDOWS)
+    return TimeStampExactDiff_Windows(before, after);
+#elif defined(PLATFORM_LINUX)
+    return TimeStampExactDiff_Linux(before, after);
+#else
+    return TimeStampExactDiff_Other(before, after);
+#endif
+}
diff --git a/src/app/system.h b/src/app/system.h
index 3bf6457..3c04760 100644
--- a/src/app/system.h
+++ b/src/app/system.h
@@ -23,6 +23,8 @@
 #include <string>
 
 
+/* Dialog utils */
+
 /**
  * \enum SysDialogType
  * \brief Type of system dialog
@@ -57,3 +59,47 @@ enum SystemDialogResult
 
 //! Displays a system dialog
 SystemDialogResult SystemDialog(SystemDialogType, const std::string &title, const std::string &message);
+
+
+/* Time utils */
+
+enum SystemTimeUnit
+{
+    //! seconds
+    STU_SEC,
+    //! milliseconds
+    STU_MSEC,
+    //! microseconds
+    STU_USEC
+};
+
+/* Forward declaration of time stamp struct
+  * SystemTimeStamp should be used in a pointer context.
+  * The implementation details are hidden because of platform dependence. */
+struct SystemTimeStamp;
+
+//! Creates a new time stamp object
+SystemTimeStamp* CreateTimeStamp();
+
+//! Destroys a time stamp object
+void DestroyTimeStamp(SystemTimeStamp *stamp);
+
+//! Copies the time stamp from \a src to \a dst
+void CopyTimeStamp(SystemTimeStamp *dst, SystemTimeStamp *src);
+
+//! Returns a time stamp associated with current time
+void GetCurrentTimeStamp(SystemTimeStamp *stamp);
+
+//! Returns the platform's expected time stamp resolution
+float GetTimeStampResolution(SystemTimeUnit unit = STU_SEC);
+
+//! Returns the platform's exact (in nanosecond units) expected time stamp resolution
+long long GetTimeStampExactResolution();
+
+//! Returns a difference between two timestamps in given time unit
+/** The difference is \a after - \a before. */
+float TimeStampDiff(SystemTimeStamp *before, SystemTimeStamp *after, SystemTimeUnit unit = STU_SEC);
+
+//! Returns the exact (in nanosecond units) difference between two timestamps
+/** The difference is \a after - \a before. */
+long long TimeStampExactDiff(SystemTimeStamp *before, SystemTimeStamp *after);
diff --git a/src/app/system_linux.h b/src/app/system_linux.h
new file mode 100644
index 0000000..f58c9a1
--- /dev/null
+++ b/src/app/system_linux.h
@@ -0,0 +1,101 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// system_linux.h
+
+/* This header contains Linux-specific code for system utils
+   from system.h. There is no separate .cpp module for simplicity.*/
+
+#include <sys/time.h>
+#include <time.h>
+#include <stdlib.h>
+
+
+SystemDialogResult SystemDialog_Linux(SystemDialogType type, const std::string& title, const std::string& message);
+
+void GetCurrentTimeStamp_Linux(SystemTimeStamp *stamp);
+long long GetTimeStampExactResolution_Linux();
+long long TimeStampExactDiff_Linux(SystemTimeStamp *before, SystemTimeStamp *after);
+
+struct SystemTimeStamp
+{
+    timespec clockTime;
+
+    SystemTimeStamp()
+    {
+        clockTime.tv_sec = clockTime.tv_nsec = 0;
+    }
+};
+
+
+SystemDialogResult SystemDialog_Linux(SystemDialogType type, const std::string& title, const std::string& message)
+{
+    std::string options = "";
+    switch (type)
+    {
+        case SDT_INFO:
+        default:
+            options = "--info";
+            break;
+        case SDT_WARNING:
+            options = "--warning";
+            break;
+        case SDT_ERROR:
+            options = "--error";
+            break;
+        case SDT_YES_NO:
+            options = "--question --ok-label=\"Yes\" --cancel-label=\"No\"";
+            break;
+        case SDT_OK_CANCEL:
+            options = "--question --ok-label=\"OK\" --cancel-label=\"Cancel\"";
+            break;
+    }
+
+    std::string command = "zenity " + options + " --text=\"" + message + "\" --title=\"" + title + "\"";
+    int code = system(command.c_str());
+
+    SystemDialogResult result = SDR_OK;
+    switch (type)
+    {
+        case SDT_YES_NO:
+            result = code ? SDR_NO : SDR_YES;
+            break;
+        case SDT_OK_CANCEL:
+            result = code ? SDR_CANCEL : SDR_OK;
+            break;
+        default:
+            break;
+    }
+
+    return result;
+}
+
+void GetCurrentTimeStamp_Linux(SystemTimeStamp *stamp)
+{
+    clock_gettime(CLOCK_MONOTONIC, &stamp->clockTime);
+}
+
+long long GetTimeStampExactResolution_Linux()
+{
+    return 1ll;
+}
+
+long long TimeStampExactDiff_Linux(SystemTimeStamp *before, SystemTimeStamp *after)
+{
+    return (after->clockTime.tv_nsec - before->clockTime.tv_nsec) +
+           (after->clockTime.tv_sec  - before->clockTime.tv_sec) * 1000000000ll;
+}
diff --git a/src/app/system_other.h b/src/app/system_other.h
new file mode 100644
index 0000000..9f13ffa
--- /dev/null
+++ b/src/app/system_other.h
@@ -0,0 +1,146 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// system_other.h
+
+/* This header contains fallback code for other platforms for system utils
+   from system.h. There is no separate .cpp module for simplicity.*/
+
+#include <SDL/SDL.h>
+
+#include <iostream>
+
+
+SystemDialogResult SystemDialog_Other(SystemDialogType type, const std::string& title, const std::string& message);
+
+void GetCurrentTimeStamp_Other(SystemTimeStamp *stamp);
+long long GetTimeStampExactResolution_Other();
+long long TimeStampExactDiff_Other(SystemTimeStamp *before, SystemTimeStamp *after);
+
+struct SystemTimeStamp
+{
+    Uint32 sdlTicks;
+
+    SystemTimeStamp()
+    {
+        sdlTicks = 0;
+    }
+};
+
+
+SystemDialogResult SystemDialog_Other(SystemDialogType type, const std::string& title, const std::string& message)
+{
+    switch (type)
+    {
+        case SDT_INFO:
+            std::cout << "INFO: ";
+            break;
+        case SDT_WARNING:
+            std::cout << "WARNING:";
+            break;
+        case SDT_ERROR:
+            std::cout << "ERROR: ";
+            break;
+        case SDT_YES_NO:
+        case SDT_OK_CANCEL:
+            std::cout << "QUESTION: ";
+            break;
+    }
+
+    std::cout << message << std::endl;
+
+    std::string line;
+
+    SystemDialogResult result = SDR_OK;
+
+    bool done = false;
+    while (!done)
+    {
+        switch (type)
+        {
+            case SDT_INFO:
+            case SDT_WARNING:
+            case SDT_ERROR:
+                std::cout << "Press ENTER to continue";
+                break;
+
+            case SDT_YES_NO:
+                std::cout << "Type 'Y' for Yes or 'N' for No";
+                break;
+
+            case SDT_OK_CANCEL:
+                std::cout << "Type 'O' for OK or 'C' for Cancel";
+                break;
+        }
+
+        std::getline(std::cin, line);
+
+        switch (type)
+        {
+            case SDT_INFO:
+            case SDT_WARNING:
+            case SDT_ERROR:
+                done = true;
+                break;
+
+            case SDT_YES_NO:
+                if (line == "Y" || line == "y")
+                {
+                    result = SDR_YES;
+                    done = true;
+                }
+                else if (line == "N" || line == "n")
+                {
+                    result = SDR_NO;
+                    done = true;
+                }
+                break;
+
+            case SDT_OK_CANCEL:
+                if (line == "O" || line == "o")
+                {
+                    done = true;
+                    result = SDR_OK;
+                }
+                else if (line == "C" || line == "c")
+                {
+                    done = true;
+                    result = SDR_CANCEL;
+                }
+                break;
+        }
+    }
+
+    return result;
+}
+
+
+
+void GetCurrentTimeStamp_Other(SystemTimeStamp *stamp)
+{
+    stamp->sdlTicks = SDL_GetTicks();
+}
+
+long long GetTimeStampExactResolution_Other()
+{
+    return 1000000ll;
+}
+
+long long TimeStampExactDiff_Other(SystemTimeStamp *before, SystemTimeStamp *after)
+{
+    return (after->sdlTicks - before->sdlTicks) * 1000000ll;
+}
diff --git a/src/app/system_windows.h b/src/app/system_windows.h
new file mode 100644
index 0000000..eb6beec
--- /dev/null
+++ b/src/app/system_windows.h
@@ -0,0 +1,122 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// system_windows.h
+
+/* This header contains Windows-specific code for system utils
+   from system.h. There is no separate .cpp module for simplicity.*/
+
+#include <windows.h>
+
+
+std::string UTF8_Encode_Windows(const std::wstring &wstr);
+std::wstring UTF8_Decode_Windows(const std::string &str);
+SystemDialogResult SystemDialog_Windows(SystemDialogType type, const std::string& title, const std::string& message);
+
+void GetCurrentTimeStamp_Windows(SystemTimeStamp *stamp);
+long long GetTimeStampExactResolution_Windows();
+long long TimeStampExactDiff_Windows(SystemTimeStamp *before, SystemTimeStamp *after);
+
+struct SystemTimeStamp
+{
+    FILETIME fileTime;
+
+    SystemTimeStamp()
+    {
+        fileTime.dwHighDateTime = fileTime.dwLowDateTime = 0;
+    }
+};
+
+
+// Convert a wide Unicode string to an UTF8 string
+std::string UTF8_Encode_Windows(const std::wstring &wstr)
+{
+    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
+    std::string strTo(size_needed, 0);
+    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
+    return strTo;
+}
+
+// Convert an UTF8 string to a wide Unicode String
+std::wstring UTF8_Decode_Windows(const std::string &str)
+{
+    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
+    std::wstring wstrTo(size_needed, 0);
+    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
+    return wstrTo;
+}
+
+SystemDialogResult SystemDialog_Windows(SystemDialogType type, const std::string& title, const std::string& message)
+{
+    unsigned int windowsType = 0;
+    std::wstring windowsMessage = UTF8_Decode_Windows(message);
+    std::wstring windowsTitle = UTF8_Decode_Windows(title);
+
+    switch (type)
+    {
+        case SDT_INFO:
+        default:
+            windowsType = MB_ICONINFORMATION|MB_OK;
+            break;
+        case SDT_WARNING:
+            windowsType = MB_ICONWARNING|MB_OK;
+            break;
+        case SDT_ERROR:
+            windowsType = MB_ICONERROR|MB_OK;
+            break;
+        case SDT_YES_NO:
+            windowsType = MB_ICONQUESTION|MB_YESNO;
+            break;
+        case SDT_OK_CANCEL:
+            windowsType = MB_ICONWARNING|MB_OKCANCEL;
+            break;
+    }
+
+    switch (MessageBoxW(NULL, windowsMessage.c_str(), windowsTitle.c_str(), windowsType))
+    {
+        case IDOK:
+            return SDR_OK;
+        case IDCANCEL:
+            return SDR_CANCEL;
+        case IDYES:
+            return SDR_YES;
+        case IDNO:
+            return SDR_NO;
+        default:
+            break;
+    }
+
+    return SDR_OK;
+}
+
+
+void GetCurrentTimeStamp_Windows(SystemTimeStamp *stamp)
+{
+    GetSystemTimeAsFileTime(&stamp->fileTime);
+}
+
+long long GetTimeStampExactResolution_Windows()
+{
+    return 100ll;
+}
+
+long long TimeStampExactDiff_Windows(SystemTimeStamp *before, SystemTimeStamp *after)
+{
+    long long tH = (1ll << 32) * (after->fileTime.dwHighDateTime - before->fileTime.dwHighDateTime);
+    long long tL = after->fileTime.dwLowDateTime - before->fileTime.dwLowDateTime;
+    return (tH + tL) * 100ll;
+}
diff --git a/src/common/config.h.cmake b/src/common/config.h.cmake
index b066387..f496db0 100644
--- a/src/common/config.h.cmake
+++ b/src/common/config.h.cmake
@@ -1,8 +1,10 @@
-#pragma once

-

-// Macros set by CMake

-#cmakedefine DEBUG

-#cmakedefine PLATFORM_WINDOWS @PLATFORM_WINDOWS@

-#cmakedefine PLATFORM_LINUX @PLATFORM_LINUX@

-#cmakedefine PLATFORM_OTHER @PLATFORM_OTHER@

-

+#pragma once
+
+// Macros set by CMake
+#cmakedefine DEBUG
+
+#cmakedefine PLATFORM_WINDOWS @PLATFORM_WINDOWS@
+#cmakedefine PLATFORM_LINUX @PLATFORM_LINUX@
+#cmakedefine PLATFORM_OTHER @PLATFORM_OTHER@
+
+#cmakedefine USE_GLEW @USE_GLEW@
diff --git a/src/common/event.cpp b/src/common/event.cpp
index 9af4691..6a5f4d3 100644
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -16,27 +16,12 @@
 
 // event.cpp
 
-#include "common/iman.h"
 #include "common/event.h"
-
-#include <string.h>
-
-
-Event::Event()
-{
-    event = EVENT_NULL;
-    param = 0;
-    axeX = 0.0f;
-    axeY = 0.0f;
-    axeZ = 0.0f;
-    keyState = 0;
-    rTime = 0.0f;
-}
+#include "common/iman.h"
 
 
-// Object's constructor.
 
-CEvent::CEvent(CInstanceManager* iMan)
+CEventQueue::CEventQueue(CInstanceManager* iMan)
 {
     m_iMan = iMan;
     m_iMan->AddInstance(CLASS_EVENT, this);
@@ -44,51 +29,38 @@ CEvent::CEvent(CInstanceManager* iMan)
     Flush();
 }
 
-// Object's destructor.
-
-CEvent::~CEvent()
+CEventQueue::~CEventQueue()
 {
 }
 
-
-// Empty the FIFO of events.
-
-void CEvent::Flush()
+void CEventQueue::Flush()
 {
     m_head = 0;
     m_tail = 0;
     m_total = 0;
 }
 
-// Produces an event.
-
-void CEvent::MakeEvent(Event &event, EventMsg msg)
-{
-    memset(&event, 0, sizeof(Event));
-    event.event = msg;
-}
-
-// Adds an event in the FIFO.
-
-bool CEvent::AddEvent(const Event &event)
+/** If the maximum size of queue has been reached, returns \c false.
+    Else, adds the event to the queue and returns \c true. */
+bool CEventQueue::AddEvent(const Event &event)
 {
-    if ( m_total >= MAXEVENT )  return false;
+    if ( m_total >= MAX_EVENT_QUEUE )  return false;
 
     m_fifo[m_head++] = event;
-    if ( m_head >= MAXEVENT )  m_head = 0;
+    if ( m_head >= MAX_EVENT_QUEUE )  m_head = 0;
     m_total ++;
 
     return true;
 }
 
-// Removes an event from the FIFO.
-
-bool CEvent::GetEvent(Event &event)
+/** If the queue is empty, returns \c false.
+    Else, gets the event from the front, puts it into \a event and returns \c true. */
+bool CEventQueue::GetEvent(Event &event)
 {
     if ( m_head == m_tail )  return false;
 
     event = m_fifo[m_tail++];
-    if ( m_tail >= MAXEVENT )  m_tail = 0;
+    if ( m_tail >= MAX_EVENT_QUEUE )  m_tail = 0;
     m_total --;
 
     return true;
diff --git a/src/common/event.h b/src/common/event.h
index 8174fab..0d9aa7c 100644
--- a/src/common/event.h
+++ b/src/common/event.h
@@ -19,40 +19,54 @@
 #pragma once
 
 
+#include "common/key.h"
 #include "math/point.h"
 
+#include <string.h>
 
-#if !defined (WM_XBUTTONDOWN)
-#define WM_XBUTTONDOWN      0x020B
-#define WM_XBUTTONUP        0x020C
-#define XBUTTON1            0x0001
-#define XBUTTON2            0x0002
-#endif
 
+class CInstanceManager;
 
+/**
+  \enum EventType
+  \brief Type of event message
+ */
+enum EventType
+{
 
-class CInstanceManager;
+// TODO: document the meaning of each value
 
+    //! Invalid event / no event
+    EVENT_NULL              = 0,
 
-const int MAXEVENT = 100;
+    //! Event sent on user or system quit request
+     EVENT_QUIT              = 1,
 
-// Events.
+    //? EVENT_FRAME             = 2,
 
-enum EventMsg
-{
-    EVENT_NULL              = 0,
+    //! Event sent after pressing a mouse button
+    EVENT_MOUSE_BUTTON_DOWN = 3,
+    //! Event sent after releasing a mouse button
+    EVENT_MOUSE_BUTTON_UP   = 4,
+    //! Event sent after moving the mouse
+    EVENT_MOUSE_MOVE        = 7,
+    //! Event sent after pressing a key
+    EVENT_KEY_DOWN          = 8,
+    //! Event sent after releasing a key
+    EVENT_KEY_UP            = 9,
 
-    EVENT_QUIT              = 1,
-    EVENT_FRAME             = 2,
-    EVENT_LBUTTONDOWN       = 3,
-    EVENT_RBUTTONDOWN       = 4,
-    EVENT_LBUTTONUP         = 5,
-    EVENT_RBUTTONUP         = 6,
-    EVENT_MOUSEMOVE         = 7,
-    EVENT_KEYDOWN           = 8,
-    EVENT_KEYUP             = 9,
-    EVENT_CHAR              = 10,
-    EVENT_FOCUS             = 11,
+    //! Event sent when application window loses/gains focus
+    EVENT_ACTIVE            = 10,
+
+    //? EVENT_CHAR              = 10,
+    //? EVENT_FOCUS             = 11,
+
+    //! Event sent after moving joystick axes
+    EVENT_JOY_AXIS          = 12,
+    //! Event sent after pressing a joystick button
+    EVENT_JOY_BUTTON_DOWN   = 13,
+    //! Event sent after releasing a joystick button
+    EVENT_JOY_BUTTON_UP     = 14,
 
     EVENT_UPDINTERFACE      = 20,
     EVENT_WIN               = 30,
@@ -525,60 +539,168 @@ enum EventMsg
     EVENT_STUDIO_STEP       = 2053,
 
     EVENT_USER              = 10000,
-    EVENT_FORCE_DWORD       = 0x7fffffff
+    EVENT_FORCE_LONG        = 0x7fffffff
+};
+
+
+/** \enum PressState
+    \brief State of key/mouse button */
+enum PressState
+{
+    STATE_PRESSED,
+    STATE_RELEASED
+};
+
+
+/** \struct KeyEventData
+    \brief Additional data for keyboard event */
+struct KeyEventData
+{
+    //! STATE_PRESSED or STATE_RELEASED */
+    PressState state;
+    //! Key symbol: KEY(...) macro value (from common/key.h)
+    unsigned int key;
+    //! Keyboard modifiers: a bitmask made of KEY_MOD(...) macro values (from common/key.h)
+    unsigned int mod;
+    //! Unicode character
+    unsigned int unicode;
+
+    KeyEventData()
+        : state(STATE_PRESSED), key(0), mod(0), unicode(0) {}
+};
+
+/** \struct MouseMotionEventData
+    \brief Additional data for mouse move event */
+struct MouseMoveEventData
+{
+    //! Current button state
+    unsigned char state;
+    //! Position of mouse in normalized coordinates (0..1)
+    Math::Point pos;
+
+    MouseMoveEventData()
+        : state(STATE_PRESSED) {}
+};
+
+/** \struct MouseButtonEventData
+    \brief Additional data mouse button event */
+struct MouseButtonEventData
+{
+    //! The mouse button index
+    unsigned char button;
+    //! STATE_PRESSED or STATE_RELEASED
+    PressState state;
+    //! Position of mouse in normalized coordinates (0..1)
+    Math::Point pos;
+
+    MouseButtonEventData()
+        : button(0), state(STATE_PRESSED) {}
+};
+
+/** \struct JoyAxisEventData
+    \brief Additional data for joystick axis event */
+struct JoyAxisEventData
+{
+    //! The joystick axis index
+    unsigned char axis;
+    //! The axis value (range: -32768 to 32767)
+    int value;
+
+    JoyAxisEventData()
+        : axis(axis), value(value) {}
+};
+
+/** \struct JoyButtonEventData
+    \brief Additional data for joystick button event */
+struct JoyButtonEventData
+{
+    //! The joystick button index
+    unsigned char button;
+    //! STATE_PRESSED or STATE_RELEASED
+    PressState state;
+
+    JoyButtonEventData()
+        : button(0), state(STATE_PRESSED) {}
+};
+
+/** \enum ActiveEventFlags
+    \brief Type of focus gained/lost */
+enum ActiveEventFlags
+{
+    //! Application window focus
+    ACTIVE_APP   = 0x01,
+    //! Input focus
+    ACTIVE_INPUT = 0x02,
+    //! Mouse focus
+    ACTIVE_MOUSE = 0x04
+
+};
+
+/** \struct ActiveEventData
+    \brief Additional data for active event */
+struct ActiveEventData
+{
+    //! Flags (bitmask of enum values ActiveEventFlags)
+    unsigned char flags = 0;
+    //! True if the focus was gained; false otherwise
+    bool gain;
+
+    ActiveEventData()
+        : flags(0), gain(false) {}
 };
 
+
+/**
+  \struct Event
+  \brief Event sent by system, interface or game
+
+  Event is described by its type (EventType) and the union
+  \a data contains additional data about the event.
+  Different members of the union are filled with different event types.
+  With some events, nothing is filled (it's zeroed out).
+  The union contains roughly the same information as SDL_Event struct
+  but packaged to independent structs and fields.
+ **/
 struct Event
 {
-    EventMsg    event;      // event (EVENT *)
-    long        param;      // parameter
-    Math::Point     pos;        // mouse position (0 .. 1)
-    float       axeX;       // control the X axis (-1 .. 1)
-    float       axeY;       // control of the Y axis (-1 .. 1)
-    float       axeZ;       // control the Z axis (-1 .. 1)
-    short       keyState;   // state of the keyboard (KS_ *)
-    float       rTime;      // relative time
-
-    Event();
+    //! Type of event (EVENT_*)
+    EventType type;
+
+    //! If true, the event was produced by system (SDL); else, it has come from user interface
+    bool systemEvent;
+
+    //! Additional data for EVENT_KEY_DOWN and EVENT_KEY_UP
+    KeyEventData key;
+    //! Additional data for EVENT_MOUSE_BUTTON_DOWN and EVENT_MOUSE_BUTTON_UP
+    MouseButtonEventData mouseButton;
+    //! Additional data for EVENT_MOUSE_MOVE
+    MouseMoveEventData mouseMove;
+    //! Additional data for EVENT_JOY
+    JoyAxisEventData joyAxis;
+    //! Additional data for EVENT_JOY_AXIS
+    JoyButtonEventData joyButton;
+    //! Additional data for EVENT_ACTIVE
+    ActiveEventData active;
+
+    //? long         param;      // parameter
+    //? Math::Point  pos;        // mouse position (0 .. 1)
+    //? float        axeX;       // control the X axis (-1 .. 1)
+    //? float        axeY;       // control of the Y axis (-1 .. 1)
+    //? float        axeZ;       // control the Z axis (-1 .. 1)
+    //? short        keyState;   // state of the keyboard (KS_ *)
+    //? float        rTime;      // relative time
+
+    Event(EventType aType = EVENT_NULL)
+        : type(aType), systemEvent(false) {}
 };
 
 
-const int VK_BUTTON1        = (0x100+1);    // joystick button 1
-const int VK_BUTTON2        = (0x100+2);    // joystick button 2
-const int VK_BUTTON3        = (0x100+3);    // joystick button 3
-const int VK_BUTTON4        = (0x100+4);    // joystick button 4
-const int VK_BUTTON5        = (0x100+5);    // joystick button 5
-const int VK_BUTTON6        = (0x100+6);    // joystick button 6
-const int VK_BUTTON7        = (0x100+7);    // joystick button 7
-const int VK_BUTTON8        = (0x100+8);    // joystick button 8
-const int VK_BUTTON9        = (0x100+9);    // joystick button 9
-const int VK_BUTTON10       = (0x100+10);   // joystick button 10
-const int VK_BUTTON11       = (0x100+11);   // joystick button 11
-const int VK_BUTTON12       = (0x100+12);   // joystick button 12
-const int VK_BUTTON13       = (0x100+13);   // joystick button 13
-const int VK_BUTTON14       = (0x100+14);   // joystick button 14
-const int VK_BUTTON15       = (0x100+15);   // joystick button 15
-const int VK_BUTTON16       = (0x100+16);   // joystick button 16
-const int VK_BUTTON17       = (0x100+17);   // joystick button 17
-const int VK_BUTTON18       = (0x100+18);   // joystick button 18
-const int VK_BUTTON19       = (0x100+19);   // joystick button 19
-const int VK_BUTTON20       = (0x100+20);   // joystick button 20
-const int VK_BUTTON21       = (0x100+21);   // joystick button 21
-const int VK_BUTTON22       = (0x100+22);   // joystick button 22
-const int VK_BUTTON23       = (0x100+23);   // joystick button 23
-const int VK_BUTTON24       = (0x100+24);   // joystick button 24
-const int VK_BUTTON25       = (0x100+25);   // joystick button 25
-const int VK_BUTTON26       = (0x100+26);   // joystick button 26
-const int VK_BUTTON27       = (0x100+27);   // joystick button 27
-const int VK_BUTTON28       = (0x100+28);   // joystick button 28
-const int VK_BUTTON29       = (0x100+29);   // joystick button 29
-const int VK_BUTTON30       = (0x100+30);   // joystick button 30
-const int VK_BUTTON31       = (0x100+31);   // joystick button 31
-const int VK_BUTTON32       = (0x100+32);   // joystick button 32
-
-const int VK_WHEELUP        = (0x200+1);    // Mousewheel up
-const int VK_WHEELDOWN      = (0x200+2);    // Mousewheel down
+/**
+ \enum KeyRank
+ \brief Slots for key assignment of user controls
+ */
 
+// TODO: move to global.h ?
 
 enum KeyRank
 {
@@ -609,25 +731,37 @@ enum KeyRank
 };
 
 
+/**
+  \class CEventQueue
+  \brief Global event queue
 
-class CEvent
+  Provides an interface to a global FIFO queue with events (both system- and user-generated).
+  The queue has a fixed maximum size but it should not be a problem.
+ */
+class CEventQueue
 {
 public:
-    CEvent(CInstanceManager* iMan);
-    ~CEvent();
+    //! Constant maximum size of queue
+    static const int MAX_EVENT_QUEUE = 100;
 
+public:
+    //! Object's constructor
+    CEventQueue(CInstanceManager* iMan);
+    //! Object's destructor
+    ~CEventQueue();
+
+    //! Empties the FIFO of events
     void    Flush();
-    void    MakeEvent(Event &event, EventMsg msg);
+    //! Adds an event to the queue
     bool    AddEvent(const Event &event);
     bool    GetEvent(Event &event);
 
 protected:
     CInstanceManager* m_iMan;
-
-    Event   m_fifo[MAXEVENT];
-    int     m_head;
-    int     m_tail;
-    int     m_total;
+    Event        m_fifo[MAX_EVENT_QUEUE];
+    int          m_head;
+    int          m_tail;
+    int          m_total;
 };
 
 
diff --git a/src/common/image.cpp b/src/common/image.cpp
new file mode 100644
index 0000000..3d64377
--- /dev/null
+++ b/src/common/image.cpp
@@ -0,0 +1,221 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// image.cpp
+
+#include "image.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <png.h>
+
+
+/* <---------------------------------------------------------------> */
+
+/* The following code is from savesurf program by Angelo "Encelo" Theodorou
+   Source: http://encelo.netsons.org/old/sdl/
+   The code was refactored and modified slightly to fit the needs.
+   The copyright information below is kept unchanged. */
+
+
+/* SaveSurf: an example on how to save a SDLSurface in PNG
+   Copyright (C) 2006 Angelo "Encelo" Theodorou
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   NOTE:
+
+   This program is part of "Mars, Land of No Mercy" SDL examples,
+   you can find other examples on http://marsnomercy.org
+*/
+
+std::string PNG_ERROR = "";
+
+void PNGUserError(png_structp ctx, png_const_charp str)
+{
+    PNG_ERROR = std::string(str);
+}
+
+int PNGColortypeFromSurface(SDL_Surface *surface)
+{
+    int colortype = PNG_COLOR_MASK_COLOR; /* grayscale not supported */
+
+    if (surface->format->palette)
+        colortype |= PNG_COLOR_MASK_PALETTE;
+    else if (surface->format->Amask)
+        colortype |= PNG_COLOR_MASK_ALPHA;
+
+    return colortype;
+}
+
+bool PNGSaveSurface(const char *filename, SDL_Surface *surf)
+{
+    FILE *fp;
+    png_structp png_ptr;
+    png_infop info_ptr;
+    int i, colortype;
+    png_bytep *row_pointers;
+
+    PNG_ERROR = "";
+
+    /* Opening output file */
+    fp = fopen(filename, "wb");
+    if (fp == NULL)
+    {
+        PNG_ERROR = std::string("Could not open file '") + std::string(filename) + std::string("' for saving");
+        return false;
+    }
+
+    /* Initializing png structures and callbacks */
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, PNGUserError, NULL);
+    if (png_ptr == NULL)
+        return false;
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (info_ptr == NULL)
+    {
+        png_destroy_write_struct(&png_ptr, static_cast<png_infopp>(NULL));
+        PNG_ERROR = "png_create_info_struct() error!";
+        return false;
+    }
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        fclose(fp);
+        return false;
+    }
+
+    png_init_io(png_ptr, fp);
+
+    colortype = PNGColortypeFromSurface(surf);
+    png_set_IHDR(png_ptr, info_ptr, surf->w, surf->h, 8, colortype, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+    /* Writing the image */
+    png_write_info(png_ptr, info_ptr);
+    png_set_packing(png_ptr);
+
+    row_pointers = static_cast<png_bytep*>( malloc(sizeof(png_bytep)*surf->h) );
+    for (i = 0; i < surf->h; i++)
+        row_pointers[i] = static_cast<png_bytep>( static_cast<Uint8 *>(surf->pixels) ) + i*surf->pitch;
+    png_write_image(png_ptr, row_pointers);
+    png_write_end(png_ptr, info_ptr);
+
+    /* Cleaning out... */
+    free(row_pointers);
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+    fclose(fp);
+
+    return true;
+}
+
+/* <---------------------------------------------------------------> */
+
+
+CImage::CImage()
+{
+    m_data = NULL;
+}
+
+CImage::~CImage()
+{
+    Free();
+}
+
+bool CImage::IsEmpty()
+{
+    return m_data == NULL;
+}
+
+void CImage::Free()
+{
+    if (m_data != NULL)
+    {
+        if (m_data->surface != NULL)
+        {
+            SDL_FreeSurface(m_data->surface);
+            m_data->surface = NULL;
+        }
+        delete m_data;
+        m_data = NULL;
+    }
+}
+
+ImageData* CImage::GetData()
+{
+    return m_data;
+}
+
+std::string CImage::GetError()
+{
+    return m_error;
+}
+
+bool CImage::Load(const std::string& fileName)
+{
+    if (! IsEmpty() )
+        Free();
+
+    m_data = new ImageData();
+
+    m_error = "";
+
+    m_data->surface = IMG_Load(fileName.c_str());
+    if (m_data->surface == NULL)
+    {
+        delete m_data;
+        m_data = NULL;
+
+        m_error = std::string(IMG_GetError());
+        return false;
+    }
+
+    return true;
+}
+
+bool CImage::SavePNG(const std::string& fileName)
+{
+    if (IsEmpty())
+    {
+        m_error = "Empty image!";
+        return false;
+    }
+
+    m_error = "";
+
+    if (! PNGSaveSurface(fileName.c_str(), m_data->surface) )
+    {
+        m_error = PNG_ERROR;
+        return false;
+    }
+
+    return true;
+}
diff --git a/src/common/image.h b/src/common/image.h
new file mode 100644
index 0000000..4d86d31
--- /dev/null
+++ b/src/common/image.h
@@ -0,0 +1,84 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// image.h
+
+#pragma once
+
+
+#include <stddef.h>
+#include <string>
+
+
+// Forward declaration without including headers to clutter the code
+struct SDL_Surface;
+
+//! Implementation-specific image data
+/** Note that the struct has no destructor and the surface
+    will not be freed at destruction. */
+struct ImageData
+{
+    //! SDL surface with image data
+    SDL_Surface* surface;
+
+    ImageData() { surface = NULL; }
+};
+
+/**
+  \class CImage
+  \brief Image loaded from file
+
+  Wrapper around SDL_Image library to load images. Also contains
+  function for saving images to PNG.
+  */
+class CImage
+{
+private:
+    //! Blocked!
+    CImage(const CImage &other) {}
+    //! Blocked!
+    void operator=(const CImage &other) {}
+
+public:
+    //! Constructs empty image (with NULL data)
+    CImage();
+    //! Destroys image, calling Free()
+    virtual ~CImage();
+
+    //! Frees the allocated image data
+    void Free();
+
+    //! Returns whether the image is empty (has NULL data)
+    bool IsEmpty();
+
+    //! Returns the image data; if empty - returns NULL
+    ImageData* GetData();
+
+    //! Loads an image from the specified file
+    bool Load(const std::string &fileName);
+
+    //! Saves the image to the specified file in PNG format
+    bool SavePNG(const std::string &fileName);
+
+    //! Returns the last error
+    std::string GetError();
+
+private:
+    //! Last encountered error
+    std::string m_error;
+    //! Image data
+    ImageData* m_data;
+};
diff --git a/src/common/iman.cpp b/src/common/iman.cpp
index 9e94f24..4c70cde 100644
--- a/src/common/iman.cpp
+++ b/src/common/iman.cpp
@@ -108,7 +108,7 @@ bool CInstanceManager::AddInstance(ClassType classType, void* pointer, int max)
 
     if ( m_table[classType].classPointer == 0 )
     {
-        m_table[classType].classPointer = (void**)malloc(max*sizeof(void*));
+        m_table[classType].classPointer = static_cast<void**>( malloc(max*sizeof(void*)) );
         m_table[classType].totalPossible = max;
         m_table[classType].totalUsed     = 0;
     }
diff --git a/src/common/ioutils.h b/src/common/ioutils.h
new file mode 100644
index 0000000..a7bd044
--- /dev/null
+++ b/src/common/ioutils.h
@@ -0,0 +1,85 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// ioutils.h
+
+#pragma once
+
+
+#include <iostream>
+
+#include <cstring>
+
+namespace IOUtils {
+
+//! Writes a binary number to output stream
+/**
+  \c T is a numeric type (int, unsigned int, etc.)
+  \c N is number of bytes
+  Write order is little-endian */
+template<int N, typename T>
+void WriteBinary(T value, std::ostream &ostr)
+{
+    for (int i = 0; i < N; ++i)
+    {
+        unsigned char byte = (value >> (i*8)) & 0xFF;
+        ostr.write(reinterpret_cast<char*>(&byte), 1);
+    }
+}
+
+//! Reads a binary number from input stream
+/**
+  \c T is a numeric type (int, unsigned int, etc.)
+  \c N is number of bytes
+  Read order is little-endian */
+template<int N, typename T>
+T ReadBinary(std::istream &istr)
+{
+    T value = 0;
+    for (int i = 0; i < N; ++i)
+    {
+        unsigned char byte = 0;
+        istr.read(reinterpret_cast<char*>(&byte), 1);
+        value |= byte << (i*8);
+    }
+    return value;
+}
+
+//! Writes a binary 32-bit float to output stream
+/**
+  Write order is little-endian
+  NOTE: code is probably not portable as there are platforms with other float representations. */
+void WriteBinaryFloat(float value, std::ostream &ostr)
+{
+    union { float fValue; unsigned int iValue; } u;
+    memset(&u, 0, sizeof(u));
+    u.fValue = value;
+    IOUtils::WriteBinary<4, unsigned int>(u.iValue, ostr);
+}
+
+//! Reads a binary 32-bit float from input stream
+/**
+  Read order is little-endian
+  NOTE: code is probably not portable as there are platforms with other float representations. */
+float ReadBinaryFloat(std::istream &istr)
+{
+    union { float fValue; unsigned int iValue; } u;
+    memset(&u, 0, sizeof(u));
+    u.iValue = IOUtils::ReadBinary<4, unsigned int>(istr);
+    return u.fValue;
+}
+
+}; // namespace IOUtils
diff --git a/src/graphics/common/device.h b/src/common/key.h
index 5900570..de31c09 100644
--- a/src/graphics/common/device.h
+++ b/src/common/key.h
@@ -1,5 +1,4 @@
 // * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
 // * Copyright (C) 2012, Polish Portal of Colobot (PPC)
 // *
 // * This program is free software: you can redistribute it and/or modify
@@ -15,38 +14,21 @@
 // * You should have received a copy of the GNU General Public License
 // * along with this program. If not, see  http://www.gnu.org/licenses/.
 
-// device.h
+// key.h
 
 #pragma once
 
 
-namespace Gfx {
+#include "SDL/SDL_keysym.h"
 
-struct DeviceConfig
-{
-    //! Screen width
-    int width;
-    //! Screen height
-    int height;
-    //! Bits per pixel
-    int bpp;
-    //! Full screen
-    bool fullScreen;
-    //! Resizeable window
-    bool resizeable;
-    //! Hardware acceleration
-    bool hardwareAccel;
-    //! Double buffering
-    bool doubleBuf;
-    //! No window frame (also set with full screen)
-    bool noFrame;
+/* Key definitions are specially defined here so that it is clear in other parts of the code
+  that these are used. It is to avoid having SDL-related enum values or #defines lying around
+  unchecked. With this approach it will be easier to maintain the code later on. */
 
-    DeviceConfig();
-};
+// Key symbol defined as concatenation to SDLK_...
+// If need arises, it can be changed to custom function or anything else
+#define KEY(x) SDLK_ ## x
 
-class CDevice
-{
-  // TODO
-};
-
-}; // namespace Gfx
+// Key modifier defined as concatenation to KMOD_...
+// If need arises, it can be changed to custom function or anything else
+#define KEY_MOD(x) KMOD_ ## x
diff --git a/src/common/logger.cpp b/src/common/logger.cpp
index acd1d27..f24726e 100644
--- a/src/common/logger.cpp
+++ b/src/common/logger.cpp
@@ -18,6 +18,8 @@
 
 #include <common/logger.h>
 
+#include <stdio.h>
+
 
 template<> CLogger* CSingleton<CLogger>::mInstance = 0;
 
@@ -53,7 +55,7 @@ void CLogger::Log(LogType type, const char *str, va_list args)
 {
     if (type < mLogLevel)
         return;
-    
+
     switch (type) {
         case LOG_WARN: fprintf(IsOpened() ? mFile : stderr, "[WARN]: "); break;
         case LOG_INFO: fprintf(IsOpened() ? mFile : stderr, "[INFO]: "); break;
diff --git a/src/common/logger.h b/src/common/logger.h
index 3a48210..2d0ab3e 100644
--- a/src/common/logger.h
+++ b/src/common/logger.h
@@ -50,7 +50,7 @@ enum LogType
 *
 * @brief Class for loggin information to file or console
 *
-*/ 
+*/
 class CLogger : public CSingleton<CLogger>
 {
     public:
diff --git a/src/common/misc.h b/src/common/misc.h
index e863b69..4853856 100644
--- a/src/common/misc.h
+++ b/src/common/misc.h
@@ -219,7 +219,7 @@ const int KS_NUMMINUS       = (1<<15);
 
 // Procedures.
 
-extern EventMsg GetUniqueEventMsg();
+extern EventType GetUniqueEventType();
 
 extern char RetNoAccent(char letter);
 extern char RetToUpper(char letter);
diff --git a/src/common/modfile.cpp b/src/common/modfile.cpp
deleted file mode 100644
index fc202b7..0000000
--- a/src/common/modfile.cpp
+++ /dev/null
@@ -1,695 +0,0 @@
-// * 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  http://www.gnu.org/licenses/.
-
-// modfile.cpp
-
-
-#include <windows.h>
-#include <stdio.h>
-#include <d3d.h>
-
-#include "common/struct.h"
-#include "math/geometry.h"
-#include "old/d3dengine.h"
-#include "old/d3dmath.h"
-#include "common/language.h"
-#include "common/event.h"
-#include "common/misc.h"
-#include "common/iman.h"
-#include "old/math3d.h"
-#include "common/modfile.h"
-
-
-
-const int MAX_VERTICES = 2000;
-
-
-
-// Object's constructor.
-
-CModFile::CModFile(CInstanceManager* iMan)
-{
-    m_iMan = iMan;
-
-    m_engine = (CD3DEngine*)m_iMan->SearchInstance(CLASS_ENGINE);
-
-    m_triangleUsed = 0;
-    m_triangleTable = (ModelTriangle*)malloc(sizeof(ModelTriangle)*MAX_VERTICES);
-    ZeroMemory(m_triangleTable, sizeof(ModelTriangle)*MAX_VERTICES);
-}
-
-// Object's destructor.
-
-CModFile::~CModFile()
-{
-    free(m_triangleTable);
-}
-
-
-
-
-// Creates a triangle in the internal structure.
-
-bool CModFile::CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3,
-                              float min, float max)
-{
-    Math::Vector    n;
-    int         i;
-
-    if ( m_triangleUsed >= MAX_VERTICES )
-    {
-        OutputDebugString("ERROR: CreateTriangle::Too many triangles\n");
-        return false;
-    }
-
-    i = m_triangleUsed++;
-
-    ZeroMemory(&m_triangleTable[i], sizeof(ModelTriangle));
-
-    m_triangleTable[i].bUsed = true;
-    m_triangleTable[i].bSelect = false;
-
-    n = Math::NormalToPlane(p3, p2, p1);
-    m_triangleTable[i].p1 = D3DVERTEX2( p1, n);
-    m_triangleTable[i].p2 = D3DVERTEX2( p2, n);
-    m_triangleTable[i].p3 = D3DVERTEX2( p3, n);
-
-    m_triangleTable[i].material.diffuse.r = 1.0f;
-    m_triangleTable[i].material.diffuse.g = 1.0f;
-    m_triangleTable[i].material.diffuse.b = 1.0f;  // white
-    m_triangleTable[i].material.ambient.r = 0.5f;
-    m_triangleTable[i].material.ambient.g = 0.5f;
-    m_triangleTable[i].material.ambient.b = 0.5f;
-
-    m_triangleTable[i].min = min;
-    m_triangleTable[i].max = max;
-
-    return true;
-}
-
-// Reads a DXF file.
-
-bool CModFile::ReadDXF(char *filename, float min, float max)
-{
-    FILE*       file = NULL;
-    char        line[100];
-    int         command, rankSommet, nbSommet, nbFace;
-    Math::Vector    table[MAX_VERTICES];
-    bool        bWaitNbSommet;
-    bool        bWaitNbFace;
-    bool        bWaitSommetX;
-    bool        bWaitSommetY;
-    bool        bWaitSommetZ;
-    bool        bWaitFaceX;
-    bool        bWaitFaceY;
-    bool        bWaitFaceZ;
-    float       x,y,z;
-    int         p1,p2,p3;
-
-    file = fopen(filename, "r");
-    if ( file == NULL )  return false;
-
-    m_triangleUsed = 0;
-
-    rankSommet = 0;
-    bWaitNbSommet = false;
-    bWaitNbFace   = false;
-    bWaitSommetX  = false;
-    bWaitSommetY  = false;
-    bWaitSommetZ  = false;
-    bWaitFaceX    = false;
-    bWaitFaceY    = false;
-    bWaitFaceZ    = false;
-
-    while ( fgets(line, 100, file) != NULL )
-    {
-        sscanf(line, "%d", &command);
-        if ( fgets(line, 100, file) == NULL )  break;
-
-        if ( command == 66 )
-        {
-            bWaitNbSommet = true;
-        }
-
-        if ( command == 71 && bWaitNbSommet )
-        {
-            bWaitNbSommet = false;
-            sscanf(line, "%d", &nbSommet);
-            if ( nbSommet > MAX_VERTICES )  nbSommet = MAX_VERTICES;
-            rankSommet = 0;
-            bWaitNbFace = true;
-
-//?         sprintf(s, "Waiting for %d sommets\n", nbSommet);
-//?         OutputDebugString(s);
-        }
-
-        if ( command == 72 && bWaitNbFace )
-        {
-            bWaitNbFace = false;
-            sscanf(line, "%d", &nbFace);
-            bWaitSommetX = true;
-
-//?         sprintf(s, "Waiting for %d faces\n", nbFace);
-//?         OutputDebugString(s);
-        }
-
-        if ( command == 10 && bWaitSommetX )
-        {
-            bWaitSommetX = false;
-            sscanf(line, "%f", &x);
-            bWaitSommetY = true;
-        }
-
-        if ( command == 20 && bWaitSommetY )
-        {
-            bWaitSommetY = false;
-            sscanf(line, "%f", &y);
-            bWaitSommetZ = true;
-        }
-
-        if ( command == 30 && bWaitSommetZ )
-        {
-            bWaitSommetZ = false;
-            sscanf(line, "%f", &z);
-
-            nbSommet --;
-            if ( nbSommet >= 0 )
-            {
-                Math::Vector p(x,z,y);  // permutation of Y and Z!
-                table[rankSommet++] = p;
-                bWaitSommetX = true;
-
-//?             sprintf(s, "Sommet[%d]=%f;%f;%f\n", rankSommet, p.x,p.y,p.z);
-//?             OutputDebugString(s);
-            }
-            else
-            {
-                bWaitFaceX = true;
-            }
-        }
-
-        if ( command == 71 && bWaitFaceX )
-        {
-            bWaitFaceX = false;
-            sscanf(line, "%d", &p1);
-            if ( p1 < 0 )  p1 = -p1;
-            bWaitFaceY = true;
-        }
-
-        if ( command == 72 && bWaitFaceY )
-        {
-            bWaitFaceY = false;
-            sscanf(line, "%d", &p2);
-            if ( p2 < 0 )  p2 = -p2;
-            bWaitFaceZ = true;
-        }
-
-        if ( command == 73 && bWaitFaceZ )
-        {
-            bWaitFaceZ = false;
-            sscanf(line, "%d", &p3);
-            if ( p3 < 0 )  p3 = -p3;
-
-            nbFace --;
-            if ( nbFace >= 0 )
-            {
-                CreateTriangle( table[p3-1], table[p2-1], table[p1-1], min,max );
-                bWaitFaceX = true;
-
-//?             sprintf(s, "Face=%d;%d;%d\n", p1,p2,p3);
-//?             OutputDebugString(s);
-            }
-        }
-
-    }
-
-    fclose(file);
-    return true;
-}
-
-
-
-struct InfoMOD
-{
-    int     rev;
-    int     vers;
-    int     total;
-    int     reserve[10];
-};
-
-
-// Change nom.bmp to nom.tga
-
-void ChangeBMPtoTGA(char *filename)
-{
-    char*   p;
-
-    p = strstr(filename, ".bmp");
-    if ( p != 0 )  strcpy(p, ".tga");
-}
-
-
-// Reads a MOD file.
-
-bool CModFile::AddModel(char *filename, int first, bool bEdit, bool bMeta)
-{
-    FILE*       file;
-    InfoMOD     info;
-    float       limit[2];
-    int         i, nb, err;
-    char*       p;
-
-    if ( m_engine->RetDebugMode() )
-    {
-        bMeta = false;
-    }
-
-    if ( bMeta )
-    {
-        p = strchr(filename, '\\');
-        if ( p == 0 )
-        {
-#if _SCHOOL
-            err = g_metafile.Open("ceebot2.dat", filename);
-#else
-            err = g_metafile.Open("colobot2.dat", filename);
-#endif
-        }
-        else
-        {
-#if _SCHOOL
-            err = g_metafile.Open("ceebot2.dat", p+1);
-#else
-            err = g_metafile.Open("colobot2.dat", p+1);
-#endif
-        }
-        if ( err != 0 )  bMeta = false;
-    }
-    if ( !bMeta )
-    {
-        file = fopen(filename, "rb");
-        if ( file == NULL )  return false;
-    }
-
-    if ( bMeta )
-    {
-        g_metafile.Read(&info, sizeof(InfoMOD));
-    }
-    else
-    {
-        fread(&info, sizeof(InfoMOD), 1, file);
-    }
-    nb = info.total;
-    m_triangleUsed += nb;
-
-    if ( info.rev == 1 && info.vers == 0 )
-    {
-        OldModelTriangle1   old;
-
-        for ( i=first ; i<m_triangleUsed ; i++ )
-        {
-            if ( bMeta )
-            {
-                g_metafile.Read(&old, sizeof(OldModelTriangle1));
-            }
-            else
-            {
-                fread(&old, sizeof(OldModelTriangle1), 1, file);
-            }
-
-            ZeroMemory(&m_triangleTable[i], sizeof(ModelTriangle));
-            m_triangleTable[i].bUsed = old.bUsed;
-            m_triangleTable[i].bSelect = old.bSelect;
-
-            m_triangleTable[i].p1.x = old.p1.x;
-            m_triangleTable[i].p1.y = old.p1.y;
-            m_triangleTable[i].p1.z = old.p1.z;
-            m_triangleTable[i].p1.nx = old.p1.nx;
-            m_triangleTable[i].p1.ny = old.p1.ny;
-            m_triangleTable[i].p1.nz = old.p1.nz;
-            m_triangleTable[i].p1.tu = old.p1.tu;
-            m_triangleTable[i].p1.tv = old.p1.tv;
-
-            m_triangleTable[i].p2.x = old.p2.x;
-            m_triangleTable[i].p2.y = old.p2.y;
-            m_triangleTable[i].p2.z = old.p2.z;
-            m_triangleTable[i].p2.nx = old.p2.nx;
-            m_triangleTable[i].p2.ny = old.p2.ny;
-            m_triangleTable[i].p2.nz = old.p2.nz;
-            m_triangleTable[i].p2.tu = old.p2.tu;
-            m_triangleTable[i].p2.tv = old.p2.tv;
-
-            m_triangleTable[i].p3.x = old.p3.x;
-            m_triangleTable[i].p3.y = old.p3.y;
-            m_triangleTable[i].p3.z = old.p3.z;
-            m_triangleTable[i].p3.nx = old.p3.nx;
-            m_triangleTable[i].p3.ny = old.p3.ny;
-            m_triangleTable[i].p3.nz = old.p3.nz;
-            m_triangleTable[i].p3.tu = old.p3.tu;
-            m_triangleTable[i].p3.tv = old.p3.tv;
-
-            m_triangleTable[i].material = old.material;
-            strcpy(m_triangleTable[i].texName, old.texName);
-            m_triangleTable[i].min = old.min;
-            m_triangleTable[i].max = old.max;
-        }
-    }
-    else if ( info.rev == 1 && info.vers == 1 )
-    {
-        OldModelTriangle2   old;
-
-        for ( i=first ; i<m_triangleUsed ; i++ )
-        {
-            if ( bMeta )
-            {
-                g_metafile.Read(&old, sizeof(OldModelTriangle2));
-            }
-            else
-            {
-                fread(&old, sizeof(OldModelTriangle2), 1, file);
-            }
-
-            ZeroMemory(&m_triangleTable[i], sizeof(ModelTriangle));
-            m_triangleTable[i].bUsed = old.bUsed;
-            m_triangleTable[i].bSelect = old.bSelect;
-
-            m_triangleTable[i].p1.x = old.p1.x;
-            m_triangleTable[i].p1.y = old.p1.y;
-            m_triangleTable[i].p1.z = old.p1.z;
-            m_triangleTable[i].p1.nx = old.p1.nx;
-            m_triangleTable[i].p1.ny = old.p1.ny;
-            m_triangleTable[i].p1.nz = old.p1.nz;
-            m_triangleTable[i].p1.tu = old.p1.tu;
-            m_triangleTable[i].p1.tv = old.p1.tv;
-
-            m_triangleTable[i].p2.x = old.p2.x;
-            m_triangleTable[i].p2.y = old.p2.y;
-            m_triangleTable[i].p2.z = old.p2.z;
-            m_triangleTable[i].p2.nx = old.p2.nx;
-            m_triangleTable[i].p2.ny = old.p2.ny;
-            m_triangleTable[i].p2.nz = old.p2.nz;
-            m_triangleTable[i].p2.tu = old.p2.tu;
-            m_triangleTable[i].p2.tv = old.p2.tv;
-
-            m_triangleTable[i].p3.x = old.p3.x;
-            m_triangleTable[i].p3.y = old.p3.y;
-            m_triangleTable[i].p3.z = old.p3.z;
-            m_triangleTable[i].p3.nx = old.p3.nx;
-            m_triangleTable[i].p3.ny = old.p3.ny;
-            m_triangleTable[i].p3.nz = old.p3.nz;
-            m_triangleTable[i].p3.tu = old.p3.tu;
-            m_triangleTable[i].p3.tv = old.p3.tv;
-
-            m_triangleTable[i].material = old.material;
-            strcpy(m_triangleTable[i].texName, old.texName);
-            m_triangleTable[i].min = old.min;
-            m_triangleTable[i].max = old.max;
-            m_triangleTable[i].state = old.state;
-            m_triangleTable[i].reserve2 = old.reserve2;
-            m_triangleTable[i].reserve3 = old.reserve3;
-            m_triangleTable[i].reserve4 = old.reserve4;
-        }
-    }
-    else
-    {
-        if ( bMeta )
-        {
-            g_metafile.Read(m_triangleTable+first, sizeof(ModelTriangle)*nb);
-        }
-        else
-        {
-            fread(m_triangleTable+first, sizeof(ModelTriangle), nb, file);
-        }
-    }
-
-    for ( i=first ; i<m_triangleUsed ; i++ )
-    {
-        ChangeBMPtoTGA(m_triangleTable[i].texName);
-    }
-
-    if ( !bEdit )
-    {
-        limit[0] = m_engine->RetLimitLOD(0);  // frontier AB as config
-        limit[1] = m_engine->RetLimitLOD(1);  // frontier BC as config
-
-        // Standard frontiers -> config.
-        for ( i=first ; i<m_triangleUsed ; i++ )
-        {
-            if ( m_triangleTable[i].min == 0.0f &&
-                 m_triangleTable[i].max == 100.0f )  // resolution A ?
-            {
-                m_triangleTable[i].max = limit[0];
-            }
-            else if ( m_triangleTable[i].min == 100.0f &&
-                      m_triangleTable[i].max == 200.0f )  // resolution B ?
-            {
-                m_triangleTable[i].min = limit[0];
-                m_triangleTable[i].max = limit[1];
-            }
-            else if ( m_triangleTable[i].min == 200.0f &&
-                      m_triangleTable[i].max == 1000000.0f )  // resolution C ?
-            {
-                m_triangleTable[i].min = limit[1];
-            }
-        }
-    }
-
-    if ( bMeta )
-    {
-        g_metafile.Close();
-    }
-    else
-    {
-        fclose(file);
-    }
-    return true;
-}
-
-// Reads a MOD file.
-
-bool CModFile::ReadModel(char *filename, bool bEdit, bool bMeta)
-{
-    m_triangleUsed = 0;
-    return AddModel(filename, 0, bEdit, bMeta);
-}
-
-
-// Writes a MOD file.
-
-bool CModFile::WriteModel(char *filename)
-{
-    FILE*       file;
-    InfoMOD     info;
-
-    if ( m_triangleUsed == 0 )  return false;
-
-    file = fopen(filename, "wb");
-    if ( file == NULL )  return false;
-
-    ZeroMemory(&info, sizeof(InfoMOD));
-    info.rev   = 1;
-    info.vers  = 2;
-    info.total = m_triangleUsed;
-    fwrite(&info, sizeof(InfoMOD), 1, file);
-
-    fwrite(m_triangleTable, sizeof(ModelTriangle), m_triangleUsed, file);
-
-    fclose(file);
-    return true;
-}
-
-
-// Creates the object in the 3D engine.
-
-bool CModFile::CreateEngineObject(int objRank, int addState)
-{
-#if 0
-    char    texName2[20];
-    int     texNum, i, state;
-
-    for ( i=0 ; i<m_triangleUsed ; i++ )
-    {
-        if ( !m_triangleTable[i].bUsed )  continue;
-
-        state = m_triangleTable[i].state;
-        texName2[0] = 0;
-
-        if ( m_triangleTable[i].texNum2 != 0 )
-        {
-            if ( m_triangleTable[i].texNum2 == 1 )
-            {
-                texNum = m_engine->RetSecondTexture();
-            }
-            else
-            {
-                texNum = m_triangleTable[i].texNum2;
-            }
-
-            if ( texNum >= 1 && texNum <= 10 )
-            {
-                state = m_triangleTable[i].state|D3DSTATEDUALb;
-            }
-            if ( texNum >= 11 && texNum <= 20 )
-            {
-                state = m_triangleTable[i].state|D3DSTATEDUALw;
-            }
-            sprintf(texName2, "dirty%.2d.bmp", texNum);
-        }
-
-        m_engine->AddTriangle(objRank, &m_triangleTable[i].p1, 3,
-                              m_triangleTable[i].material,
-                              state+addState,
-                              m_triangleTable[i].texName, texName2,
-                              m_triangleTable[i].min,
-                              m_triangleTable[i].max, false);
-    }
-    return true;
-#else
-    char    texName1[20];
-    char    texName2[20];
-    int     texNum, i, state;
-
-    for ( i=0 ; i<m_triangleUsed ; i++ )
-    {
-        if ( !m_triangleTable[i].bUsed )  continue;
-
-        state = m_triangleTable[i].state;
-        strcpy(texName1, m_triangleTable[i].texName);
-        texName2[0] = 0;
-
-        if ( strcmp(texName1, "plant.tga") == 0 )
-        {
-            state |= D3DSTATEALPHA;
-        }
-
-        if ( m_triangleTable[i].texNum2 != 0 )
-        {
-            if ( m_triangleTable[i].texNum2 == 1 )
-            {
-                texNum = m_engine->RetSecondTexture();
-            }
-            else
-            {
-                texNum = m_triangleTable[i].texNum2;
-            }
-
-            if ( texNum >= 1 && texNum <= 10 )
-            {
-                state |= D3DSTATEDUALb;
-            }
-            if ( texNum >= 11 && texNum <= 20 )
-            {
-                state |= D3DSTATEDUALw;
-            }
-            sprintf(texName2, "dirty%.2d.tga", texNum);
-        }
-
-        m_engine->AddTriangle(objRank, &m_triangleTable[i].p1, 3,
-                              m_triangleTable[i].material,
-                              state+addState,
-                              texName1, texName2,
-                              m_triangleTable[i].min,
-                              m_triangleTable[i].max, false);
-    }
-    return true;
-#endif
-}
-
-
-// Performs a mirror according to Z.
-
-void CModFile::Mirror()
-{
-    D3DVERTEX2  t;
-    int         i;
-
-    for ( i=0 ; i<m_triangleUsed ; i++ )
-    {
-        t                     = m_triangleTable[i].p1;
-        m_triangleTable[i].p1 = m_triangleTable[i].p2;
-        m_triangleTable[i].p2 = t;
-
-        m_triangleTable[i].p1.z = -m_triangleTable[i].p1.z;
-        m_triangleTable[i].p2.z = -m_triangleTable[i].p2.z;
-        m_triangleTable[i].p3.z = -m_triangleTable[i].p3.z;
-
-        m_triangleTable[i].p1.nz = -m_triangleTable[i].p1.nz;
-        m_triangleTable[i].p2.nz = -m_triangleTable[i].p2.nz;
-        m_triangleTable[i].p3.nz = -m_triangleTable[i].p3.nz;
-    }
-}
-
-
-// Returns the pointer to the list of triangles.
-
-void CModFile::SetTriangleUsed(int total)
-{
-    m_triangleUsed = total;
-}
-
-int CModFile::RetTriangleUsed()
-{
-    return m_triangleUsed;
-}
-
-int CModFile::RetTriangleMax()
-{
-    return MAX_VERTICES;
-}
-
-ModelTriangle* CModFile::RetTriangleList()
-{
-    return m_triangleTable;
-}
-
-
-// Returns the height according to a position (x - z);
-
-float CModFile::RetHeight(Math::Vector pos)
-{
-    Math::Vector    p1, p2, p3;
-    float       limit;
-    int         i;
-
-    limit = 5.0f;
-
-    for ( i=0 ; i<m_triangleUsed ; i++ )
-    {
-        if ( !m_triangleTable[i].bUsed )  continue;
-
-        if ( fabs(pos.x-m_triangleTable[i].p1.x) < limit &&
-             fabs(pos.z-m_triangleTable[i].p1.z) < limit )
-        {
-            return m_triangleTable[i].p1.y;
-        }
-
-        if ( fabs(pos.x-m_triangleTable[i].p2.x) < limit &&
-             fabs(pos.z-m_triangleTable[i].p2.z) < limit )
-        {
-            return m_triangleTable[i].p2.y;
-        }
-
-        if ( fabs(pos.x-m_triangleTable[i].p3.x) < limit &&
-             fabs(pos.z-m_triangleTable[i].p3.z) < limit )
-        {
-            return m_triangleTable[i].p3.y;
-        }
-    }
-
-    return 0.0f;
-}
-
-
diff --git a/src/common/modfile.h b/src/common/modfile.h
deleted file mode 100644
index c852c1e..0000000
--- a/src/common/modfile.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// * 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  http://www.gnu.org/licenses/.
-
-// modfile.h
-
-#pragma once
-
-
-#include "math/vector.h"
-#include "old/d3dengine.h"
-
-
-class CInstanceManager;
-
-
-
-
-struct OldModelTriangle1
-{
-    char            bUsed;      // true -> using
-    char            bSelect;    // true -> selected
-    D3DVERTEX       p1;
-    D3DVERTEX       p2;
-    D3DVERTEX       p3;
-    D3DMATERIAL7    material;
-    char            texName[20];
-    float           min;
-    float           max;
-};      // length = 196 bytes
-
-struct OldModelTriangle2
-{
-    char            bUsed;      // true -> used
-    char            bSelect;    // true -> selected
-    D3DVERTEX       p1;
-    D3DVERTEX       p2;
-    D3DVERTEX       p3;
-    D3DMATERIAL7    material;
-    char            texName[20];
-    float           min;
-    float           max;
-    long            state;
-    short           reserve1;
-    short           reserve2;
-    short           reserve3;
-    short           reserve4;
-};
-
-struct ModelTriangle
-{
-    char            bUsed;      // true -> used
-    char            bSelect;    // true -> selected
-    D3DVERTEX2      p1;
-    D3DVERTEX2      p2;
-    D3DVERTEX2      p3;
-    D3DMATERIAL7    material;
-    char            texName[20];
-    float           min;
-    float           max;
-    long            state;
-    short           texNum2;
-    short           reserve2;
-    short           reserve3;
-    short           reserve4;
-};      // length = 208 bytes
-
-
-
-
-class CModFile
-{
-public:
-    CModFile(CInstanceManager* iMan);
-    ~CModFile();
-
-    bool            ReadDXF(char *filename, float min, float max);
-    bool            AddModel(char *filename, int first, bool bEdit=false, bool bMeta=true);
-    bool            ReadModel(char *filename, bool bEdit=false, bool bMeta=true);
-    bool            WriteModel(char *filename);
-
-    bool            CreateEngineObject(int objRank, int addState=0);
-    void            Mirror();
-
-    void            SetTriangleUsed(int total);
-    int             RetTriangleUsed();
-    int             RetTriangleMax();
-    ModelTriangle*  RetTriangleList();
-
-    float           RetHeight(Math::Vector pos);
-
-protected:
-    bool            CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max);
-
-protected:
-    CInstanceManager* m_iMan;
-    CD3DEngine*     m_engine;
-
-    ModelTriangle*  m_triangleTable;
-    int             m_triangleUsed;
-};
-
-
diff --git a/src/common/singleton.h b/src/common/singleton.h
index dc09645..4df7878 100644
--- a/src/common/singleton.h
+++ b/src/common/singleton.h
@@ -29,25 +29,25 @@ template<typename T> class CSingleton
 
     public:
         static T& GetInstance() {
-            aserrt(mInstance);
+            assert(mInstance != NULL);
             return *mInstance;
         }
 
-        static T& GetInstancePointer() {
-            aserrt(mInstance);
+        static T* GetInstancePointer() {
+            assert(mInstance != NULL);
             return mInstance;
         }
 
         static bool IsCreated() {
-            return mInstance != NULL; 
+            return mInstance != NULL;
         }
 
         CSingleton() {
-            assert(!mInstance);
+            assert(mInstance == NULL);
             mInstance = static_cast<T *>(this);
         }
 
-        ~CSingleton() {
+        virtual ~CSingleton() {
             mInstance = NULL;
         }
 
diff --git a/src/common/stringutils.cpp b/src/common/stringutils.cpp
new file mode 100644
index 0000000..585bb46
--- /dev/null
+++ b/src/common/stringutils.cpp
@@ -0,0 +1,149 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// stringutils.cpp
+
+#include "stringutils.h"
+
+
+std::string StrUtils::Replace(const std::string &str, const std::string &oldStr, const std::string &newStr)
+{
+  std::string result = str;
+  size_t pos = 0;
+  while ((pos = str.find(oldStr, pos)) != std::string::npos)
+  {
+    result.replace(pos, oldStr.length(), newStr);
+    pos += newStr.length();
+  }
+  return result;
+}
+
+std::string StrUtils::UnicodeCharToUtf8(unsigned int ch)
+{
+  std::string result;
+  if (ch < 0x0080)
+  {
+    result += static_cast<char>(ch);
+  }
+  else if (ch < 0x0800)
+  {
+    char ch1 = 0xC0 | ((ch & 0x07C0) >> 6);
+    char ch2 = 0x80 | (ch & 0x3F);
+    result += ch1;
+    result += ch2;
+  }
+  else
+  {
+    char ch1 = 0xE0 | ((ch & 0xF000) >> 12);
+    char ch2 = 0x80 | ((ch & 0x07C0) >> 6);
+    char ch3 = 0x80 | (ch & 0x3F);
+    result += ch1;
+    result += ch2;
+    result += ch3;
+  }
+  return result;
+}
+
+std::string StrUtils::UnicodeStringToUtf8(const std::wstring &str)
+{
+  std::string result;
+  for (unsigned int i = 0; i < str.size(); ++i)
+    result += StrUtils::UnicodeCharToUtf8(static_cast<unsigned int>(str[i]));
+
+  return result;
+}
+
+unsigned int StrUtils::Utf8CharToUnicode(const std::string &ch)
+{
+  if (ch.empty())
+    return 0;
+
+  unsigned int result = 0;
+  if ((ch[0] & 0x80) == 0)
+  {
+    if (ch.size() == 1)
+      result = static_cast<unsigned int>(ch[0]);
+  }
+  else if ((ch[0] & 0xC0) == 0xC0)
+  {
+    if (ch.size() == 2)
+    {
+      unsigned int ch1 = (ch[0] & 0x1F) << 6;
+      unsigned int ch2 = (ch[1] & 0x3F);
+      result = ch1 | ch2;
+    }
+  }
+  else
+  {
+    if (ch.size() == 3)
+    {
+      unsigned int ch1 = (ch[0] & 0xF0) << 12;
+      unsigned int ch2 = (ch[1] & 0xC0) << 6;
+      unsigned int ch3 = (ch[2] & 0xC0);
+      result = ch1 | ch2 | ch3;
+    }
+  }
+
+  return result;
+}
+
+std::wstring StrUtils::Utf8StringToUnicode(const std::string &str)
+{
+  std::wstring result;
+  unsigned int pos = 0;
+  while (pos < str.size())
+  {
+    int len = StrUtils::Utf8CharSizeAt(str, pos);
+    if (len == 0)
+      break;
+
+    std::string ch = str.substr(pos, len);
+    result += static_cast<wchar_t>(StrUtils::Utf8CharToUnicode(ch));
+    pos += len;
+  }
+  return result;
+}
+
+int StrUtils::Utf8CharSizeAt(const std::string &str, unsigned int pos)
+{
+  if (pos >= str.size())
+    return 0;
+
+  if ((str[pos] & 0x80) == 0)
+    return 1;
+  else if ((str[pos] & 0xC0) == 0xC0)
+    return 2;
+  else
+    return 3;
+
+  return 0;
+}
+
+size_t StrUtils::Utf8StringLength(const std::string &str)
+{
+  size_t result = 0;
+  for (unsigned int i = 0; i < str.size(); ++i)
+  {
+    char ch = str[i];
+    if ((ch & 0x80) == 0)
+      ++result;
+    else if ((ch & 0xC0) == 0xC0)
+      result += 2;
+    else
+      result += 3;
+  }
+  return result;
+}
diff --git a/src/common/stringutils.h b/src/common/stringutils.h
new file mode 100644
index 0000000..a0cae70
--- /dev/null
+++ b/src/common/stringutils.h
@@ -0,0 +1,77 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// stringutils.h
+
+#pragma once
+
+
+#include <string>
+#include <sstream>
+
+namespace StrUtils {
+
+//! Converts a value to string
+/** If given, \a ok is set to true/false on success/failure.
+    Warning: To avoid unnecessary problems, *always* give full template qualifier e.g. ToString\<int\> */
+template<class T>
+std::string ToString(T value, bool *ok = NULL)
+{
+  std::ostringstream s;
+  s << value;
+  if (ok != NULL)
+    *ok = !s.fail();
+  return s.str();
+}
+
+//! Converts a value to string
+/** If given, \a ok is set to true/false on success/failure.
+    Warning: To avoid unnecessary problems, *always* give full template qualifier e.g. FromString\<int\> */
+template<class T>
+T FromString(const std::string &str, bool *ok = NULL)
+{
+  std::istringstream s;
+  s.str(str);
+  T value;
+  s >> value;
+  if (ok != NULL)
+    *ok = !s.fail();
+  return value;
+}
+
+//! Returns a string with every occurence of \a oldStr in \a str replaced to \a newStr
+std::string Replace(const std::string &str, const std::string &oldStr, const std::string &newStr);
+
+
+//! Converts a wide Unicode char to a single UTF-8 encoded char
+std::string UnicodeCharToUtf8(unsigned int ch);
+
+//! Converts a wide Unicode string to a UTF-8 encoded string
+std::string UnicodeStringToUtf8(const std::wstring &str);
+
+//! Converts a UTF-8 encoded single character to wide Unicode char
+unsigned int Utf8CharToUnicode(const std::string &ch);
+
+//! Converts a UTF-8 encoded string to wide Unicode string
+std::wstring Utf8StringToUnicode(const std::string &str);
+
+//! Returns the size in bytes of UTF-8 character at given \a pos in a UTF-8 \a str
+int Utf8CharSizeAt(const std::string &str, unsigned int pos);
+
+//! Returns the length in characters of UTF-8 string \a str
+size_t Utf8StringLength(const std::string &str);
+
+}; // namespace StrUtil
diff --git a/src/common/test/CMakeLists.txt b/src/common/test/CMakeLists.txt
new file mode 100644
index 0000000..680116c
--- /dev/null
+++ b/src/common/test/CMakeLists.txt
@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_BUILD_TYPE debug)
+set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -O0")
+
+add_executable(image_test ../image.cpp image_test.cpp)
diff --git a/src/common/test/image_test.cpp b/src/common/test/image_test.cpp
new file mode 100644
index 0000000..0ad1ee2
--- /dev/null
+++ b/src/common/test/image_test.cpp
@@ -0,0 +1,34 @@
+#include "../image.h"
+
+#include <SDL/SDL.h>
+#include <stdio.h>
+
+/* For now, just a simple test: loading a file from image
+ * and saving it to another in PNG. */
+
+int main(int argc, char *argv[])
+{
+    if (argc != 3)
+    {
+        printf("Usage: %s in_image out_image\n", argv[0]);
+        return 0;
+    }
+
+    CImage image;
+
+    if (! image.Load(argv[1]))
+    {
+        std::string err = image.GetError();
+        printf("Error loading '%s': %s\n", err.c_str());
+        return 1;
+    }
+
+    if (! image.SavePNG(argv[2]))
+    {
+        std::string err = image.GetError();
+        printf("Error saving PNG '%s': %s\n", err.c_str());
+        return 2;
+    }
+
+    return 0;
+}
diff --git a/src/graphics/common/README.txt b/src/graphics/common/README.txt
deleted file mode 100644
index 495a453..0000000
--- a/src/graphics/common/README.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-src/graphics/common
-
-Universal structs and classes used in graphics engine
-
-Concrete implementation in OpenGL is in graphics/opengl directory.
diff --git a/src/graphics/common/camera.cpp b/src/graphics/common/camera.cpp
deleted file mode 100644
index 9990d01..0000000
--- a/src/graphics/common/camera.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// camera.cpp
-
-#include "graphics/common/camera.h"
-
-
-// TODO implementation
diff --git a/src/graphics/common/camera.h b/src/graphics/common/camera.h
deleted file mode 100644
index f17ecef..0000000
--- a/src/graphics/common/camera.h
+++ /dev/null
@@ -1,273 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// camera.h
-
-#pragma once
-
-#include "engine.h"
-#include "common/event.h"
-
-
-class CInstanceManager;
-class Gfx::CEngine;
-class Gfx::CTerrain;
-class Gfx::CWater;
-class CObject;
-
-namespace Gfx {
-
-
-enum CameraType
-{
-    CAMERA_NULL     = 0,    // camera undefined
-    CAMERA_FREE     = 1,    // camera free (never in principle)
-    CAMERA_EDIT     = 2,    // camera while editing a program
-    CAMERA_ONBOARD  = 3,    // camera on board a robot
-    CAMERA_BACK     = 4,    // camera behind a robot
-    CAMERA_FIX      = 5,    // static camera following robot
-    CAMERA_EXPLO    = 6,    // camera steady after explosion
-    CAMERA_SCRIPT   = 7,    // camera during a film script
-    CAMERA_INFO     = 8,    // camera for displaying information
-    CAMERA_VISIT    = 9,    // visit instead of an error
-    CAMERA_DIALOG   = 10,   // camera for dialogue
-    CAMERA_PLANE    = 11,   // static camera height
-};
-
-enum CameraSmooth
-{
-    CS_NONE         = 0,    // sharp
-    CS_NORM         = 1,    // normal
-    CS_HARD         = 2,    // hard
-    CS_SPEC         = 3,    // special
-};
-
-enum CenteringPhase
-{
-    CP_NULL         = 0,
-    CP_START        = 1,
-    CP_WAIT         = 2,
-    CP_STOP         = 3,
-};
-
-enum CameraEffect
-{
-    CE_NULL         = 0,    // no effect
-    CE_TERRAFORM    = 1,    // digging in
-    CE_CRASH        = 2,    // Vehicle driving is severely
-    CE_EXPLO        = 3,    // explosion
-    CE_SHOT         = 4,    // not mortal shot
-    CE_VIBRATION    = 5,    // vibration during construction
-    CE_PET          = 6,    // spleen reactor
-};
-
-enum OverEffect
-{
-    OE_NULL         = 0,    // no effect
-    OE_BLOOD        = 1,    // flash red
-    OE_FADEINw      = 2,    // white -> nothing
-    OE_FADEOUTw     = 3,    // nothing -> white
-    OE_FADEOUTb     = 4,    // nothing -> blue
-    OE_BLITZ        = 5,    // lightning
-};
-
-
-
-class CCamera {
-
-    public:
-    CCamera(CInstanceManager* iMan);
-    ~CCamera();
-
-    bool        EventProcess(const Event &event);
-
-    void        Init(Math::Vector eye, Math::Vector lookat, float delay);
-
-    void        SetObject(CObject* object);
-    CObject*    RetObject();
-
-    void        SetType(CameraType type);
-    CameraType  RetType();
-
-    void        SetSmooth(CameraSmooth type);
-    CameraSmooth RetSmoth();
-
-    void        SetDist(float dist);
-    float       RetDist();
-
-    void        SetFixDirection(float angle);
-    float       RetFixDirection();
-
-    void        SetRemotePan(float value);
-    float       RetRemotePan();
-
-    void        SetRemoteZoom(float value);
-    float       RetRemoteZoom();
-
-    void        StartVisit(Math::Vector goal, float dist);
-    void        StopVisit();
-
-    void        RetCamera(Math::Vector &eye, Math::Vector &lookat);
-
-    bool        StartCentering(CObject *object, float angleH, float angleV, float dist, float time);
-    bool        StopCentering(CObject *object, float time);
-    void        AbortCentering();
-
-    void        FlushEffect();
-    void        StartEffect(CameraEffect effect, Math::Vector pos, float force);
-
-    void        FlushOver();
-    void        SetOverBaseColor(Gfx::Color color);
-    void        StartOver(OverEffect effect, Math::Vector pos, float force);
-
-    void        FixCamera();
-    void        SetScriptEye(Math::Vector eye);
-    void        SetScriptLookat(Math::Vector lookat);
-
-    void        SetEffect(bool bEnable);
-    void        SetCameraScroll(bool bScroll);
-    void        SetCameraInvertX(bool bInvert);
-    void        SetCameraInvertY(bool bInvert);
-
-    float       RetMotorTurn();
-    Gfx::MouseType  RetMouseDef(Math::Point pos);
-
-protected:
-    bool        EventMouseMove(const Event &event);
-    void        EventMouseWheel(int dir);
-    bool        EventFrame(const Event &event);
-    bool        EventFrameFree(const Event &event);
-    bool        EventFrameEdit(const Event &event);
-    bool        EventFrameDialog(const Event &event);
-    bool        EventFrameBack(const Event &event);
-    bool        EventFrameFix(const Event &event);
-    bool        EventFrameExplo(const Event &event);
-    bool        EventFrameOnBoard(const Event &event);
-    bool        EventFrameInfo(const Event &event);
-    bool        EventFrameVisit(const Event &event);
-    bool        EventFrameScript(const Event &event);
-
-    void        SetViewTime(const Math::Vector &vEyePt, const Math::Vector &vLookatPt, float rTime);
-    bool        IsCollision(Math::Vector &eye, Math::Vector lookat);
-    bool        IsCollisionBack(Math::Vector &eye, Math::Vector lookat);
-    bool        IsCollisionFix(Math::Vector &eye, Math::Vector lookat);
-
-    Math::Vector    ExcludeTerrain(Math::Vector eye, Math::Vector lookat, float &angleH, float &angleV);
-    Math::Vector    ExcludeObject(Math::Vector eye, Math::Vector lookat, float &angleH, float &angleV);
-
-    void        SetViewParams(const Math::Vector &eye, const Math::Vector &lookat, const Math::Vector &up);
-    void        EffectFrame(const Event &event);
-    void        OverFrame(const Event &event);
-
-protected:
-    CInstanceManager* m_iMan;
-    Gfx::CEngine*   m_engine;
-    CTerrain*   m_terrain;
-    CWater*     m_water;
-
-    CameraType  m_type;         // the type of camera (CAMERA *)
-    CameraSmooth    m_smooth;       // type of smoothing
-    CObject*    m_cameraObj;        // object linked to the camera
-
-    float       m_eyeDistance;      // distance between the eyes
-    float       m_initDelay;        // time of initial centering
-
-    Math::Vector    m_actualEye;        // current eye
-    Math::Vector    m_actualLookat;     // aim current
-    Math::Vector    m_finalEye;     // final eye
-    Math::Vector    m_finalLookat;      // aim final
-    Math::Vector    m_normEye;      // normal eye
-    Math::Vector    m_normLookat;       // aim normal
-    float       m_focus;
-
-    bool        m_bRightDown;
-    Math::Point     m_rightPosInit;
-    Math::Point     m_rightPosCenter;
-    Math::Point     m_rightPosMove;
-
-    Math::Vector    m_eyePt;        // CAMERA_FREE: eye
-    float       m_directionH;       // CAMERA_FREE: horizontal direction
-    float       m_directionV;       // CAMERA_FREE: vertical direction
-    float       m_heightEye;        // CAMERA_FREE: height above the ground
-    float       m_heightLookat;     // CAMERA_FREE: height above the ground
-    float       m_speed;        // CAMERA_FREE: speed of movement
-
-    float       m_backDist;     // CAMERA_BACK: distance
-    float       m_backMin;      // CAMERA_BACK: distance minimal
-    float       m_addDirectionH;    // CAMERA_BACK: additional direction
-    float       m_addDirectionV;    // CAMERA_BACK: additional direction
-    bool        m_bTransparency;
-
-    float       m_fixDist;      // CAMERA_FIX: distance
-    float       m_fixDirectionH;    // CAMERA_FIX: direction
-    float       m_fixDirectionV;    // CAMERA_FIX: direction
-
-    Math::Vector    m_visitGoal;        // CAMERA_VISIT: target position
-    float       m_visitDist;        // CAMERA_VISIT: distance
-    float       m_visitTime;        // CAMERA_VISIT: relative time
-    CameraType  m_visitType;        // CAMERA_VISIT: initial type
-    float       m_visitDirectionH;  // CAMERA_VISIT: direction
-    float       m_visitDirectionV;  // CAMERA_VISIT: direction
-
-    float       m_editHeight;       // CAMERA_EDIT: height
-
-    float       m_remotePan;
-    float       m_remoteZoom;
-
-    Math::Point     m_mousePos;
-    float       m_mouseDirH;
-    float       m_mouseDirV;
-    float       m_mouseMarging;
-
-    float       m_motorTurn;
-
-    CenteringPhase m_centeringPhase;
-    float       m_centeringAngleH;
-    float       m_centeringAngleV;
-    float       m_centeringDist;
-    float       m_centeringCurrentH;
-    float       m_centeringCurrentV;
-    float       m_centeringTime;
-    float       m_centeringProgress;
-
-    CameraEffect m_effectType;
-    Math::Vector m_effectPos;
-    float        m_effectForce;
-    float        m_effectProgress;
-    Math::Vector m_effectOffset;
-
-    OverEffect  m_overType;
-    float       m_overForce;
-    float       m_overTime;
-    Gfx::Color  m_overColorBase;
-    Gfx::Color  m_overColor;
-    int         m_overMode;
-    float       m_overFadeIn;
-    float       m_overFadeOut;
-
-    Math::Vector    m_scriptEye;
-    Math::Vector    m_scriptLookat;
-
-    bool        m_bEffect;      // shocks if explosion?
-    bool        m_bCameraScroll;    // scroll in the edges?
-    bool        m_bCameraInvertX;   // X inversion in the edges?
-    bool        m_bCameraInvertY;   // Y inversion in the edges?
-
-};
-
-
-}; // namespace Gfx
diff --git a/src/graphics/common/color.cpp b/src/graphics/common/color.cpp
deleted file mode 100644
index dd502f9..0000000
--- a/src/graphics/common/color.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// color.cpp
-
-#include "graphics/common/color.h"
-
-#include "math/func.h"
-
-
-// Returns the color corresponding long.
-
-long Gfx::RetColor(float intensity)
-{
-  long  color;
-
-  if ( intensity <= 0.0f )  return 0x00000000;
-  if ( intensity >= 1.0f )  return 0xffffffff;
-
-  color  = (int)(intensity*255.0f)<<24;
-  color |= (int)(intensity*255.0f)<<16;
-  color |= (int)(intensity*255.0f)<<8;
-  color |= (int)(intensity*255.0f);
-
-  return color;
-}
-
-// Returns the color corresponding long.
-
-long Gfx::RetColor(Gfx::Color intensity)
-{
-  long  color;
-
-  color  = (int)(intensity.a*255.0f)<<24;
-  color |= (int)(intensity.r*255.0f)<<16;
-  color |= (int)(intensity.g*255.0f)<<8;
-  color |= (int)(intensity.b*255.0f);
-
-  return color;
-}
-
-// Returns the color corresponding Color.
-
-Gfx::Color Gfx::RetColor(long intensity)
-{
-  Gfx::Color color;
-
-  color.r = (float)((intensity>>16)&0xff)/256.0f;
-  color.g = (float)((intensity>>8 )&0xff)/256.0f;
-  color.b = (float)((intensity>>0 )&0xff)/256.0f;
-  color.a = (float)((intensity>>24)&0xff)/256.0f;
-
-  return color;
-}
-
-
-// RGB to HSV conversion.
-
-void Gfx::RGB2HSV(Gfx::Color src, Gfx::ColorHSV &dest)
-{
-  float min, max, delta;
-
-  min = Math::Min(src.r, src.g, src.b);
-  max = Math::Max(src.r, src.g, src.b);
-
-  dest.v = max;  // intensity
-
-  if ( max == 0.0f )
-  {
-    dest.s = 0.0f;  // saturation
-    dest.h = 0.0f;  // undefined color!
-  }
-  else
-  {
-    delta = max-min;
-    dest.s = delta/max;  // saturation
-
-    if ( src.r == max )  // between yellow & magenta
-    {
-      dest.h = (src.g-src.b)/delta;
-    }
-    else if ( src.g == max )  // between cyan & yellow
-    {
-      dest.h = 2.0f+(src.b-src.r)/delta;
-    }
-    else  // between magenta & cyan
-    {
-      dest.h = 4.0f+(src.r-src.g)/delta;
-    }
-
-    dest.h *= 60.0f;  // in degrees
-    if ( dest.h < 0.0f )  dest.h += 360.0f;
-    dest.h /= 360.0f;  // 0..1
-  }
-}
-
-// HSV to RGB conversion.
-
-void Gfx::HSV2RGB(Gfx::ColorHSV src, Gfx::Color &dest)
-{
-  int   i;
-  float f,v,p,q,t;
-
-  src.h = Math::Norm(src.h)*360.0f;
-  src.s = Math::Norm(src.s);
-  src.v = Math::Norm(src.v);
-
-  if ( src.s == 0.0f )  // zero saturation?
-  {
-    dest.r = src.v;
-    dest.g = src.v;
-    dest.b = src.v;  // gray
-  }
-  else
-  {
-    if ( src.h == 360.0f )  src.h = 0.0f;
-    src.h /= 60.0f;
-    i = (int)src.h;  // integer part (0 .. 5)
-    f = src.h-i;     // fractional part
-
-    v = src.v;
-    p = src.v*(1.0f-src.s);
-    q = src.v*(1.0f-(src.s*f));
-    t = src.v*(1.0f-(src.s*(1.0f-f)));
-
-    switch (i)
-    {
-      case 0:  dest.r=v; dest.g=t; dest.b=p;  break;
-      case 1:  dest.r=q; dest.g=v; dest.b=p;  break;
-      case 2:  dest.r=p; dest.g=v; dest.b=t;  break;
-      case 3:  dest.r=p; dest.g=q; dest.b=v;  break;
-      case 4:  dest.r=t; dest.g=p; dest.b=v;  break;
-      case 5:  dest.r=v; dest.g=p; dest.b=q;  break;
-    }
-  }
-}
-
diff --git a/src/graphics/common/color.h b/src/graphics/common/color.h
deleted file mode 100644
index 12f008f..0000000
--- a/src/graphics/common/color.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// color.h
-
-#pragma once
-
-
-namespace Gfx {
-
-struct Color
-{
-    float r, g, b, a;
-
-    Color(float aR = 0.0f, float aG = 0.0f, float aB = 0.0f, float aA = 0.0f)
-     : r(aR), g(aG), b(aB), a(aA) {}
-};
-
-
-struct ColorHSV
-{
-    float h, s, v;
-
-    ColorHSV(float aH = 0.0f, float aS = 0.0f, float aV = 0.0f)
-     : h(aH), s(aS), v(aV) {}
-};
-
-
-long  RetColor(float intensity);
-long  RetColor(Color intensity);
-Color RetColor(long intensity);
-
-void RGB2HSV(Color src, ColorHSV &dest);
-void HSV2RGB(ColorHSV src, Color &dest);
-
-}; // namespace Gfx
-
diff --git a/src/graphics/common/device.cpp b/src/graphics/common/device.cpp
deleted file mode 100644
index 53274b3..0000000
--- a/src/graphics/common/device.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "graphics/common/device.h"
-
-//! Sets the default values
-Gfx::DeviceConfig::DeviceConfig()
-{
-    width = 800;
-    height = 600;
-    bpp = 16;
-    fullScreen = false;
-    resizeable = false;
-    hardwareAccel = true;
-    doubleBuf = true;
-    noFrame = false;
-}
\ No newline at end of file
diff --git a/src/graphics/common/engine.cpp b/src/graphics/common/engine.cpp
deleted file mode 100644
index 3b9a89d..0000000
--- a/src/graphics/common/engine.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// engine.cpp
-
-#include "graphics/common/engine.h"
-
-#include <GL/gl.h>
-#include <GL/glu.h>
-
-
-// TODO implementation
-
-Gfx::CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
-{
-    // TODO
-}
-
-Gfx::CEngine::~CEngine()
-{
-    // TODO
-}
-
-int Gfx::CEngine::Render()
-{
-    /* Just a hello world for now */
-
-    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-    glShadeModel(GL_SMOOTH);
-    glDisable(GL_DEPTH_TEST);
-    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-
-
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    gluOrtho2D(-10.0f, 10.0f, -10.0f, 10.0f);
-
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-    //glTranslatef(0.0f, 0.0f, -6.0f);
-
-    glBegin(GL_TRIANGLES);
-    {
-        glColor3f(1.0f, 0.0f, 0.0f);
-        glVertex2f(-2.0f, -1.0f);
-        glColor3f(0.0f, 1.0f, 0.0f);
-        glVertex2f(2.0f, -1.0f);
-        glColor3f(0.0f, 0.0f, 1.0f);
-        glVertex2f(0.0f, 1.5f);
-    }
-    glEnd();
-
-    glFlush();
-
-    return 1;
-}
diff --git a/src/graphics/common/engine.h b/src/graphics/common/engine.h
deleted file mode 100644
index 6d2937c..0000000
--- a/src/graphics/common/engine.h
+++ /dev/null
@@ -1,715 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// engine.h
-
-#pragma once
-
-
-#include "graphics/common/color.h"
-#include "graphics/common/material.h"
-#include "graphics/common/vertex.h"
-#include "math/intpoint.h"
-#include "math/matrix.h"
-#include "math/point.h"
-#include "math/vector.h"
-
-
-class CApplication;
-class CInstanceManager;
-class CObject;
-class CSound;
-
-
-namespace Gfx {
-
-class CDevice;
-class CLight;
-class CText;
-class CParticle;
-class CWater;
-class CCloud;
-class CLightning;
-class CPlanet;
-class CTerrain;
-
-
-//const int MAXOBJECT       = 1200;
-//const int MAXSHADOW       = 500;
-//const int MAXGROUNDSPOT   = 100;
-
-
-enum ObjectType
-{
-    //! Object doesn't exist
-    OBJTYPE_NULL        = 0,
-    //! Terrain
-    OBJTYPE_TERRAIN     = 1,
-    //! Fixed object
-    OBJTYPE_FIX         = 2,
-    //! Moving object
-    OBJTYPE_VEHICULE    = 3,
-    //! Part of a moving object
-    OBJTYPE_DESCENDANT  = 4,
-    //! Fixed object type quartz
-    OBJTYPE_QUARTZ      = 5,
-    //! Fixed object type metal
-    OBJTYPE_METAL       = 6
-};
-
-enum TriangleType
-{
-    //! triangles
-    TRIANGLE_TYPE_6T        = 1,
-    //! surfaces
-    TRIANGLE_TYPE_6S        = 2
-};
-
-enum Mapping
-{
-    MAPPING_X       = 1,
-    MAPPING_Y       = 2,
-    MAPPING_Z       = 3,
-    MAPPING_1X      = 4,
-    MAPPING_1Y      = 5,
-    MAPPING_1Z      = 6
-};
-
-enum MouseType
-{
-    MOUSE_HIDE      = 0,        // no mouse
-    MOUSE_NORM      = 1,
-    MOUSE_WAIT      = 2,
-    MOUSE_EDIT      = 3,
-    MOUSE_HAND      = 4,
-    MOUSE_CROSS     = 5,
-    MOUSE_SHOW      = 6,
-    MOUSE_NO        = 7,
-    MOUSE_MOVE      = 8,        // +
-    MOUSE_MOVEH     = 9,        // -
-    MOUSE_MOVEV     = 10,       // |
-    MOUSE_MOVED     = 11,       // /
-    MOUSE_MOVEI     = 12,       // \ //
-    MOUSE_SCROLLL   = 13,       // <<
-    MOUSE_SCROLLR   = 14,       // >>
-    MOUSE_SCROLLU   = 15,       // ^
-    MOUSE_SCROLLD   = 16,       // v
-    MOUSE_TARGET    = 17
-};
-
-enum ShadowType
-{
-    SHADOW_NORM = 0,
-    SHADOW_WORM = 1
-};
-
-enum RenderState
-{
-    //! Normal opaque materials
-    RSTATE_NORMAL           = 0,
-    //! The transparent texture (black = no)
-    RSTATE_TTEXTURE_BLACK   = (1<<0),
-    //! The transparent texture (white = no)
-    RSTATE_TTEXTURE_WHITE   = (1<<1),
-    //! The transparent diffuse color
-    RSTATE_TDIFFUSE         = (1<<2),
-    //! Texture wrap
-    RSTATE_WRAP             = (1<<3),
-    //! Texture borders with solid color
-    RSTATE_CLAMP            = (1<<4),
-    //! Light texture (ambient max)
-    RSTATE_LIGHT            = (1<<5),
-    //! Double black texturing
-    RSTATE_DUAL_BLACK       = (1<<6),
-    //! Double white texturing
-    RSTATE_DUAL_WHITE       = (1<<7),
-    //! Part 1 (no change in. MOD!)
-    RSTATE_PART1            = (1<<8),
-    //! Part 2
-    RSTATE_PART2            = (1<<9),
-    //! Part 3
-    RSTATE_PART3            = (1<<10),
-    //! Part 4
-    RSTATE_PART4            = (1<<11),
-    //! Double-sided face
-    RSTATE_2FACE            = (1<<12),
-    //! Image using alpha channel
-    RSTATE_ALPHA            = (1<<13),
-    //! Always use 2nd floor texturing
-    RSTATE_SECOND           = (1<<14),
-    //! Causes the fog
-    RSTATE_FOG              = (1<<15),
-    //! The transparent color (black = no)
-    RSTATE_TCOLOR_BLACK     = (1<<16),
-    //! The transparent color (white = no)
-    RSTATE_TCOLOR_WHITE     = (1<<17)
-};
-
-
-struct Triangle
-{
-    Gfx::VertexTex2     triangle[3];
-    Gfx::Material       material;
-    int                 state;
-    char                texName1[20];
-    char                texName2[20];
-};
-
-
-struct ObjLevel6
-{
-    int                 totalPossible;
-    int                 totalUsed;
-    Gfx::Material       material;
-    int                 state;
-    Gfx::TriangleType   type;
-    Gfx::VertexTex2 vertex[1];
-};
-
-struct ObjLevel5
-{
-    int             totalPossible;
-    int             totalUsed;
-    int             reserve;
-    Gfx::ObjLevel6* table[1];
-};
-
-struct ObjLevel4
-{
-    int             totalPossible;
-    int             totalUsed;
-    float           min, max;
-    Gfx::ObjLevel5* table[1];
-};
-
-struct ObjLevel3
-{
-    int             totalPossible;
-    int             totalUsed;
-    int             objRank;
-    Gfx::ObjLevel4* table[1];
-};
-
-struct ObjLevel2
-{
-    int             totalPossible;
-    int             totalUsed;
-    char            texName1[20];
-    char            texName2[20];
-    Gfx::ObjLevel3* table[1];
-};
-
-struct ObjLevel1
-{
-    int             totalPossible;
-    int             totalUsed;
-    Gfx::ObjLevel2* table[1];
-};
-
-
-struct Object
-{
-    bool                used;           // true -> object exists
-    bool                visible;        // true -> visible object
-    bool                drawWorld;      // true -> shape behind the interface
-    bool                drawFront;      // true -> shape before the interface
-    int                 totalTriangle;      // number of triangles used
-    Gfx::ObjectType     type;           // type of the object (TYPE*)
-    Math::Matrix        transform;      // transformation matrix
-    float               distance;       // distance point of view - original
-    Math::Vector        bboxMin;        // bounding box of the object
-    Math::Vector        bboxMax;        // (the origin 0, 0, 0 is always included)
-    float               radius;         // radius of the sphere at the origin
-    int                 shadowRank;     // rank of the associated shadow
-    float               transparency;       // transparency of the object (0 .. 1)
-};
-
-struct Shadow
-{
-    bool                used;           // true -> object exists
-    bool                hide;           // true -> invisible shadow (object carried by ex.)
-    int                 objRank;        // rank of the object
-    Gfx::ShadowType     type;           // type of shadow
-    Math::Vector        pos;            // position for the shadow
-    Math::Vector        normal;         // normal terrain
-    float               angle;          // angle of the shadow
-    float               radius;         // radius of the shadow
-    float               intensity;      // intensity of the shadow
-    float               height;         // height from the ground
-};
-
-struct GroundSpot
-{
-    bool            used;           // true -> object exists
-    Gfx::Color      color;          // color of the shadow
-    float           min, max;       // altitudes min / max
-    float           smooth;         // transition area
-    Math::Vector    pos;            // position for the shadow
-    float           radius;         // radius of the shadow
-    Math::Vector    drawPos;        // drawn to position the shade
-    float           drawRadius;     // radius of the shadow drawn
-};
-
-struct GroundMark
-{
-    bool            used;           // true -> object exists
-    bool            draw;           // true -> drawn mark
-    int             phase;          // 1 = increase, 2 = fixed, 3 = decrease
-    float           delay[3];       // time for 3 phases
-    float           fix;            // fixed time
-    Math::Vector    pos;            // position for marks
-    float           radius;         // radius of marks
-    float           intensity;      // color intensity
-    Math::Vector    drawPos;        // drawn in position marks
-    float           drawRadius;     // radius marks drawn
-    float           drawIntensity;      // current drawn
-    int             dx, dy;         // dimensions table
-    char*           table;          // pointer to the table
-};
-
-
-
-class CEngine
-{
-public:
-    CEngine(CInstanceManager *iMan, CApplication *app);
-    ~CEngine();
-
-    void            SetDevice(Gfx::CDevice *device);
-    Gfx::CDevice*   RetDevice();
-
-    void            SetTerrain(Gfx::CTerrain* terrain);
-
-    bool            WriteProfile();
-
-    void            SetPause(bool pause);
-    bool            RetPause();
-
-    void            SetMovieLock(bool lock);
-    bool            RetMovieLock();
-
-    void            SetShowStat(bool show);
-    bool            RetShowStat();
-
-    void            SetRenderEnable(bool enable);
-
-    int             OneTimeSceneInit();
-    int             InitDeviceObjects();
-    int             DeleteDeviceObjects();
-    int             RestoreSurfaces();
-    int             Render();
-    int             FrameMove(float rTime);
-    void            StepSimul(float rTime);
-    int             FinalCleanup();
-    void            AddStatisticTriangle(int nb);
-    int             RetStatisticTriangle();
-    void            SetHiliteRank(int *rankList);
-    bool            GetHilite(Math::Point &p1, Math::Point &p2);
-    bool            GetSpriteCoord(int &x, int &y);
-    void            SetInfoText(int line, char* text);
-    char    *       RetInfoText(int line);
-    //LRESULT       MsgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-    void            FirstExecuteAdapt(bool first);
-    //int               GetVidMemTotal();
-    //bool          IsVideo8MB();
-    //bool          IsVideo32MB();
-
-    bool            EnumDevices(char *bufDevices, int lenDevices, char *bufModes, int lenModes, int &totalDevices, int &selectDevices, int &totalModes, int &selectModes);
-    bool            RetFullScreen();
-    bool            ChangeDevice(char *device, char *mode, bool full);
-
-    Math::Matrix*   RetMatView();
-    Math::Matrix*   RetMatLeftView();
-    Math::Matrix*   RetMatRightView();
-
-    void            TimeInit();
-    void            TimeEnterGel();
-    void            TimeExitGel();
-    float           TimeGet();
-
-    int             RetRestCreate();
-    int             CreateObject();
-    void            FlushObject();
-    bool            DeleteObject(int objRank);
-    bool            SetDrawWorld(int objRank, bool draw);
-    bool            SetDrawFront(int objRank, bool draw);
-    bool            AddTriangle(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool globalUpdate);
-    bool            AddSurface(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, bool globalUpdate);
-    bool            AddQuick(int objRank, Gfx::ObjLevel6* buffer, char* texName1, char* texName2, float min, float max, bool globalUpdate);
-    Gfx::ObjLevel6* SearchTriangle(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max);
-    void            ChangeLOD();
-    bool            ChangeSecondTexture(int objRank, char* texName2);
-    int             RetTotalTriangles(int objRank);
-    int             GetTriangles(int objRank, float min, float max, Gfx::Triangle* buffer, int size, float percent);
-    bool            GetBBox(int objRank, Math::Vector &min, Math::Vector &max);
-    bool            ChangeTextureMapping(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, Gfx::Mapping mode, float au, float bu, float av, float bv);
-    bool            TrackTextureMapping(int objRank, const Gfx::Material &mat, int state, char* texName1, char* texName2, float min, float max, Gfx::Mapping mode, float pos, float factor, float tl, float ts, float tt);
-    bool            SetObjectTransform(int objRank, const Math::Matrix &transform);
-    bool            GetObjectTransform(int objRank, Math::Matrix &transform);
-    bool            SetObjectType(int objRank, Gfx::ObjectType type);
-    Gfx::ObjectType RetObjectType(int objRank);
-    bool            SetObjectTransparency(int objRank, float value);
-
-    bool            ShadowCreate(int objRank);
-    void            ShadowDelete(int objRank);
-    bool            SetObjectShadowHide(int objRank, bool hide);
-    bool            SetObjectShadowType(int objRank, Gfx::ShadowType type);
-    bool            SetObjectShadowPos(int objRank, const Math::Vector &pos);
-    bool            SetObjectShadowNormal(int objRank, const Math::Vector &n);
-    bool            SetObjectShadowAngle(int objRank, float angle);
-    bool            SetObjectShadowRadius(int objRank, float radius);
-    bool            SetObjectShadowIntensity(int objRank, float intensity);
-    bool            SetObjectShadowHeight(int objRank, float h);
-    float           RetObjectShadowRadius(int objRank);
-
-    void            GroundSpotFlush();
-    int             GroundSpotCreate();
-    void            GroundSpotDelete(int rank);
-    bool            SetObjectGroundSpotPos(int rank, const Math::Vector &pos);
-    bool            SetObjectGroundSpotRadius(int rank, float radius);
-    bool            SetObjectGroundSpotColor(int rank, const Gfx::Color &color);
-    bool            SetObjectGroundSpotMinMax(int rank, float min, float max);
-    bool            SetObjectGroundSpotSmooth(int rank, float smooth);
-
-    int             GroundMarkCreate(Math::Vector pos, float radius, float delay1, float delay2, float delay3, int dx, int dy, char* table);
-    bool            GroundMarkDelete(int rank);
-
-    void            Update();
-
-    void            SetViewParams(const Math::Vector &vEyePt, const Math::Vector &vLookatPt, const Math::Vector &vUpVec, float fEyeDistance);
-
-    bool            FreeTexture(char* name);
-    bool            LoadTexture(char* name, int stage=0);
-    bool            LoadAllTexture();
-
-    void            SetLimitLOD(int rank, float limit);
-    float           RetLimitLOD(int rank, bool last=false);
-
-    void            SetTerrainVision(float vision);
-
-    void            SetGroundSpot(bool mode);
-    bool            RetGroundSpot();
-    void            SetShadow(bool mode);
-    bool            RetShadow();
-    void            SetDirty(bool mode);
-    bool            RetDirty();
-    void            SetFog(bool mode);
-    bool            RetFog();
-    bool            RetStateColor();
-
-    void            SetSecondTexture(int texNum);
-    int             RetSecondTexture();
-
-    void            SetRankView(int rank);
-    int             RetRankView();
-
-    void            SetDrawWorld(bool draw);
-    void            SetDrawFront(bool draw);
-
-    void            SetAmbiantColor(const Gfx::Color &color, int rank=0);
-    Gfx::Color      RetAmbiantColor(int rank=0);
-
-    void            SetWaterAddColor(const Gfx::Color &color);
-    Gfx::Color      RetWaterAddColor();
-
-    void            SetFogColor(const Gfx::Color &color, int rank=0);
-    Gfx::Color      RetFogColor(int rank=0);
-
-    void            SetDeepView(float length, int rank=0, bool ref=false);
-    float           RetDeepView(int rank=0);
-
-    void            SetFogStart(float start, int rank=0);
-    float           RetFogStart(int rank=0);
-
-    void            SetBackground(char *name, Gfx::Color up=Gfx::Color(), Gfx::Color down=Gfx::Color(), Gfx::Color cloudUp=Gfx::Color(), Gfx::Color cloudDown=Gfx::Color(), bool full=false, bool quarter=false);
-    void            RetBackground(char *name, Gfx::Color &up, Gfx::Color &down, Gfx::Color &cloudUp, Gfx::Color &cloudDown, bool &full, bool &quarter);
-    void            SetFrontsizeName(char *name);
-    void            SetOverFront(bool front);
-    void            SetOverColor(const Gfx::Color &color=Gfx::Color(), int mode=RSTATE_TCOLOR_BLACK);
-
-    void            SetParticuleDensity(float value);
-    float           RetParticuleDensity();
-    float           ParticuleAdapt(float factor);
-
-    void            SetClippingDistance(float value);
-    float           RetClippingDistance();
-
-    void            SetObjectDetail(float value);
-    float           RetObjectDetail();
-
-    void            SetGadgetQuantity(float value);
-    float           RetGadgetQuantity();
-
-    void            SetTextureQuality(int value);
-    int             RetTextureQuality();
-
-    void            SetTotoMode(bool present);
-    bool            RetTotoMode();
-
-    void            SetLensMode(bool present);
-    bool            RetLensMode();
-
-    void            SetWaterMode(bool present);
-    bool            RetWaterMode();
-
-    void            SetBlitzMode(bool present);
-    bool            RetBlitzMode();
-
-    void            SetSkyMode(bool present);
-    bool            RetSkyMode();
-
-    void            SetBackForce(bool present);
-    bool            RetBackForce();
-
-    void            SetPlanetMode(bool present);
-    bool            RetPlanetMode();
-
-    void            SetLightMode(bool present);
-    bool            RetLightMode();
-
-    void            SetEditIndentMode(bool auto);
-    bool            RetEditIndentMode();
-
-    void            SetEditIndentValue(int value);
-    int             RetEditIndentValue();
-
-    void            SetSpeed(float speed);
-    float           RetSpeed();
-
-    void            SetTracePrecision(float factor);
-    float           RetTracePrecision();
-
-    void            SetFocus(float focus);
-    float           RetFocus();
-    Math::Vector    RetEyePt();
-    Math::Vector    RetLookatPt();
-    float           RetEyeDirH();
-    float           RetEyeDirV();
-    Math::Point     RetDim();
-    void            UpdateMatProj();
-
-    void            ApplyChange();
-
-    void            FlushPressKey();
-    void            ResetKey();
-    void            SetKey(int keyRank, int option, int key);
-    int             RetKey(int keyRank, int option);
-
-    void            SetJoystick(bool enable);
-    bool            RetJoystick();
-
-    void            SetDebugMode(bool mode);
-    bool            RetDebugMode();
-    bool            RetSetupMode();
-
-    bool            IsVisiblePoint(const Math::Vector &pos);
-
-    int             DetectObject(Math::Point mouse);
-    void            SetState(int state, Gfx::Color color=Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f));
-    void            SetTexture(char *name, int stage=0);
-    void            SetMaterial(const Gfx::Material &mat);
-
-    void            MoveMousePos(Math::Point pos);
-    void            SetMousePos(Math::Point pos);
-    Math::Point     RetMousePos();
-    void            SetMouseType(Gfx::MouseType type);
-    Gfx::MouseType  RetMouseType();
-    void            SetMouseHide(bool hide);
-    bool            RetMouseHide();
-    void            SetNiceMouse(bool nice);
-    bool            RetNiceMouse();
-    bool            RetNiceMouseCap();
-
-    CText*          RetText();
-
-    bool            ChangeColor(char *name, Gfx::Color colorRef1, Gfx::Color colorNew1, Gfx::Color colorRef2, Gfx::Color colorNew2, float tolerance1, float tolerance2, Math::Point ts, Math::Point ti, Math::Point *pExclu=0, float shift=0.0f, bool hSV=false);
-    bool            OpenImage(char *name);
-    bool            CopyImage();
-    bool            LoadImage();
-    bool            ScrollImage(int dx, int dy);
-    bool            SetDot(int x, int y, Gfx::Color color);
-    bool            CloseImage();
-    bool            WriteScreenShot(char *filename, int width, int height);
-    //bool      GetRenderDC(HDC &hDC);
-    //bool      ReleaseRenderDC(HDC &hDC);
-    //PBITMAPINFO   CreateBitmapInfoStruct(HBITMAP hBmp);
-    //bool      CreateBMPFile(LPTSTR pszFile, PBITMAPINFO pbi, HBITMAP hBMP, HDC hDC);
-
-protected:
-    void        MemSpace1(Gfx::ObjLevel1 *&p, int nb);
-    void        MemSpace2(Gfx::ObjLevel2 *&p, int nb);
-    void        MemSpace3(Gfx::ObjLevel3 *&p, int nb);
-    void        MemSpace4(Gfx::ObjLevel4 *&p, int nb);
-    void        MemSpace5(Gfx::ObjLevel5 *&p, int nb);
-    void        MemSpace6(Gfx::ObjLevel6 *&p, int nb);
-
-    Gfx::ObjLevel2* AddLevel1(Gfx::ObjLevel1 *&p1, char* texName1, char* texName2);
-    Gfx::ObjLevel3* AddLevel2(Gfx::ObjLevel2 *&p2, int objRank);
-    Gfx::ObjLevel4* AddLevel3(Gfx::ObjLevel3 *&p3, float min, float max);
-    Gfx::ObjLevel5* AddLevel4(Gfx::ObjLevel4 *&p4, int reserve);
-    Gfx::ObjLevel6* AddLevel5(Gfx::ObjLevel5 *&p5, Gfx::TriangleType type, const Gfx::Material &mat, int state, int nb);
-
-    bool        IsVisible(int objRank);
-    bool        DetectBBox(int objRank, Math::Point mouse);
-    bool        DetectTriangle(Math::Point mouse, Gfx::VertexTex2 *triangle, int objRank, float &dist);
-    bool        TransformPoint(Math::Vector &p2D, int objRank, Math::Vector p3D);
-    void        ComputeDistance();
-    void        UpdateGeometry();
-    void        RenderGroundSpot();
-    void        DrawShadow();
-    void        DrawBackground();
-    void        DrawBackgroundGradient(Gfx::Color up, Gfx::Color down);
-    void        DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, char *name);
-    void        DrawBackgroundImage();
-    void        DrawPlanet();
-    void        DrawFrontsize();
-    void        DrawOverColor();
-    bool        GetBBox2D(int objRank, Math::Point &min, Math::Point &max);
-    void        DrawHilite();
-    void        DrawMouse();
-    void        DrawSprite(Math::Point pos, Math::Point dim, int icon);
-
-protected:
-    CInstanceManager*   m_iMan;
-    CApplication*   m_app;
-    Gfx::CDevice*   m_device;
-    Gfx::CText*         m_text;
-    Gfx::CLight*            m_light;
-    Gfx::CParticle*     m_particule;
-    Gfx::CWater*            m_water;
-    Gfx::CCloud*            m_cloud;
-    Gfx::CLightning*            m_blitz;
-    Gfx::CPlanet*       m_planet;
-    Gfx::CTerrain*      m_terrain;
-    CSound*         m_sound;
-
-    int             m_blackSrcBlend[2];
-    int             m_blackDestBlend[2];
-    int             m_whiteSrcBlend[2];
-    int             m_whiteDestBlend[2];
-    int             m_diffuseSrcBlend[2];
-    int             m_diffuseDestBlend[2];
-    int             m_alphaSrcBlend[2];
-    int             m_alphaDestBlend[2];
-
-    Math::Matrix    m_matProj;
-    Math::Matrix    m_matLeftView;
-    Math::Matrix    m_matRightView;
-    Math::Matrix    m_matView;
-    float           m_focus;
-
-    Math::Matrix    m_matWorldInterface;
-    Math::Matrix    m_matProjInterface;
-    Math::Matrix    m_matViewInterface;
-
-    long            m_baseTime;
-    long            m_stopTime;
-    float           m_absTime;
-    float           m_lastTime;
-    float           m_speed;
-    bool            m_pause;
-    bool            m_render;
-    bool            m_movieLock;
-
-    Math::IntPoint      m_dim;
-    Math::IntPoint      m_lastDim;
-    Gfx::ObjLevel1*     m_objectPointer;
-    int                 m_objectParamTotal;
-    Gfx::Object*        m_objectParam;
-    int                 m_shadowTotal;
-    Gfx::Shadow*        m_shadow;
-    Gfx::GroundSpot*    m_groundSpot;
-    Gfx::GroundMark     m_groundMark;
-    Math::Vector        m_eyePt;
-    Math::Vector        m_lookatPt;
-    float           m_eyeDirH;
-    float           m_eyeDirV;
-    int             m_rankView;
-    Gfx::Color      m_ambiantColor[2];
-    Gfx::Color      m_backColor[2];
-    Gfx::Color      m_fogColor[2];
-    float           m_deepView[2];
-    float           m_fogStart[2];
-    Gfx::Color      m_waterAddColor;
-    int             m_statisticTriangle;
-    bool            m_updateGeometry;
-    char            m_infoText[10][200];
-    int             m_alphaMode;
-    bool            m_stateColor;
-    bool            m_forceStateColor;
-    bool            m_groundSpotVisible;
-    bool            m_shadowVisible;
-    bool            m_dirty;
-    bool            m_fog;
-    bool            m_firstGroundSpot;
-    int             m_secondTexNum;
-    char            m_backgroundName[50];
-    Gfx::Color      m_backgroundColorUp;
-    Gfx::Color      m_backgroundColorDown;
-    Gfx::Color      m_backgroundCloudUp;
-    Gfx::Color      m_backgroundCloudDown;
-    bool            m_backgroundFull;
-    bool            m_backgroundQuarter;
-    bool            m_overFront;
-    Gfx::Color      m_overColor;
-    int             m_overMode;
-    char            m_frontsizeName[50];
-    bool            m_drawWorld;
-    bool            m_drawFront;
-    float           m_limitLOD[2];
-    float           m_particuleDensity;
-    float           m_clippingDistance;
-    float           m_lastClippingDistance;
-    float           m_objectDetail;
-    float           m_lastObjectDetail;
-    float           m_terrainVision;
-    float           m_gadgetQuantity;
-    int             m_textureQuality;
-    bool            m_totoMode;
-    bool            m_lensMode;
-    bool            m_waterMode;
-    bool            m_skyMode;
-    bool            m_backForce;
-    bool            m_planetMode;
-    bool            m_lightMode;
-    bool            m_editIndentMode;
-    int             m_editIndentValue;
-    float           m_tracePrecision;
-
-    int             m_hiliteRank[100];
-    bool            m_hilite;
-    Math::Point     m_hiliteP1;
-    Math::Point     m_hiliteP2;
-
-    int             m_lastState;
-    Gfx::Color      m_lastColor;
-    char            m_lastTexture[2][50];
-    Gfx::Material   m_lastMaterial;
-
-    Math::Point     m_mousePos;
-    Gfx::MouseType  m_mouseType;
-    bool            m_mouseHide;
-    bool            m_niceMouse;
-
-    //LPDIRECTDRAWSURFACE7 m_imageSurface;
-    //DDSURFACEDESC2        m_imageDDSD;
-    //WORD*             m_imageCopy;
-    //int                   m_imageDX;
-    //int                   m_imageDY;
-};
-
-}; // namespace Gfx
diff --git a/src/graphics/common/light.cpp b/src/graphics/common/light.cpp
deleted file mode 100644
index d938256..0000000
--- a/src/graphics/common/light.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// light.cpp
-
-#include "graphics/common/light.h"
-
-// TODO implementation
\ No newline at end of file
diff --git a/src/graphics/common/light.h b/src/graphics/common/light.h
deleted file mode 100644
index dec9912..0000000
--- a/src/graphics/common/light.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// light.h
-
-#pragma once
-
-
-#include "graphics/common/color.h"
-#include "math/vector.h"
-
-
-namespace Gfx {
-
-/** \enum LightType
- *  \brief Type of light */
-enum LightType
-{
-    LT_Point,
-    LT_Spot,
-    LT_Directional
-};
-
-/**
- * \struct Light
- * \brief Light
- *
- * This structure was created as analog to DirectX's D3DLIGHT.
- *
- * It contains analogous fields as the D3DLIGHT struct.
- */
-struct Light
-{
-    //! Type of light source
-    Gfx::LightType      type;
-    //! Color of light
-    Gfx::Color          color;
-    //! Position in world space
-    Math::Vector    position;
-    //! Direction in world space
-    Math::Vector    direction;
-    //! Cutoff range
-    float           range;
-    //! Falloff
-    float           falloff;
-    //! Constant attenuation
-    float           attenuation0;
-    //! Linear attenuation
-    float           attenuation1;
-    //! Quadratic attenuation
-    float           attenuation2;
-    //! Inner angle of spotlight cone
-    float           theta;
-    //! Outer angle of spotlight cone
-    float           phi;
-
-    Light() : type(LT_Point), range(0.0f), falloff(0.0f),
-              attenuation0(0.0f), attenuation1(0.0f), attenuation2(0.0f),
-              theta(0.0f), phi(0.0f) {}
-};
-
-struct LightProg
-{
-    float   starting;
-    float   ending;
-    float   current;
-    float   progress;
-    float   speed;
-};
-
-/**
- * \struct SceneLight
- * \brief Dynamic light in 3D scene
- *
- * TODO documentation
- */
-struct SceneLight
-{
-    //! true -> light exists
-    bool            used;
-    //! true -> light turned on
-    bool            enable;
-
-    //! Type of all objects included
-    //D3DTypeObj        incluType;
-    //! Type of all objects excluded
-    //D3DTypeObj        excluType;
-
-    //! Configuration of the light
-    Gfx::Light      light;
-
-    //! intensity (0 .. 1)
-    Gfx::LightProg      intensity;
-    Gfx::LightProg      colorRed;
-    Gfx::LightProg      colorGreen;
-    Gfx::LightProg      colorBlue;
-};
-
-// TODO CLight
-
-}; // namespace Gfx
diff --git a/src/graphics/common/model.cpp b/src/graphics/common/model.cpp
deleted file mode 100644
index c415fb8..0000000
--- a/src/graphics/common/model.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// model.cpp
-
-#include "graphics/common/model.h"
-
-
-// TODO implementation
diff --git a/src/graphics/common/model.h b/src/graphics/common/model.h
deleted file mode 100644
index e8a5f19..0000000
--- a/src/graphics/common/model.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// model.h
-
-#pragma once
-
-#include "engine.h"
-#include "common/event.h"
-#include "modfile.h"
-#include "vertex.h"
-#include "math/point.h"
-
-
-class CInstanceManager;
-class CModFile;
-class CInterface;
-
-
-namespace Gfx {
-
-class CEngine;
-
-
-class CModel {
-    public:
-    CModel(CInstanceManager* iMan);
-    ~CModel();
-
-    void        StartUserAction();
-    void        StopUserAction();
-
-    bool        EventProcess(const Event &event);
-
-    void        InitView();
-    void        InitViewFromSelect();
-    void        UpdateView();
-    void        ViewMove(const Event &event, float speed);
-
-    protected:
-    bool        EventFrame(const Event &event);
-    bool        GetVertex(int rank, Gfx::VertexTex2 &vertex);
-    bool        SetVertex(int rank, Gfx::VertexTex2 &vertex);
-    Math::Vector    RetSelectCDG();
-    Math::Vector    RetSelectNormal();
-    void        SmoothSelect();
-    void        PlaneSelect();
-    void        ColorSelect();
-    void        StateSelect();
-    void        MoveSelect(Math::Vector move);
-    void        OperSelect(Math::Vector move, char oper);
-    void        ReadScript(char *filename);
-    void        BBoxCompute(Math::Vector &min, Math::Vector &max);
-    bool        IsMappingSelectPlausible(Gfx::Mapping D3Dmode);
-    void        MappingSelect(int mode, int rotate, bool bMirrorX, bool bMirrorY, Math::Point ti, Math::Point ts, char *texName);
-    void        MappingSelectSpherical(int mode, int rotate, bool bMirrorX, bool bMirrorY, Math::Point ti, Math::Point ts, char *texName);
-    Math::Vector    RetMappingCenter(Math::Vector pos, Math::Vector min);
-    void        MappingSelectCylindrical(int mode, int rotate, bool bMirrorX, bool bMirrorY, Math::Point ti, Math::Point ts, char *texName);
-    void        MappingSelectFace(int mode, int rotate, bool bMirrorX, bool bMirrorY, Math::Point ti, Math::Point ts, char *texName);
-    void        MappingSelect2(int texNum2, int subdiv, int offsetU, int offsetV, bool bMirrorX, bool bMirrorY);
-    void        MappingSelectPlane2(int mode, bool bMirrorX, bool bMirrorY);
-    void        MappingSelectSpherical2(bool bMirrorX, bool bMirrorY);
-    void        MappingSelectMagic2(bool bMirrorX, bool bMirrorY);
-    int         SearchNext(int rank, int step);
-    int         SearchSamePlane(int first, int step);
-    void        CurrentSearchNext(int step, bool bControl);
-    void        CurrentInit();
-    void        CurrentSelect(bool bSelect);
-    void        DeselectAll();
-    void        SelectAll();
-    void        SelectZone(int first, int last);
-    void        SelectTerm();
-    void        DefaultSelect();
-    void        SelectDelete();
-    void        Compress();
-    void        MinMaxSelect();
-    void        MinMaxChange();
-    void        UpdateInfoText();
-    int*        RetTextureTable();
-    void        TexturePartUpdate();
-    void        TextureRankChange(int step);
-    void        TexturePartChange(int step);
-    void        PutTextureValues();
-    void        GetTextureValues();
-    void        GetModelName(char *buffer);
-    void        GetDXFName(char *buffer);
-    void        GetScriptName(char *buffer);
-    bool        IsEditFocus();
-
-    protected:
-    CInstanceManager* m_iMan;
-    Gfx::CEngine*   m_engine;
-    CModFile*       m_modFile;
-    CInterface*     m_interface;
-
-    float           m_time;
-    ModelTriangle*  m_triangleTable;
-    int             m_triangleSel1;
-    int             m_triangleSel2;
-    int             m_mode;
-    int             m_textureMode;
-    int             m_textureRotate;
-    bool            m_bTextureMirrorX;
-    bool            m_bTextureMirrorY;
-    Math::Point         m_textureInf;
-    Math::Point         m_textureSup;
-    int             m_texturePart;
-    int             m_textureRank;
-    char            m_textureName[20];
-    bool            m_bDisplayTransparent;
-    bool            m_bDisplayOnlySelection;
-    float           m_viewHeight;
-    float           m_viewDist;
-    float           m_viewAngleH;
-    float           m_viewAngleV;
-    int             m_color;
-    int             m_state;
-    int             m_secondTexNum;
-    int             m_secondSubdiv;
-    int             m_secondOffsetU;
-    int             m_secondOffsetV;
-    char            m_oper;
-    float           m_min;
-    float           m_max;
-};
-
-}; // namespace Gfx
diff --git a/src/graphics/common/modfile.cpp b/src/graphics/common/modfile.cpp
deleted file mode 100644
index 6f80be7..0000000
--- a/src/graphics/common/modfile.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// modfile.cpp
-
-#include "graphics/common/modfile.h"
-
-
-// TODO implementation
\ No newline at end of file
diff --git a/src/graphics/common/modfile.h b/src/graphics/common/modfile.h
deleted file mode 100644
index c81739b..0000000
--- a/src/graphics/common/modfile.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// modfile.h
-
-#include "engine.h"
-#include "vertex.h"
-#include "material.h"
-#include "math/vector.h"
-
-
-class CInstanceManager;
-
-
-namespace Gfx {
-
-struct OldModelTriangle1
-{
-    char            bUsed;      // TRUE -> using
-    char            bSelect;    // TRUE -> selected
-    Vertex      p1;
-    Vertex      p2;
-    Vertex      p3;
-    Material    material;
-    char            texName[20];
-    float           min;
-    float           max;
-};      // length = 196 bytes
-
-struct OldModelTriangle2
-{
-    char            bUsed;      // TRUE -> used
-    char            bSelect;    // TRUE -> selected
-    Vertex      p1;
-    Vertex      p2;
-    Vertex      p3;
-    Material    material;
-    char            texName[20];
-    float           min;
-    float           max;
-    long            state;
-    short           reserve1;
-    short           reserve2;
-    short           reserve3;
-    short           reserve4;
-};
-
-struct ModelTriangle
-{
-    char            bUsed;      // TRUE -> used
-    char            bSelect;    // TRUE -> selected
-    VertexTex2      p1;
-    VertexTex2      p2;
-    VertexTex2      p3;
-    Material    material;
-    char            texName[20];
-    float           min;
-    float           max;
-    long            state;
-    short           texNum2;
-    short           reserve2;
-    short           reserve3;
-    short           reserve4;
-};      // length = 208 bytes
-
-
-
-
-class CModFile {
-public:
-    CModFile(CInstanceManager* iMan);
-    ~CModFile();
-
-    bool            ReadDXF(char *filename, float min, float max);
-    bool            AddModel(char *filename, int first, bool bEdit=false, bool bMeta=true);
-    bool            ReadModel(char *filename, bool bEdit=false, bool bMeta=true);
-    bool            WriteModel(char *filename);
-
-    bool            CreateEngineObject(int objRank, int addState=0);
-    void            Mirror();
-
-    void            SetTriangleUsed(int total);
-    int             RetTriangleUsed();
-    int             RetTriangleMax();
-    ModelTriangle*  RetTriangleList();
-
-    float           RetHeight(Math::Vector pos);
-
-protected:
-    bool            CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max);
-
-protected:
-    CInstanceManager* m_iMan;
-    CEngine*        m_engine;
-
-    ModelTriangle*  m_triangleTable;
-    int             m_triangleUsed;
-};
-
-};
diff --git a/src/graphics/common/vertex.h b/src/graphics/common/vertex.h
deleted file mode 100644
index 0cc6402..0000000
--- a/src/graphics/common/vertex.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// vertex.h
-
-#pragma once
-
-
-#include "math/vector.h"
-#include "math/point.h"
-
-namespace Gfx {
-
-/**
- * \struct Vertex
- * \brief Vertex of a primitive
- *
- * This structure was created as analog to DirectX's D3DVERTEX.
- *
- * It contains:
- *  - vertex coordinates (x,y,z) as Math::Vector,
- *  - normal coordinates (nx,ny,nz) as Math::Vector
- *  - texture coordinates (u,v) as Math::Point.
- */
-struct Vertex
-{
-    Math::Vector coord;
-    Math::Vector normal;
-    Math::Point texCoord;
-
-    Vertex(Math::Vector aCoord = Math::Vector(),
-           Math::Vector aNormal = Math::Vector(),
-           Math::Point aTexCoord = Math::Point())
-        : coord(aCoord), normal(aNormal), texCoord(aTexCoord) {}
-};
-
-/**
- * \struct VertexTex2
- * \brief Vertex with secondary texture coordinates
- *
- * In addition to fields from Gfx::Vector, it contains
- * secondary texture coordinates (u2, v2) as Math::Point
- */
-struct VertexTex2 : public Gfx::Vertex
-{
-    Math::Point texCoord2;
-
-    VertexTex2(Math::Vector aCoord = Math::Vector(),
-               Math::Vector aNormal = Math::Vector(),
-               Math::Point aTexCoord = Math::Point(),
-               Math::Point aTexCoord2 = Math::Point())
-        : Vertex(aCoord, aNormal, aTexCoord), texCoord2(aTexCoord2) {}
-};
-
-}; // namespace Gfx
diff --git a/src/graphics/core/README.txt b/src/graphics/core/README.txt
new file mode 100644
index 0000000..12beef9
--- /dev/null
+++ b/src/graphics/core/README.txt
@@ -0,0 +1,6 @@
+src/graphics/core
+
+Abstract core of graphics engine
+
+Core types, enums, structs and CDevice abstract class that define
+the abstract graphics device used in graphics engine
diff --git a/src/graphics/core/color.cpp b/src/graphics/core/color.cpp
new file mode 100644
index 0000000..f241227
--- /dev/null
+++ b/src/graphics/core/color.cpp
@@ -0,0 +1,103 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// color.cpp
+
+#include "graphics/core/color.h"
+
+#include "math/func.h"
+
+
+Gfx::ColorHSV Gfx::RGB2HSV(Gfx::Color color)
+{
+    Gfx::ColorHSV result;
+
+    float min = Math::Min(color.r, color.g, color.b);
+    float max = Math::Max(color.r, color.g, color.b);
+
+    result.v = max;  // intensity
+
+    if ( max == 0.0f )
+    {
+        result.s = 0.0f;  // saturation
+        result.h = 0.0f;  // undefined color!
+    }
+    else
+    {
+        float delta = max-min;
+        result.s = delta/max;  // saturation
+
+        if ( color.r == max )  // between yellow & magenta
+        {
+        result.h = (color.g-color.b)/delta;
+        }
+        else if ( color.g == max )  // between cyan & yellow
+        {
+        result.h = 2.0f+(color.b-color.r)/delta;
+        }
+        else  // between magenta & cyan
+        {
+        result.h = 4.0f+(color.r-color.g)/delta;
+        }
+
+        result.h *= 60.0f;  // in degrees
+        if ( result.h < 0.0f )  result.h += 360.0f;
+        result.h /= 360.0f;  // 0..1
+    }
+
+    return result;
+}
+
+Gfx::Color Gfx::HSV2RGB(Gfx::ColorHSV color)
+{
+    Gfx::Color result;
+
+    color.h = Math::Norm(color.h)*360.0f;
+    color.s = Math::Norm(color.s);
+    color.v = Math::Norm(color.v);
+
+    if ( color.s == 0.0f )  // zero saturation?
+    {
+        result.r = color.v;
+        result.g = color.v;
+        result.b = color.v;  // gray
+    }
+    else
+    {
+        if ( color.h == 360.0f )  color.h = 0.0f;
+        color.h /= 60.0f;
+        int i = static_cast<int>(color.h);  // integer part (0 .. 5)
+        float f = color.h-i;   // fractional part
+
+        float v = color.v;
+        float p = color.v*(1.0f-color.s);
+        float q = color.v*(1.0f-(color.s*f));
+        float t = color.v*(1.0f-(color.s*(1.0f-f)));
+
+        switch (i)
+        {
+        case 0:  result.r=v; result.g=t; result.b=p;  break;
+        case 1:  result.r=q; result.g=v; result.b=p;  break;
+        case 2:  result.r=p; result.g=v; result.b=t;  break;
+        case 3:  result.r=p; result.g=q; result.b=v;  break;
+        case 4:  result.r=t; result.g=p; result.b=v;  break;
+        case 5:  result.r=v; result.g=p; result.b=q;  break;
+        }
+    }
+
+    return result;
+}
+
diff --git a/src/graphics/core/color.h b/src/graphics/core/color.h
new file mode 100644
index 0000000..6973644
--- /dev/null
+++ b/src/graphics/core/color.h
@@ -0,0 +1,98 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// color.h
+
+#pragma once
+
+
+#include <sstream>
+
+
+namespace Gfx {
+
+/**
+  \struct Color
+  \brief RGBA color */
+struct Color
+{
+    //! Red, green, blue and alpha components
+    float r, g, b, a;
+
+    //! Constructor; default values are (0,0,0,0) = black
+    Color(float aR = 0.0f, float aG = 0.0f, float aB = 0.0f, float aA = 0.0f)
+     : r(aR), g(aG), b(aB), a(aA) {}
+
+    inline Gfx::Color Inverse() const
+    {
+        return Gfx::Color(1.0f - r, 1.0f - g, 1.0f - b, 1.0f - a);
+    }
+
+    //! Returns the struct cast to \c float* array; use with care!
+    inline float* Array()
+    {
+        return reinterpret_cast<float*>(this);
+    }
+
+    //! Returns the struct cast to <tt>const float*</tt> array; use with care!
+    inline const float* Array() const
+    {
+        return reinterpret_cast<const float*>(this);
+    }
+
+    //! Returns a string (r, g, b, a)
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "(" << r << ", " << g << ", " << b << ", " << a << ")";
+        return s.str();
+    }
+
+    inline bool operator==(const Gfx::Color &other) const
+    {
+        return r == other.r && g == other.g && b == other.b && a == other.a;
+    }
+};
+
+/**
+  \struct ColorHSV
+  \brief HSV color */
+struct ColorHSV
+{
+    float h, s, v;
+
+    ColorHSV(float aH = 0.0f, float aS = 0.0f, float aV = 0.0f)
+     : h(aH), s(aS), v(aV) {}
+
+     //! Returns a string "(h, s, v)"
+     inline std::string ToString() const
+     {
+        std::stringstream s;
+        s.precision(3);
+        s << "(" << h << ", " << s << ", " << v << ")";
+        return s.str();
+     }
+};
+
+//! Converts a RGB color to HSV color
+Gfx::ColorHSV RGB2HSV(Gfx::Color color);
+
+//! Converts a HSV color to RGB color
+Gfx::Color HSV2RGB(Gfx::ColorHSV color);
+
+}; // namespace Gfx
+
diff --git a/src/graphics/core/device.h b/src/graphics/core/device.h
new file mode 100644
index 0000000..c10b853
--- /dev/null
+++ b/src/graphics/core/device.h
@@ -0,0 +1,412 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// device.h
+
+#pragma once
+
+
+#include "graphics/core/color.h"
+#include "graphics/core/light.h"
+#include "graphics/core/material.h"
+#include "graphics/core/texture.h"
+#include "graphics/core/vertex.h"
+#include "math/intsize.h"
+#include "math/matrix.h"
+
+#include <string>
+
+
+class CImage;
+
+
+namespace Gfx {
+
+/**
+  \struct DeviceConfig
+  \brief General config for graphics device
+
+  These settings are common window options set by SDL.
+*/
+struct DeviceConfig
+{
+    //! Screen size
+    Math::IntSize size;
+    //! Bits per pixel
+    int bpp;
+    //! Full screen
+    bool fullScreen;
+    //! Resizeable window
+    bool resizeable;
+    //! Double buffering
+    bool doubleBuf;
+    //! No window frame (also set with full screen)
+    bool noFrame;
+
+    //! Constructor calls LoadDefault()
+    DeviceConfig() { LoadDefault(); }
+
+    //! Loads the default values
+    inline void LoadDefault()
+    {
+        size = Math::IntSize(800, 600);
+        bpp = 32;
+        fullScreen = false;
+        resizeable = false;
+        doubleBuf = true;
+        noFrame = false;
+    }
+};
+
+
+/**
+  \enum TransformType
+  \brief Type of transformation in rendering pipeline
+
+  These correspond to DirectX's three transformation matrices. */
+enum TransformType
+{
+    TRANSFORM_WORLD,
+    TRANSFORM_VIEW,
+    TRANSFORM_PROJECTION
+};
+
+/**
+  \enum RenderState
+  \brief Render states that can be enabled/disabled */
+enum RenderState
+{
+    RENDER_STATE_LIGHTING,
+    RENDER_STATE_TEXTURING,
+    RENDER_STATE_BLENDING,
+    RENDER_STATE_FOG,
+    RENDER_STATE_DEPTH_TEST,
+    RENDER_STATE_DEPTH_WRITE,
+    RENDER_STATE_ALPHA_TEST,
+    RENDER_STATE_CULLING,
+    RENDER_STATE_DITHERING
+};
+
+/**
+  \enum CompFunc
+  \brief Type of function used to compare values */
+enum CompFunc
+{
+    COMP_FUNC_NEVER,
+    COMP_FUNC_LESS,
+    COMP_FUNC_EQUAL,
+    COMP_FUNC_NOTEQUAL,
+    COMP_FUNC_LEQUAL,
+    COMP_FUNC_GREATER,
+    COMP_FUNC_GEQUAL,
+    COMP_FUNC_ALWAYS
+};
+
+/**
+  \enum BlendFunc
+  \brief Type of blending function */
+enum BlendFunc
+{
+    BLEND_ZERO,
+    BLEND_ONE,
+    BLEND_SRC_COLOR,
+    BLEND_INV_SRC_COLOR,
+    BLEND_DST_COLOR,
+    BLEND_INV_DST_COLOR,
+    BLEND_SRC_ALPHA,
+    BLEND_INV_SRC_ALPHA,
+    BLEND_DST_ALPHA,
+    BLEND_INV_DST_ALPHA,
+    BLEND_SRC_ALPHA_SATURATE
+};
+
+/**
+  \enum FogMode
+  \brief Type of fog calculation function */
+enum FogMode
+{
+    FOG_LINEAR,
+    FOG_EXP,
+    FOG_EXP2
+};
+
+/**
+  \enum CullMode
+  \brief Culling mode for polygons */
+enum CullMode
+{
+    //! Cull clockwise side
+    CULL_CW,
+    //! Cull counter-clockwise side
+    CULL_CCW
+};
+
+/**
+  \enum ShadeModel
+  \brief Shade model used in rendering */
+enum ShadeModel
+{
+    SHADE_FLAT,
+    SHADE_SMOOTH
+};
+
+/**
+  \enum FillMode
+  \brief Polygon fill mode */
+enum FillMode
+{
+    //! Draw only points
+    FILL_POINT,
+    //! Draw only lines
+    FILL_LINES,
+    //! Draw full polygons
+    FILL_FILL
+};
+
+/**
+  \enum PrimitiveType
+  \brief Type of primitive to render */
+enum PrimitiveType
+{
+    PRIMITIVE_POINTS,
+    PRIMITIVE_LINES,
+    PRIMITIVE_LINE_STRIP,
+    PRIMITIVE_TRIANGLES,
+    PRIMITIVE_TRIANGLE_STRIP
+};
+
+/**
+  \enum IntersectPlane
+  \brief Intersection plane of projection volume
+
+  These flags can be OR'd together. */
+enum IntersectPlane
+{
+    INTERSECT_PLANE_LEFT   = 0x01,
+    INTERSECT_PLANE_RIGHT  = 0x02,
+    INTERSECT_PLANE_TOP    = 0x04,
+    INTERSECT_PLANE_BOTTOM = 0x08,
+    INTERSECT_PLANE_FRONT  = 0x10,
+    INTERSECT_PLANE_BACK   = 0x20,
+    INTERSECT_PLANE_ALL = INTERSECT_PLANE_LEFT   | INTERSECT_PLANE_RIGHT  |
+                          INTERSECT_PLANE_TOP    | INTERSECT_PLANE_BOTTOM |
+                          INTERSECT_PLANE_FRONT  | INTERSECT_PLANE_BACK
+};
+
+/*
+
+Notes for rewriting DirectX code:
+
+>> SetRenderState() translates to many functions depending on param
+
+D3DRENDERSTATE_ALPHABLENDENABLE    -> SetRenderState() with RENDER_STATE_BLENDING
+D3DRENDERSTATE_ALPHAFUNC           -> SetAlphaTestFunc() func
+D3DRENDERSTATE_ALPHAREF            -> SetAlphaTestFunc() ref
+D3DRENDERSTATE_ALPHATESTENABLE     -> SetRenderState() with RENDER_STATE_ALPHA_TEST
+D3DRENDERSTATE_AMBIENT             -> SetGlobalAmbient()
+D3DRENDERSTATE_CULLMODE            -> SetCullMode()
+D3DRENDERSTATE_DESTBLEND           -> SetBlendFunc() dest blending func
+D3DRENDERSTATE_DITHERENABLE        -> SetRenderState() with RENDER_STATE_DITHERING
+D3DRENDERSTATE_FILLMODE            -> SetFillMode()
+D3DRENDERSTATE_FOGCOLOR            -> SetFogParams()
+D3DRENDERSTATE_FOGENABLE           -> SetRenderState() with RENDER_STATE_FOG
+D3DRENDERSTATE_FOGEND              -> SetFogParams()
+D3DRENDERSTATE_FOGSTART            -> SetFogParams()
+D3DRENDERSTATE_FOGVERTEXMODE       -> SetFogParams() fog model
+D3DRENDERSTATE_LIGHTING            -> SetRenderState() with RENDER_STATE_LIGHTING
+D3DRENDERSTATE_SHADEMODE           -> SetShadeModel()
+D3DRENDERSTATE_SPECULARENABLE      -> doesn't matter (always enabled)
+D3DRENDERSTATE_SRCBLEND            -> SetBlendFunc() src blending func
+D3DRENDERSTATE_TEXTUREFACTOR       -> SetTextureFactor()
+D3DRENDERSTATE_ZBIAS               -> SetDepthBias()
+D3DRENDERSTATE_ZENABLE             -> SetRenderState() with RENDER_STATE_DEPTH_TEST
+D3DRENDERSTATE_ZFUNC               -> SetDepthTestFunc()
+D3DRENDERSTATE_ZWRITEENABLE        -> SetRenderState() with RENDER_STATE_DEPTH_WRITE
+
+
+>> SetTextureStageState() translates to SetTextureParams() or CreateTexture() for some params
+
+Params from enum in struct TextureCreateParams or TextureParams
+  D3DTSS_ADDRESS       -> Gfx::TexWrapMode wrapS, wrapT
+  D3DTSS_ALPHAARG1     -> Gfx::TexMixArgument alphaArg1
+  D3DTSS_ALPHAARG2     -> Gfx::TexMixArgument alphaArg2
+  D3DTSS_ALPHAOP       -> Gfx::TexMixOperation alphaOperation
+  D3DTSS_COLORARG1     -> Gfx::TexMixArgument colorArg1
+  D3DTSS_COLORARG2     -> Gfx::TexMixArgument colorArg2
+  D3DTSS_COLOROP       -> Gfx::TexMixOperation colorOperation
+  D3DTSS_MAGFILTER     -> Gfx::TexMagFilter magFilter
+  D3DTSS_MINFILTER     -> Gfx::TexMinFilter minFilter
+  D3DTSS_TEXCOORDINDEX -> doesn't matter (texture coords are set explicitly by glMultiTexCoordARB*)
+
+Note that D3DTSS_ALPHAOP or D3DTSS_COLOROP set to D3DTOP_DISABLE must translate to disabling the whole texture stage.
+In DirectX, you shouldn't mix enabling one and disabling the other.
+Also, if previous stage is disabled in DirectX, the later ones are disabled, too. In OpenGL, that is not the case.
+
+*/
+
+/**
+  \class CDevice
+  \brief Abstract interface of graphics device
+
+  It is based on DIRECT3DDEVICE class from DirectX to make it easier to port existing code.
+  It encapsulates the general graphics device state and provides a common interface
+  to graphics-specific functions which will be used throughout the program,
+  both in CEngine class and in UI classes. Note that it doesn't contain all functions from DirectX,
+  only those that were used in old code.
+
+ */
+class CDevice
+{
+public:
+    virtual ~CDevice() {}
+
+    //! Initializes the device, setting the initial state
+    virtual bool Create() = 0;
+    //! Destroys the device, releasing every acquired resource
+    virtual void Destroy() = 0;
+
+    //! Returns whether the device has been initialized
+    virtual bool GetWasInit() = 0;
+    //! Returns the last encountered error
+    virtual std::string GetError() = 0;
+
+    //! Begins drawing the 3D scene
+    virtual void BeginScene() = 0;
+    //! Ends drawing the 3D scene
+    virtual void EndScene() = 0;
+
+    //! Clears the screen to blank
+    virtual void Clear() = 0;
+
+    //! Sets the transform matrix of given type
+    virtual void SetTransform(TransformType type, const Math::Matrix &matrix) = 0;
+    //! Returns the current transform matrix of given type
+    virtual const Math::Matrix& GetTransform(TransformType type) = 0;
+    //! Multiplies the current transform matrix of given type by given matrix
+    virtual void MultiplyTransform(TransformType type, const Math::Matrix &matrix) = 0;
+
+    //! Sets the current material
+    virtual void SetMaterial(const Gfx::Material &material) = 0;
+    //! Returns the current material
+    virtual const Gfx::Material& GetMaterial() = 0;
+
+    //! Returns the maximum number of lights available
+    virtual int GetMaxLightCount() = 0;
+    //! Sets the light at given index
+    virtual void SetLight(int index, const Gfx::Light &light) = 0;
+    //! Returns the current light at given index
+    virtual const Gfx::Light& GetLight(int index) = 0;
+    //! Enables/disables the light at given index
+    virtual void SetLightEnabled(int index, bool enabled) = 0;
+    //! Returns the current enable state of light at given index
+    virtual bool GetLightEnabled(int index) = 0;
+
+    //! Creates a texture from image; the image can be safely removed after that
+    virtual Gfx::Texture CreateTexture(CImage *image, const Gfx::TextureCreateParams &params) = 0;
+    //! Deletes a given texture, freeing it from video memory
+    virtual void DestroyTexture(const Gfx::Texture &texture) = 0;
+    //! Deletes all textures created so far
+    virtual void DestroyAllTextures() = 0;
+
+    //! Returns the maximum number of multitexture stages
+    virtual int GetMaxTextureCount() = 0;
+    //! Sets the (multi)texture at given index
+    virtual void SetTexture(int index, const Gfx::Texture &texture) = 0;
+    //! Returns the (multi)texture at given index
+    virtual Gfx::Texture GetTexture(int index) = 0;
+    //! Enables/disables the given texture stage
+    virtual void SetTextureEnabled(int index, bool enabled) = 0;
+    //! Returns the current enable state of given texture stage
+    virtual bool GetTextureEnabled(int index) = 0;
+
+    //! Sets the params for texture stage with given index
+    virtual void SetTextureStageParams(int index, const Gfx::TextureStageParams &params) = 0;
+    //! Returns the current params of texture stage with given index
+    virtual Gfx::TextureStageParams GetTextureStageParams(int index) = 0;
+
+    //! Sets the texture factor to the given color value
+    virtual void SetTextureFactor(const Gfx::Color &color) = 0;
+    //! Returns the current texture factor
+    virtual Gfx::Color GetTextureFactor() = 0;
+
+    //! Renders primitive composed of vertices with single texture
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::Vertex *vertices    , int vertexCount) = 0;
+    //! Renders primitive composed of vertices with color information and single texture
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexCol *vertices , int vertexCount) = 0;
+    //! Renders primitive composed of vertices with multitexturing (2 textures)
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexTex2 *vertices, int vertexCount) = 0;
+
+    //! Tests whether a sphere intersects the 6 clipping planes of projection volume
+    virtual int ComputeSphereVisibility(const Math::Vector &center, float radius) = 0;
+
+    //! Enables/disables the given render state
+    virtual void SetRenderState(Gfx::RenderState state, bool enabled) = 0;
+    //! Returns the current setting of given render state
+    virtual bool GetRenderState(Gfx::RenderState state) = 0;
+
+    //! Sets the function of depth test
+    virtual void SetDepthTestFunc(Gfx::CompFunc func) = 0;
+    //! Returns the current function of depth test
+    virtual Gfx::CompFunc GetDepthTestFunc() = 0;
+
+    //! Sets the depth bias (constant value added to Z-coords)
+    virtual void SetDepthBias(float factor) = 0;
+    //! Returns the current depth bias
+    virtual float GetDepthBias() = 0;
+
+    //! Sets the alpha test function and reference value
+    virtual void SetAlphaTestFunc(Gfx::CompFunc func, float refValue) = 0;
+    //! Returns the current alpha test function and reference value
+    virtual void GetAlphaTestFunc(Gfx::CompFunc &func, float &refValue) = 0;
+
+    //! Sets the blending functions for source and destination operations
+    virtual void SetBlendFunc(Gfx::BlendFunc srcBlend, Gfx::BlendFunc dstBlend) = 0;
+    //! Returns the current blending functions for source and destination operations
+    virtual void GetBlendFunc(Gfx::BlendFunc &srcBlend, Gfx::BlendFunc &dstBlend) = 0;
+
+    //! Sets the clear color
+    virtual void SetClearColor(const Gfx::Color &color) = 0;
+    //! Returns the current clear color
+    virtual Gfx::Color GetClearColor() = 0;
+
+    //! Sets the global ambient color
+    virtual void SetGlobalAmbient(const Gfx::Color &color) = 0;
+    //! Returns the global ambient color
+    virtual Gfx::Color GetGlobalAmbient() = 0;
+
+    //! Sets the fog parameters: mode, color, start distance, end distance and density (for exp models)
+    virtual void SetFogParams(Gfx::FogMode mode, const Gfx::Color &color, float start, float end, float density) = 0;
+    //! Returns the current fog parameters: mode, color, start distance, end distance and density (for exp models)
+    virtual void GetFogParams(Gfx::FogMode &mode, Gfx::Color &color, float &start, float &end, float &density) = 0;
+
+    //! Sets the current cull mode
+    virtual void SetCullMode(Gfx::CullMode mode) = 0;
+    //! Returns the current cull mode
+    virtual Gfx::CullMode GetCullMode() = 0;
+
+    //! Sets the shade model
+    virtual void SetShadeModel(Gfx::ShadeModel model) = 0;
+    //! Returns the current shade model
+    virtual Gfx::ShadeModel GetShadeModel() = 0;
+
+    //! Sets the current fill mode
+    virtual void SetFillMode(Gfx::FillMode mode) = 0;
+    //! Returns the current fill mode
+    virtual Gfx::FillMode GetFillMode() = 0;
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/core/light.h b/src/graphics/core/light.h
new file mode 100644
index 0000000..b787cb2
--- /dev/null
+++ b/src/graphics/core/light.h
@@ -0,0 +1,91 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// light.h
+
+#pragma once
+
+
+#include "graphics/core/color.h"
+#include "math/vector.h"
+
+
+namespace Gfx {
+
+/**
+  \enum LightType
+  \brief Type of light in 3D scene */
+enum LightType
+{
+    LIGHT_POINT,
+    LIGHT_SPOT,
+    LIGHT_DIRECTIONAL
+};
+
+/**
+  \struct Light
+  \brief Properties of light in 3D scene
+
+  This structure was created as analog to DirectX's D3DLIGHT. */
+struct Light
+{
+    //! Type of light source
+    Gfx::LightType  type;
+    //! Color of ambient light
+    Gfx::Color      ambient;
+    //! Color of diffuse light
+    Gfx::Color      diffuse;
+    //! Color of specular light
+    Gfx::Color      specular;
+    //! Position in world space (for point & spot lights)
+    Math::Vector    position;
+    //! Direction in world space (for directional & spot lights)
+    Math::Vector    direction;
+    //! Constant attenuation factor
+    float           attenuation0;
+    //! Linear attenuation factor
+    float           attenuation1;
+    //! Quadratic attenuation factor
+    float           attenuation2;
+    //! Angle of spotlight cone (0-90 degrees)
+    float           spotAngle;
+    //! Intensity of spotlight (0 = uniform; 128 = most intense)
+    float           spotIntensity;
+
+    //! Constructor; calls LoadDefault()
+    Light()
+    {
+        LoadDefault();
+    }
+
+    //! Loads default values
+    void LoadDefault()
+    {
+        type = LIGHT_POINT;
+        ambient = Gfx::Color(0.4f, 0.4f, 0.4f);
+        diffuse = Gfx::Color(0.8f, 0.8f, 0.8f);
+        specular = Gfx::Color(1.0f, 1.0f, 1.0f);
+        position = Math::Vector(0.0f, 0.0f, 0.0f);
+        direction = Math::Vector(0.0f, 0.0f, 1.0f);
+        attenuation0 = 1.0f;
+        attenuation1 = attenuation2 = 0.0f;
+        spotAngle = 90.0f;
+        spotIntensity = 0.0f;
+    }
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/common/material.h b/src/graphics/core/material.h
index f71923f..31b42f3 100644
--- a/src/graphics/common/material.h
+++ b/src/graphics/core/material.h
@@ -19,6 +19,9 @@
 #pragma once
 
 
+#include "graphics/core/color.h"
+
+
 namespace Gfx {
 
 /**
diff --git a/src/graphics/core/texture.h b/src/graphics/core/texture.h
new file mode 100644
index 0000000..8d6b082
--- /dev/null
+++ b/src/graphics/core/texture.h
@@ -0,0 +1,237 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// texture.h
+
+#pragma once
+
+#include "math/intsize.h"
+
+
+namespace Gfx {
+
+/**
+  \enum TexImgFormat
+  \brief Format of image data */
+enum TexImgFormat
+{
+    //! Try to determine automatically (may not work)
+    TEX_IMG_AUTO,
+    //! RGB triplet, 3 bytes
+    TEX_IMG_RGB,
+    //! BGR triplet, 3 bytes
+    TEX_IMG_BGR,
+    //! RGBA triplet, 4 bytes
+    TEX_IMG_RGBA,
+    //! BGRA triplet, 4 bytes
+    TEX_IMG_BGRA
+};
+
+/**
+  \enum TexMinFilter
+  \brief Texture minification filter
+
+  Corresponds to OpenGL modes but should translate to DirectX too. */
+enum TexMinFilter
+{
+    TEX_MIN_FILTER_NEAREST,
+    TEX_MIN_FILTER_LINEAR,
+    TEX_MIN_FILTER_NEAREST_MIPMAP_NEAREST,
+    TEX_MIN_FILTER_LINEAR_MIPMAP_NEAREST,
+    TEX_MIN_FILTER_NEAREST_MIPMAP_LINEAR,
+    TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR
+};
+
+/**
+  \enum TexMagFilter
+  \brief Texture magnification filter */
+enum TexMagFilter
+{
+    TEX_MAG_FILTER_NEAREST,
+    TEX_MAG_FILTER_LINEAR
+};
+
+/**
+  \enum TexWrapMode
+  \brief Wrapping mode for texture coords */
+enum TexWrapMode
+{
+    TEX_WRAP_CLAMP,
+    TEX_WRAP_REPEAT
+};
+
+/**
+  \enum TexMixOperation
+  \brief Multitexture mixing operation */
+enum TexMixOperation
+{
+    //! Default operation on default params (modulate on computed & texture)
+    TEX_MIX_OPER_DEFAULT,
+    //! = Arg1
+    TEX_MIX_OPER_REPLACE,
+    //! = Arg1 * Arg2
+    TEX_MIX_OPER_MODULATE,
+    //! = Arg1 + Arg2
+    TEX_MIX_OPER_ADD,
+    //! = Arg1 - Arg2
+    TEX_MIX_OPER_SUBTRACT
+};
+
+/**
+  \enum TexMixArgument
+  \brief Multitexture mixing argument */
+enum TexMixArgument
+{
+    //! Color from current texture
+    TEX_MIX_ARG_TEXTURE,
+    //! Color computed by previous texture unit (current in DirectX; previous in OpenGL)
+    TEX_MIX_ARG_COMPUTED_COLOR,
+    //! (Source) color of textured fragment (diffuse in DirectX; primary color in OpenGL)
+    TEX_MIX_ARG_SRC_COLOR,
+    //! Constant color (texture factor in DirectX; texture env color in OpenGL)
+    TEX_MIX_ARG_FACTOR
+};
+
+/**
+  \struct TextureCreateParams
+  \brief Parameters for texture creation
+
+  These params define how particular texture is created and later displayed.
+  They must be specified at texture creation time and cannot be changed later. */
+struct TextureCreateParams
+{
+    //! Whether to generate mipmaps
+    bool mipmap;
+    //! Format of source image data
+    Gfx::TexImgFormat format;
+    //! Minification filter
+    Gfx::TexMinFilter minFilter;
+    //! Magnification filter
+    Gfx::TexMagFilter magFilter;
+
+    //! Constructor; calls LoadDefault()
+    TextureCreateParams()
+        { LoadDefault(); }
+
+    //! Loads the default values
+    inline void LoadDefault()
+    {
+        format = Gfx::TEX_IMG_RGB;
+        mipmap = false;
+
+        minFilter = Gfx::TEX_MIN_FILTER_NEAREST;
+        magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
+    }
+};
+
+/**
+  \struct TextureStageParams
+  \brief Parameters for a texture unit
+
+  These params define the behavior of texturing units (stages).
+  They can be changed freely and are feature of graphics engine, not any particular texture. */
+struct TextureStageParams
+{
+    //! Mixing operation done on color values
+    Gfx::TexMixOperation colorOperation;
+    //! 1st argument of color operations
+    Gfx::TexMixArgument colorArg1;
+    //! 2nd argument of color operations
+    Gfx::TexMixArgument colorArg2;
+    //! Mixing operation done on alpha values
+    Gfx::TexMixOperation alphaOperation;
+    //! 1st argument of alpha operations
+    Gfx::TexMixArgument alphaArg1;
+    //! 2nd argument of alpha operations
+    Gfx::TexMixArgument alphaArg2;
+    //! Wrap mode for 1st tex coord
+    Gfx::TexWrapMode    wrapS;
+    //! Wrap mode for 2nd tex coord
+    Gfx::TexWrapMode    wrapT;
+
+    //! Constructor; calls LoadDefault()
+    TextureStageParams()
+        { LoadDefault(); }
+
+    //! Loads the default values
+    inline void LoadDefault()
+    {
+        colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+        colorArg1 = Gfx::TEX_MIX_ARG_COMPUTED_COLOR;
+        colorArg2 = Gfx::TEX_MIX_ARG_TEXTURE;
+
+        alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+        alphaArg1 = Gfx::TEX_MIX_ARG_COMPUTED_COLOR;
+        alphaArg2 = Gfx::TEX_MIX_ARG_TEXTURE;
+
+        wrapS = wrapT = Gfx::TEX_WRAP_REPEAT;
+    }
+};
+
+/**
+  \struct Texture
+  \brief Info about a texture
+
+  Identifies (through id) a texture created in graphics engine.
+  Also contains some additional data. */
+struct Texture
+{
+    //! Whether the texture (ID) is valid
+    bool valid;
+    //! ID of the texture in graphics engine
+    unsigned int id;
+    //! Size of texture
+    Math::IntSize size;
+    //! Whether the texture has alpha channel
+    bool alpha;
+
+    Texture()
+    {
+        valid = false;
+        id = 0;
+        alpha = false;
+    }
+
+    //! Comparator for use in texture maps and sets
+    inline bool operator<(const Gfx::Texture &other) const
+    {
+        // Invalid textures are always "less than" every other texture
+
+        if ( (!valid) && (!other.valid) )
+            return false;
+
+        if (!valid)
+            return true;
+
+        if (!other.valid)
+            return false;
+
+        return id < other.id;
+    }
+
+    //! Comparator
+    inline bool operator==(const Gfx::Texture &other) const
+    {
+        if (valid != other.valid)
+            return false;
+        if ( (!valid) && (!other.valid) )
+            return true;
+
+        return id == other.id;
+    }
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/core/vertex.h b/src/graphics/core/vertex.h
new file mode 100644
index 0000000..b7fab1c
--- /dev/null
+++ b/src/graphics/core/vertex.h
@@ -0,0 +1,141 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// vertex.h
+
+#pragma once
+
+
+#include "graphics/core/color.h"
+#include "math/vector.h"
+#include "math/point.h"
+
+#include <sstream>
+
+namespace Gfx {
+
+/**
+ * \struct Vertex
+ * \brief Vertex of a primitive
+ *
+ * This structure was created as analog to DirectX's D3DVERTEX.
+ *
+ * It contains:
+ *  - vertex coordinates (x,y,z) as Math::Vector,
+ *  - normal coordinates (nx,ny,nz) as Math::Vector
+ *  - texture coordinates (u,v) as Math::Point.
+ */
+struct Vertex
+{
+    Math::Vector coord;
+    Math::Vector normal;
+    Math::Point texCoord;
+
+    Vertex(Math::Vector aCoord = Math::Vector(),
+           Math::Vector aNormal = Math::Vector(),
+           Math::Point aTexCoord = Math::Point())
+        : coord(aCoord), normal(aNormal), texCoord(aTexCoord) {}
+
+
+    //! Returns a string "(c: [...], n: [...], tc: [...])"
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "(c: " << coord.ToString() << ", n: " << normal.ToString()
+          << ", tc: " << texCoord.ToString() << ")";
+        return s.str();
+    }
+};
+
+/**
+ * \struct VertexCol
+ * \brief Vertex with color information
+ *
+ * This structure was created as analog to DirectX's D3DLVERTEX.
+ *
+ * It contains:
+ *  - vertex coordinates (x,y,z) as Math::Vector,
+ *  - RGBA color as Gfx::Color,
+ *  - RGBA specular color as Gfx::Color,
+ *  - texture coordinates (u,v) as Math::Point.
+ */
+struct VertexCol
+{
+    Math::Vector coord;
+    Gfx::Color color;
+    Gfx::Color specular;
+    Math::Point texCoord;
+
+    VertexCol(Math::Vector aCoord = Math::Vector(),
+              Gfx::Color aColor = Gfx::Color(),
+              Gfx::Color aSpecular = Gfx::Color(),
+              Math::Point aTexCoord = Math::Point())
+        : coord(aCoord), color(aColor), specular(aSpecular), texCoord(aTexCoord) {}
+
+    //! Returns a string "(c: [...], col: [...], sp: [...], tc: [...])"
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "(c: " << coord.ToString() << ", col: " << color.ToString() << ", sp: "
+          << specular.ToString() << ", tc: " << texCoord.ToString() << ")";
+        return s.str();
+    }
+};
+
+
+/**
+ * \struct VertexTex2
+ * \brief Vertex with secondary texture coordinates
+ *
+ * In addition to fields from Gfx::Vector, it contains
+ * secondary texture coordinates (u2, v2) as Math::Point
+ */
+struct VertexTex2
+{
+    Math::Vector coord;
+    Math::Vector normal;
+    Math::Point texCoord;
+    Math::Point texCoord2;
+
+    VertexTex2(Math::Vector aCoord = Math::Vector(),
+               Math::Vector aNormal = Math::Vector(),
+               Math::Point aTexCoord = Math::Point(),
+               Math::Point aTexCoord2 = Math::Point())
+        : coord(aCoord), normal(aNormal), texCoord(aTexCoord), texCoord2(aTexCoord2) {}
+
+    //! Sets the fields from Gfx::Vertex with texCoord2 = (0,0)
+    void FromVertex(const Gfx::Vertex &v)
+    {
+        coord = v.coord;
+        normal = v.normal;
+        texCoord = v.texCoord;
+        texCoord2 = Math::Point();
+    }
+
+    //! Returns a string "(c: [...], n: [...], tc: [...], tc2: [...])"
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "(c: " << coord.ToString() << ", n: " << normal.ToString()
+          << ", tc: " << texCoord.ToString() << ", tc2: " << texCoord2.ToString() << ")";
+        return s.str();
+    }
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/engine/README.txt b/src/graphics/engine/README.txt
new file mode 100644
index 0000000..308b601
--- /dev/null
+++ b/src/graphics/engine/README.txt
@@ -0,0 +1,8 @@
+src/graphics/engine
+
+Graphics engine
+
+CEngine class and various other classes implementing the main features
+of graphics engine from model loading to decorative particles
+
+Graphics operations are done on abstract interface from src/graphics/core
diff --git a/src/graphics/engine/camera.cpp b/src/graphics/engine/camera.cpp
new file mode 100644
index 0000000..c7ca503
--- /dev/null
+++ b/src/graphics/engine/camera.cpp
@@ -0,0 +1,1664 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// camera.cpp
+
+#include "graphics/engine/camera.h"
+
+#include "common/iman.h"
+#include "graphics/engine/engine.h"
+#include "graphics/engine/terrain.h"
+#include "graphics/engine/water.h"
+#include "math/const.h"
+#include "math/geometry.h"
+#include "object/object.h"
+#include "physics/physics.h"
+
+
+//! Changes the level of transparency of an object and objects transported (battery & cargo)
+void SetTransparency(CObject* obj, float value)
+{
+    obj->SetTransparency(value);
+
+    CObject *fret = obj->GetFret();
+    if (fret != NULL)
+        fret->SetTransparency(value);
+
+    fret = obj->GetPower();
+    if (fret != NULL)
+        fret->SetTransparency(value);
+}
+
+
+
+Gfx::CCamera::CCamera(CInstanceManager* iMan)
+{
+    m_iMan = iMan;
+    m_iMan->AddInstance(CLASS_CAMERA, this);
+
+    m_engine  = static_cast<Gfx::CEngine*> ( m_iMan->SearchInstance(CLASS_ENGINE) );
+    m_terrain = static_cast<Gfx::CTerrain*>( m_iMan->SearchInstance(CLASS_TERRAIN) );
+    m_water   = static_cast<Gfx::CWater*>  ( m_iMan->SearchInstance(CLASS_WATER) );
+
+    m_type      = Gfx::CAM_TYPE_FREE;
+    m_smooth    = Gfx::CAM_SMOOTH_NORM;
+    m_cameraObj = 0;
+
+    m_eyeDistance = 10.0f;
+    m_initDelay   =  0.0f;
+
+    m_actualEye    = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_actualLookat = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_finalEye     = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_finalLookat  = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_normEye      = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_normLookat   = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_focus        = 1.0f;
+
+    m_rightDown      = false;
+    m_rightPosInit   = Math::Point(0.5f, 0.5f);
+    m_rightPosCenter = Math::Point(0.5f, 0.5f);
+    m_rightPosMove   = Math::Point(0.5f, 0.5f);
+
+    m_eyePt        = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_directionH   =  0.0f;
+    m_directionV   =  0.0f;
+    m_heightEye    = 20.0f;
+    m_heightLookat =  0.0f;
+    m_speed        =  2.0f;
+
+    m_backDist      = 0.0f;
+    m_backMin       = 0.0f;
+    m_addDirectionH = 0.0f;
+    m_addDirectionV = 0.0f;
+    m_transparency  = false;
+
+    m_fixDist       = 0.0f;
+    m_fixDirectionH = 0.0f;
+    m_fixDirectionV = 0.0f;
+
+    m_visitGoal       = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_visitDist       = 0.0f;
+    m_visitTime       = 0.0f;
+    m_visitType       = Gfx::CAM_TYPE_NULL;
+    m_visitDirectionH = 0.0f;
+    m_visitDirectionV = 0.0f;
+
+    m_editHeight = 40.0f;
+
+    m_remotePan  = 0.0f;
+    m_remoteZoom = 0.0f;
+
+    m_mouseDirH    = 0.0f;
+    m_mouseDirV    = 0.0f;
+    m_mouseMarging = 0.01f;
+
+    m_motorTurn = 0.0f;
+
+    m_centeringPhase    = Gfx::CAM_PHASE_NULL;
+    m_centeringAngleH   = 0.0f;
+    m_centeringAngleV   = 0.0f;
+    m_centeringDist     = 0.0f;
+    m_centeringCurrentH = 0.0f;
+    m_centeringCurrentV = 0.0f;
+    m_centeringTime     = 0.0f;
+    m_centeringProgress = 0.0f;
+
+    m_effectType     = Gfx::CAM_EFFECT_NULL;
+    m_effectPos      = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_effectForce    = 0.0f;
+    m_effectProgress = 0.0f;
+    m_effectOffset   = Math::Vector(0.0f, 0.0f, 0.0f);
+
+    m_scriptEye    = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_scriptLookat = Math::Vector(0.0f, 0.0f, 0.0f);
+
+    m_effect        = true;
+    m_cameraScroll  = true;
+    m_cameraInvertX = false;
+    m_cameraInvertY = false;
+}
+
+Gfx::CCamera::~CCamera()
+{
+}
+
+void Gfx::CCamera::SetEffect(bool enable)
+{
+    m_effect = enable;
+}
+
+void Gfx::CCamera::SetCameraScroll(bool scroll)
+{
+    m_cameraScroll = scroll;
+}
+
+void Gfx::CCamera::SetCameraInvertX(bool invert)
+{
+    m_cameraInvertX = invert;
+}
+
+void Gfx::CCamera::SetCameraInvertY(bool invert)
+{
+    m_cameraInvertY = invert;
+}
+
+float Gfx::CCamera::GetMotorTurn()
+{
+    if (m_type == Gfx::CAM_TYPE_BACK)
+        return m_motorTurn;
+    return 0.0f;
+}
+
+void Gfx::CCamera::Init(Math::Vector eye, Math::Vector lookat, float delay)
+{
+    m_initDelay = delay;
+
+    eye.y    += m_terrain->GetFloorLevel(eye,    true);
+    lookat.y += m_terrain->GetFloorLevel(lookat, true);
+
+    m_type = Gfx::CAM_TYPE_FREE;
+    m_eyePt = eye;
+
+    m_directionH = Math::RotateAngle(eye.x - lookat.x, eye.z - lookat.z) + Math::PI / 2.0f;
+    m_directionV = -Math::RotateAngle(Math::DistanceProjected(eye, lookat), eye.y - lookat.y);
+
+    m_eyeDistance = 10.0f;
+    m_heightLookat = 10.0f;
+    m_backDist = 30.0f;
+    m_backMin  = 10.0f;
+    m_addDirectionH = 0.0f;
+    m_addDirectionV = -Math::PI*0.05f;
+    m_fixDist = 50.0f;
+    m_fixDirectionH = Math::PI*0.25f;
+    m_fixDirectionV = -Math::PI*0.10f;
+    m_centeringPhase = Gfx::CAM_PHASE_NULL;
+    m_actualEye = m_eyePt;
+    m_actualLookat = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
+    m_finalEye = m_actualEye;
+    m_finalLookat = m_actualLookat;
+    m_scriptEye = m_actualEye;
+    m_scriptLookat = m_actualLookat;
+    m_focus = 1.00f;
+    m_remotePan  = 0.0f;
+    m_remoteZoom = 0.0f;
+
+    FlushEffect();
+    FlushOver();
+    SetType(Gfx::CAM_TYPE_FREE);
+}
+
+
+void Gfx::CCamera::SetObject(CObject* object)
+{
+    m_cameraObj = object;
+}
+
+CObject* Gfx::CCamera::GetObject()
+{
+    return m_cameraObj;
+}
+
+void Gfx::CCamera::SetType(CameraType type)
+{
+    m_remotePan  = 0.0f;
+    m_remoteZoom = 0.0f;
+
+    if ( (m_type == Gfx::CAM_TYPE_BACK) && m_transparency )
+    {
+        for (int i = 0; i < 1000000; i++)
+        {
+            CObject* obj = static_cast<CObject*>( m_iMan->SearchInstance(CLASS_OBJECT, i) );
+            if (obj == NULL)
+                break;
+
+            if (obj->GetTruck())
+                continue;  // battery or cargo?
+
+            SetTransparency(obj, 0.0f);  // opaque object
+        }
+    }
+    m_transparency = false;
+
+    if (type == Gfx::CAM_TYPE_INFO  ||
+        type == Gfx::CAM_TYPE_VISIT)  // xx -> info ?
+    {
+        m_normEye    = m_engine->GetEyePt();
+        m_normLookat = m_engine->GetLookatPt();
+
+        m_engine->SetFocus(1.00f);  // normal
+        m_type = type;
+        return;
+    }
+
+    if (m_type == Gfx::CAM_TYPE_INFO  ||
+        m_type == Gfx::CAM_TYPE_VISIT)  // info -> xx ?
+    {
+        m_engine->SetFocus(m_focus);  // gives initial focus
+        m_type = type;
+
+        Math::Vector upVec = Math::Vector(0.0f, 1.0f, 0.0f);
+        SetViewParams(m_normEye, m_normLookat, upVec);
+        return;
+    }
+
+    if ( m_type == Gfx::CAM_TYPE_BACK && type == Gfx::CAM_TYPE_FREE )  // back -> free ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -50.0f);
+
+    if ( m_type == Gfx::CAM_TYPE_BACK && type == Gfx::CAM_TYPE_EDIT )  // back -> edit ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -1.0f);
+
+    if ( m_type == Gfx::CAM_TYPE_ONBOARD && type == Gfx::CAM_TYPE_FREE )  // onboard -> free ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -30.0f);
+
+    if ( m_type == Gfx::CAM_TYPE_ONBOARD && type == Gfx::CAM_TYPE_EDIT )  // onboard -> edit ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -30.0f);
+
+    if ( m_type == Gfx::CAM_TYPE_ONBOARD && type == Gfx::CAM_TYPE_EXPLO )  // onboard -> explo ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -50.0f);
+
+    if ( m_type == Gfx::CAM_TYPE_BACK && type == Gfx::CAM_TYPE_EXPLO )  // back -> explo ?
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, -20.0f);
+
+    if ( type == Gfx::CAM_TYPE_FIX   ||
+         type == Gfx::CAM_TYPE_PLANE )
+        AbortCentering();  // Special stops framing
+
+    m_fixDist = 50.0f;
+    if ( type == Gfx::CAM_TYPE_PLANE )
+        m_fixDist = 60.0f;
+
+    if ( type == Gfx::CAM_TYPE_BACK )
+    {
+        AbortCentering();  // Special stops framing
+        m_addDirectionH = 0.0f;
+        m_addDirectionV = -Math::PI*0.05f;
+
+        ObjectType oType;
+        if ( m_cameraObj == 0 )  oType = OBJECT_NULL;
+        else                     oType = m_cameraObj->GetType();
+
+        m_backDist = 30.0f;
+        if ( oType == OBJECT_BASE     )  m_backDist = 200.0f;
+        if ( oType == OBJECT_HUMAN    )  m_backDist =  20.0f;
+        if ( oType == OBJECT_TECH     )  m_backDist =  20.0f;
+        if ( oType == OBJECT_FACTORY  )  m_backDist =  50.0f;
+        if ( oType == OBJECT_RESEARCH )  m_backDist =  40.0f;
+        if ( oType == OBJECT_DERRICK  )  m_backDist =  40.0f;
+        if ( oType == OBJECT_REPAIR   )  m_backDist =  35.0f;
+        if ( oType == OBJECT_DESTROYER)  m_backDist =  35.0f;
+        if ( oType == OBJECT_TOWER    )  m_backDist =  45.0f;
+        if ( oType == OBJECT_NUCLEAR  )  m_backDist =  70.0f;
+        if ( oType == OBJECT_PARA     )  m_backDist = 180.0f;
+        if ( oType == OBJECT_SAFE     )  m_backDist =  50.0f;
+        if ( oType == OBJECT_HUSTON   )  m_backDist = 120.0f;
+
+        m_backMin = m_backDist/3.0f;
+        if ( oType == OBJECT_HUMAN    )  m_backMin =  10.0f;
+        if ( oType == OBJECT_TECH     )  m_backMin =  10.0f;
+        if ( oType == OBJECT_FACTORY  )  m_backMin =  30.0f;
+        if ( oType == OBJECT_RESEARCH )  m_backMin =  20.0f;
+        if ( oType == OBJECT_NUCLEAR  )  m_backMin =  32.0f;
+        if ( oType == OBJECT_PARA     )  m_backMin =  40.0f;
+        if ( oType == OBJECT_SAFE     )  m_backMin =  25.0f;
+        if ( oType == OBJECT_HUSTON   )  m_backMin =  80.0f;
+    }
+
+    if ( type != Gfx::CAM_TYPE_ONBOARD && m_cameraObj != 0 )
+        m_cameraObj->SetGunGoalH(0.0f);  // puts the cannon right
+
+    if ( type == Gfx::CAM_TYPE_ONBOARD )
+        m_focus = 1.50f;  // Wide
+    else
+        m_focus = 1.00f;  // normal
+    m_engine->SetFocus(m_focus);
+
+    m_type = type;
+
+    SetSmooth(Gfx::CAM_SMOOTH_NORM);
+}
+
+CameraType Gfx::CCamera::GetType()
+{
+    return m_type;
+}
+
+void Gfx::CCamera::SetSmooth(CameraSmooth type)
+{
+    m_smooth = type;
+}
+
+CameraSmooth Gfx::CCamera::GetSmoth()
+{
+    return m_smooth;
+}
+
+void Gfx::CCamera::SetDist(float dist)
+{
+    m_fixDist = dist;
+}
+
+float Gfx::CCamera::GetDist()
+{
+    return m_fixDist;
+}
+
+void Gfx::CCamera::SetFixDirection(float angle)
+{
+    m_fixDirectionH = angle;
+}
+
+float Gfx::CCamera::GetFixDirection()
+{
+    return m_fixDirectionH;
+}
+
+void Gfx::CCamera::SetRemotePan(float value)
+{
+    m_remotePan = value;
+}
+
+float Gfx::CCamera::GetRemotePan()
+{
+    return m_remotePan;
+}
+
+void Gfx::CCamera::SetRemoteZoom(float value)
+{
+    value = Math::Norm(value);
+
+    if ( m_type == Gfx::CAM_TYPE_BACK )
+        m_backDist = m_backMin + (200.0f - m_backMin) * value;
+
+    if ( m_type == Gfx::CAM_TYPE_FIX   ||
+         m_type == Gfx::CAM_TYPE_PLANE )
+        m_fixDist = 10.0f + (200.0f - 10.0f) * value;
+}
+
+float Gfx::CCamera::GetRemoteZoom()
+{
+    if ( m_type == Gfx::CAM_TYPE_BACK )
+        return (m_backDist - m_backMin) / (200.0f - m_backMin);
+
+    if ( m_type == Gfx::CAM_TYPE_FIX   ||
+         m_type == Gfx::CAM_TYPE_PLANE )
+        return (m_fixDist - 10.0f) / (200.0f - 10.0f);
+
+    return 0.0f;
+}
+
+void Gfx::CCamera::StartVisit(Math::Vector goal, float dist)
+{
+    m_visitType = m_type;
+    SetType(Gfx::CAM_TYPE_VISIT);
+    m_visitGoal = goal;
+    m_visitDist = dist;
+    m_visitTime = 0.0f;
+    m_visitDirectionH = 0.0f;
+    m_visitDirectionV = -Math::PI*0.10f;
+}
+
+void Gfx::CCamera::StopVisit()
+{
+    SetType(m_visitType);  // presents the initial type
+}
+
+void Gfx::CCamera::GetCamera(Math::Vector &eye, Math::Vector &lookat)
+{
+    eye = m_eyePt;
+    lookat = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
+}
+
+bool Gfx::CCamera::StartCentering(CObject *object, float angleH, float angleV,
+                             float dist, float time)
+{
+    if (m_type != Gfx::CAM_TYPE_BACK)
+        return false;
+    if (object != m_cameraObj)
+        return false;
+
+    if (m_centeringPhase != Gfx::CAM_PHASE_NULL)
+        return false;
+
+    if (m_addDirectionH > Math::PI)
+        angleH = Math::PI * 2.0f - angleH;
+
+    m_centeringPhase    = Gfx::CAM_PHASE_START;
+    m_centeringAngleH   = angleH;
+    m_centeringAngleV   = angleV;
+    m_centeringDist     = dist;
+    m_centeringCurrentH = 0.0f;
+    m_centeringCurrentV = 0.0f;
+    m_centeringTime     = time;
+    m_centeringProgress = 0.0f;
+
+    return true;
+}
+
+bool Gfx::CCamera::StopCentering(CObject *object, float time)
+{
+    if (m_type != Gfx::CAM_TYPE_BACK)
+        return false;
+    if (object != m_cameraObj)
+        return false;
+
+    if (m_centeringPhase != Gfx::CAM_PHASE_START &&
+        m_centeringPhase != Gfx::CAM_PHASE_WAIT)
+        return false;
+
+    m_centeringPhase = Gfx::CAM_PHASE_STOP;
+
+    if (m_centeringAngleH != 99.9f)
+        m_centeringAngleH = m_centeringCurrentH;
+
+    if (m_centeringAngleV != 99.9f)
+        m_centeringAngleV = m_centeringCurrentV;
+
+    m_centeringTime     = time;
+    m_centeringProgress = 0.0f;
+
+    return true;
+}
+
+void Gfx::CCamera::AbortCentering()
+{
+    if (m_type == Gfx::CAM_TYPE_INFO  ||
+        m_type == Gfx::CAM_TYPE_VISIT )
+        return;
+
+    if (m_centeringPhase == Gfx::CAM_PHASE_NULL)
+        return;
+
+    m_centeringPhase = Gfx::CAM_PHASE_NULL;
+
+    if ( m_centeringAngleH != 99.9f )
+        m_addDirectionH = m_centeringCurrentH;
+
+    if (m_centeringAngleV != 99.9f)
+        m_addDirectionV = m_centeringCurrentV;
+}
+
+void Gfx::CCamera::FlushEffect()
+{
+    m_effectType     = Gfx::CAM_EFFECT_NULL;
+    m_effectForce    = 0.0f;
+    m_effectProgress = 0.0f;
+    m_effectOffset   = Math::Vector(0.0f, 0.0f, 0.0f);
+}
+
+void Gfx::CCamera::StartEffect(CameraEffect effect, Math::Vector pos, float force)
+{
+    if ( !m_effect )  return;
+
+    m_effectType     = effect;
+    m_effectPos      = pos;
+    m_effectForce    = force;
+    m_effectProgress = 0.0f;
+}
+
+void Gfx::CCamera::EffectFrame(const Event &event)
+{
+    if (m_type == Gfx::CAM_TYPE_INFO  ||
+        m_type == Gfx::CAM_TYPE_VISIT)
+        return;
+
+    if (m_effectType == Gfx::CAM_EFFECT_NULL)
+        return;
+
+    m_effectOffset = Math::Vector(0.0f, 0.0f, 0.0f);
+
+    float force = m_effectForce;
+
+    if ( m_effectType == Gfx::CAM_EFFECT_TERRAFORM )
+    {
+        m_effectProgress += event.rTime * 0.7f;
+        m_effectOffset.x = (Math::Rand() - 0.5f) * 10.0f;
+        m_effectOffset.y = (Math::Rand() - 0.5f) * 10.0f;
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 10.0f;
+
+        force *= 1.0f-m_effectProgress;
+    }
+
+    if ( m_effectType == Gfx::CAM_EFFECT_EXPLO )
+    {
+        m_effectProgress += event.rTime * 1.0f;
+        m_effectOffset.x = (Math::Rand() - 0.5f)  *5.0f;
+        m_effectOffset.y = (Math::Rand() - 0.5f) * 5.0f;
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 5.0f;
+
+        force *= 1.0f-m_effectProgress;
+    }
+
+    if ( m_effectType == Gfx::CAM_EFFECT_SHOT )
+    {
+        m_effectProgress += event.rTime * 1.0f;
+        m_effectOffset.x = (Math::Rand() - 0.5f) * 2.0f;
+        m_effectOffset.y = (Math::Rand() - 0.5f) * 2.0f;
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 2.0f;
+
+        force *= 1.0f-m_effectProgress;
+    }
+
+    if ( m_effectType == Gfx::CAM_EFFECT_CRASH )
+    {
+        m_effectProgress += event.rTime * 5.0f;
+        m_effectOffset.y = sinf(m_effectProgress * Math::PI) * 1.5f;
+        m_effectOffset.x = (Math::Rand() - 0.5f) * 1.0f * (1.0f - m_effectProgress);
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 1.0f * (1.0f - m_effectProgress);
+    }
+
+    if ( m_effectType == Gfx::CAM_EFFECT_VIBRATION )
+    {
+        m_effectProgress += event.rTime * 0.1f;
+        m_effectOffset.y = (Math::Rand() - 0.5f) * 1.0f * (1.0f - m_effectProgress);
+        m_effectOffset.x = (Math::Rand() - 0.5f) * 1.0f * (1.0f - m_effectProgress);
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 1.0f * (1.0f - m_effectProgress);
+    }
+
+    if ( m_effectType == Gfx::CAM_EFFECT_PET )
+    {
+        m_effectProgress += event.rTime  *5.0f;
+        m_effectOffset.x = (Math::Rand() - 0.5f) * 0.2f;
+        m_effectOffset.y = (Math::Rand() - 0.5f) * 2.0f;
+        m_effectOffset.z = (Math::Rand() - 0.5f) * 0.2f;
+    }
+
+    float dist = Math::Distance(m_eyePt, m_effectPos);
+    dist = Math::Norm((dist - 100.f) / 100.0f);
+
+    force *= 1.0f-dist;
+#if _TEEN
+    force *= 2.0f;
+#endif
+    m_effectOffset *= force;
+
+    if (m_effectProgress >= 1.0f)
+        FlushEffect();
+}
+
+void Gfx::CCamera::FlushOver()
+{
+    m_overType = Gfx::CAM_OVER_EFFECT_NULL;
+    m_overColorBase = Gfx::Color(0.0f, 0.0f, 0.0f, 0.0f);  // black
+    m_engine->SetOverColor();  // nothing
+}
+
+void Gfx::CCamera::SetOverBaseColor(Gfx::Color color)
+{
+    m_overColorBase = color;
+}
+
+void Gfx::CCamera::StartOver(Gfx::CameraOverEffect effect, Math::Vector pos, float force)
+{
+    m_overType = effect;
+    m_overTime = 0.0f;
+
+    float decay;
+    if (m_overType == Gfx::CAM_OVER_EFFECT_LIGHTNING)
+        decay = 400.0f;
+    else
+        decay = 100.0f;
+
+    float dist = Math::Distance(m_eyePt, pos);
+    dist = (dist - decay) / decay;
+    if (dist < 0.0f) dist = 0.0f;
+    if (dist > 1.0f) dist = 1.0f;
+
+    m_overForce = force * (1.0f - dist);
+
+    if (m_overType == Gfx::CAM_OVER_EFFECT_BLOOD)
+    {
+        m_overColor   = Gfx::Color(0.8f, 0.1f, 0.1f); // red
+        m_overMode    = Gfx::ENG_RSTATE_TCOLOR_BLACK;
+
+        m_overFadeIn  = 0.4f;
+        m_overFadeOut = 0.8f;
+        m_overForce   = 1.0f;
+    }
+
+    if ( m_overType == Gfx::CAM_OVER_EFFECT_FADEIN_WHITE )
+    {
+        m_overColor   = Gfx::Color(1.0f, 1.0f, 1.0f); // white
+        m_overMode    = Gfx::ENG_RSTATE_TCOLOR_BLACK;
+
+        m_overFadeIn  = 0.0f;
+        m_overFadeOut = 20.0f;
+        m_overForce   = 1.0f;
+    }
+
+    if ( m_overType == Gfx::CAM_OVER_EFFECT_FADEOUT_WHITE )
+    {
+        m_overColor   = Gfx::Color(1.0f, 1.0f, 1.0f); // white
+        m_overMode    = Gfx::ENG_RSTATE_TCOLOR_BLACK;
+
+        m_overFadeIn  = 6.0f;
+        m_overFadeOut = 100000.0f;
+        m_overForce   = 1.0f;
+    }
+
+    if ( m_overType == Gfx::CAM_OVER_EFFECT_FADEOUT_BLACK )
+    {
+        m_overColor   = m_engine->GetFogColor(1); // fog color underwater
+        m_overMode    = Gfx::ENG_RSTATE_TTEXTURE_WHITE;
+
+        m_overFadeIn  = 4.0f;
+        m_overFadeOut = 100000.0f;
+        m_overForce   = 1.0f;
+    }
+
+    if ( m_overType == Gfx::CAM_OVER_EFFECT_LIGHTNING )
+    {
+        m_overColor   = Gfx::Color(0.9f, 1.0f, 1.0f);  // white-cyan
+        m_overMode    = Gfx::ENG_RSTATE_TCOLOR_BLACK;
+
+        m_overFadeIn  = 0.0f;
+        m_overFadeOut = 1.0f;
+    }
+}
+
+void Gfx::CCamera::OverFrame(const Event &event)
+{
+    if (m_type == Gfx::CAM_TYPE_INFO ||
+        m_type == Gfx::CAM_TYPE_VISIT)
+        return;
+
+    if (m_overType == Gfx::CAM_OVER_EFFECT_NULL)
+        return;
+
+    m_overTime += event.rTime;
+
+    if (m_overType == Gfx::CAM_OVER_EFFECT_LIGHTNING)
+    {
+        Gfx::Color color;
+        if (rand() % 2 == 0)
+        {
+            color.r = m_overColor.r * m_overForce;
+            color.g = m_overColor.g * m_overForce;
+            color.b = m_overColor.b * m_overForce;
+        }
+        else
+        {
+            color = Gfx::Color(0.0f. 0.0f, 0.0f);
+        }
+        color.a = 0.0f;
+        m_engine->SetOverColor(color, m_overMode);
+    }
+    else
+    {
+        if ( (m_overFadeIn > 0.0f) && (m_overTime < m_overFadeIn) )
+        {
+            float intensity = m_overTime / m_overFadeIn;
+            intensity *= m_overForce;
+
+            Gfx::Color color;
+            if (m_overMode == Gfx::ENG_RSTATE_TCOLOR_WHITE)
+            {
+                color.r = 1.0f - (1.0f - m_overColor.r) * intensity;
+                color.g = 1.0f - (1.0f - m_overColor.g) * intensity;
+                color.b = 1.0f - (1.0f - m_overColor.b) * intensity;
+            }
+            else
+            {
+                color.r = m_overColor.r * intensity;
+                color.g = m_overColor.g * intensity;
+                color.b = m_overColor.b * intensity;
+
+                color.r = 1.0f - (1.0f - color.r) * (1.0f - m_overColorBase.r);
+                color.g = 1.0f - (1.0f - color.g) * (1.0f - m_overColorBase.g);
+                color.b = 1.0f - (1.0f - color.b) * (1.0f - m_overColorBase.b);
+            }
+            color.a = 0.0f;
+            m_engine->SetOverColor(color, m_overMode);
+        }
+        else if ( (m_overFadeOut > 0.0f) && (m_overTime - m_overFadeIn < m_overFadeOut) )
+        {
+            float intensity = 1.0f - (m_overTime - m_overFadeIn) / m_overFadeOut;
+            intensity *= m_overForce;
+
+            Gfx::Color color;
+            if (m_overMode == Gfx::ENG_RSTATE_TCOLOR_WHITE)
+            {
+                color.r = 1.0f-(1.0f-m_overColor.r) * intensity;
+                color.g = 1.0f-(1.0f-m_overColor.g) * intensity;
+                color.b = 1.0f-(1.0f-m_overColor.b) * intensity;
+            }
+            else
+            {
+                color.r = m_overColor.r * intensity;
+                color.g = m_overColor.g * intensity;
+                color.b = m_overColor.b * intensity;
+
+                color.r = 1.0f - (1.0f - color.r)*(1.0f - m_overColorBase.r);
+                color.g = 1.0f - (1.0f - color.g)*(1.0f - m_overColorBase.g);
+                color.b = 1.0f - (1.0f - color.b)*(1.0f - m_overColorBase.b);
+            }
+            color.a = 0.0f;
+            m_engine->SetOverColor(color, m_overMode);
+        }
+    }
+
+    if ( m_overTime >= m_overFadeIn+m_overFadeOut )
+    {
+        FlushOver();
+        return;
+    }
+}
+
+void Gfx::CCamera::FixCamera()
+{
+    m_initDelay = 0.0f;
+    m_actualEye    = m_finalEye    = m_scriptEye;
+    m_actualLookat = m_finalLookat = m_scriptLookat;
+    SetViewTime(m_scriptEye, m_scriptLookat, 0.0f);
+}
+
+void Gfx::CCamera::SetViewTime(const Math::Vector &eyePt,
+                               const Math::Vector &lookatPt,
+                               float rTime)
+{
+    Math::Vector eye, lookat;
+
+    if (m_type == Gfx::CAM_TYPE_INFO)
+    {
+        eye    = eyePt;
+        lookat = lookatPt;
+    }
+    else
+    {
+        if (m_initDelay > 0.0f)
+        {
+            m_initDelay -= rTime;
+            if (m_initDelay < 0.0f)
+                m_initDelay = 0.0f;
+            rTime /= 1.0f+m_initDelay;
+        }
+
+        eye    = eyePt;
+        lookat = lookatPt;
+        if ( !IsCollision(eye, lookat) )
+        {
+            m_finalEye    = eye;
+            m_finalLookat = lookat;
+        }
+
+        float prog = 0.0f;
+        float dist = Math::Distance(m_finalEye, m_actualEye);
+
+        if (m_smooth == Gfx::CAM_SMOOTH_NONE) prog = dist;
+        if (m_smooth == Gfx::CAM_SMOOTH_NORM) prog = powf(dist, 1.5f) * rTime * 0.5f;
+        if (m_smooth == Gfx::CAM_SMOOTH_HARD) prog = powf(dist, 1.0f) * rTime * 4.0f;
+        if (m_smooth == Gfx::CAM_SMOOTH_SPEC) prog = powf(dist, 1.0f) * rTime * 0.05f;
+        if (dist == 0.0f)
+        {
+            m_actualEye = m_finalEye;
+        }
+        else
+        {
+            if (prog > dist)
+                prog = dist;
+            m_actualEye = (m_finalEye - m_actualEye) / dist * prog + m_actualEye;
+        }
+
+        dist = Math::Distance(m_finalLookat, m_actualLookat);
+        if ( m_smooth == Gfx::CAM_SMOOTH_NONE ) prog = dist;
+        if ( m_smooth == Gfx::CAM_SMOOTH_NORM ) prog = powf(dist, 1.5f) * rTime * 2.0f;
+        if ( m_smooth == Gfx::CAM_SMOOTH_HARD ) prog = powf(dist, 1.0f) * rTime * 4.0f;
+        if ( m_smooth == Gfx::CAM_SMOOTH_SPEC ) prog = powf(dist, 1.0f) * rTime * 4.0f;
+        if ( dist == 0.0f )
+        {
+            m_actualLookat = m_finalLookat;
+        }
+        else
+        {
+            if (prog > dist)
+                prog = dist;
+            m_actualLookat = (m_finalLookat - m_actualLookat) / dist * prog + m_actualLookat;
+        }
+
+        eye = m_effectOffset+m_actualEye;
+        m_water->AdjustEye(eye);
+
+        float h = m_terrain->GetFloorLevel(eye);
+        if (eye.y < h + 4.0f)
+            eye.y = h + 4.0f;
+
+        lookat = m_effectOffset+m_actualLookat;
+    }
+
+    Math::Vector upVec = Math::Vector(0.0f, 1.0f, 0.0f);
+    SetViewParams(eye, lookat, upVec);
+}
+
+bool Gfx::CCamera::IsCollision(Math::Vector &eye, Math::Vector lookat)
+{
+    if (m_type == Gfx::CAM_TYPE_BACK )  return IsCollisionBack(eye, lookat);
+    if (m_type == Gfx::CAM_TYPE_FIX  )  return IsCollisionFix (eye, lookat);
+    if (m_type == Gfx::CAM_TYPE_PLANE)  return IsCollisionFix (eye, lookat);
+    return false;
+}
+
+bool Gfx::CCamera::IsCollisionBack(Math::Vector &eye, Math::Vector lookat)
+{
+    ObjectType iType;
+    if (m_cameraObj == NULL)
+        iType = OBJECT_NULL;
+    else
+        iType = m_cameraObj->GetType();
+
+    Math::Vector min;
+    min.x = Math::Min(m_actualEye.x, m_actualLookat.x);
+    min.y = Math::Min(m_actualEye.y, m_actualLookat.y);
+    min.z = Math::Min(m_actualEye.z, m_actualLookat.z);
+
+    Math::Vector max;
+    max.x = Math::Max(m_actualEye.x, m_actualLookat.x);
+    max.y = Math::Max(m_actualEye.y, m_actualLookat.y);
+    max.z = Math::Max(m_actualEye.z, m_actualLookat.z);
+
+    m_transparency = false;
+
+    for (int i = 0 ;i < 1000000; i++)
+    {
+        CObject *obj = (CObject*)m_iMan->SearchInstance(CLASS_OBJECT, i);
+        if (obj == NULL) break;
+
+        if (obj->GetTruck()) continue;  // battery or cargo?
+
+        SetTransparency(obj, 0.0f);  // opaque object
+
+        if (obj == m_cameraObj) continue;
+
+        if ( iType == OBJECT_BASE     ||  // building?
+             iType == OBJECT_DERRICK  ||
+             iType == OBJECT_FACTORY  ||
+             iType == OBJECT_STATION  ||
+             iType == OBJECT_CONVERT  ||
+             iType == OBJECT_REPAIR   ||
+             iType == OBJECT_DESTROYER||
+             iType == OBJECT_TOWER    ||
+             iType == OBJECT_RESEARCH ||
+             iType == OBJECT_RADAR    ||
+             iType == OBJECT_ENERGY   ||
+             iType == OBJECT_LABO     ||
+             iType == OBJECT_NUCLEAR  ||
+             iType == OBJECT_PARA     ||
+             iType == OBJECT_SAFE     ||
+             iType == OBJECT_HUSTON   )  continue;
+
+        ObjType oType = obj->GetType();
+        if ( oType == OBJECT_HUMAN  ||
+             oType == OBJECT_TECH   ||
+             oType == OBJECT_TOTO   ||
+             oType == OBJECT_FIX    ||
+             oType == OBJECT_FRET   ||
+             oType == OBJECT_ANT    ||
+             oType == OBJECT_SPIDER ||
+             oType == OBJECT_BEE    ||
+             oType == OBJECT_WORM   )  continue;
+
+        Math::Vector oPos;
+        float oRadius = 0.0f;
+        obj->GetGlobalSphere(oPos, oRadius);
+        if ( oRadius <= 2.0f )  continue;  // ignores small objects
+
+        if ( oPos.x+oRadius < min.x ||
+             oPos.y+oRadius < min.y ||
+             oPos.z+oRadius < min.z ||
+             oPos.x-oRadius > max.x ||
+             oPos.y-oRadius > max.y ||
+             oPos.z-oRadius > max.z )  continue;
+
+        Math::Vector proj = Projection(m_actualEye, m_actualLookat, oPos);
+        float dpp = Math::Distance(proj, oPos);
+        if ( dpp > oRadius )  continue;
+
+        if ( oType == OBJECT_FACTORY )
+        {
+            float angle = Math::RotateAngle(m_actualEye.x-oPos.x, oPos.z-m_actualEye.z);  // CW !
+            angle = Math::Direction(angle, obj->GetAngleY(0));
+            if ( fabs(angle) < 30.0f*Math::PI/180.0f )  continue;  // in the gate?
+        }
+
+        float del = Math::Distance(m_actualEye, m_actualLookat);
+        if (oType == OBJECT_FACTORY)
+            del += oRadius;
+
+        float len = Math::Distance(m_actualEye, proj);
+        if (len > del) continue;
+
+        SetTransparency(obj, 1.0f);  // transparent object
+        m_transparency = true;
+    }
+    return false;
+}
+
+bool Gfx::CCamera::IsCollisionFix(Math::Vector &eye, Math::Vector lookat)
+{
+    for (int i = 0; i < 1000000; i++)
+    {
+        CObject *obj = static_cast<CObject*>( m_iMan->SearchInstance(CLASS_OBJECT, i) );
+        if (obj == NULL) break;
+
+        if (obj == m_cameraObj) continue;
+
+        ObjectType type = obj->GetType();
+        if ( type == OBJECT_TOTO    ||
+             type == OBJECT_FRET    ||
+             type == OBJECT_STONE   ||
+             type == OBJECT_URANIUM ||
+             type == OBJECT_METAL   ||
+             type == OBJECT_POWER   ||
+             type == OBJECT_ATOMIC  ||
+             type == OBJECT_BULLET  ||
+             type == OBJECT_BBOX    ||
+             type == OBJECT_KEYa    ||
+             type == OBJECT_KEYb    ||
+             type == OBJECT_KEYc    ||
+             type == OBJECT_KEYd    ||
+             type == OBJECT_ANT     ||
+             type == OBJECT_SPIDER  ||
+             type == OBJECT_BEE     ||
+             type == OBJECT_WORM )  continue;
+
+        Math::Vector objPos;
+        float objRadius = 0.0f;
+        obj->GetGlobalSphere(objPos, objRadius);
+        if (objRadius == 0.0f) continue;
+
+        float dist = Math::Distance(eye, objPos);
+        if (dist < objRadius)
+        {
+            dist = Math::Distance(eye, lookat);
+            Math::Vector proj = Projection(eye, lookat, objPos);
+            eye = (lookat - eye) * objRadius / dist + proj;
+            return false;
+        }
+    }
+    return false;
+}
+
+bool Gfx::CCamera::EventProcess(const Event &event)
+{
+    switch (event.type)
+    {
+        // TODO: frame update event
+        case EVENT_FRAME:
+            EventFrame(event);
+            break;
+
+        case EVENT_MOUSE_MOVE:
+            EventMouseMove(event);
+            break;
+
+        case EVENT_KEY_DOWN:
+            // TODO: mouse wheel event
+            if ( event.param == VK_WHEELUP   )  EventMouseWheel(+1);
+            if ( event.param == VK_WHEELDOWN )  EventMouseWheel(-1);
+            break;
+
+        default:
+            break;
+    }
+    return true;
+}
+
+bool Gfx::CCamera::EventMouseMove(const Event &event)
+{
+    m_mousePos = event.pos;
+    return true;
+}
+
+void Gfx::CCamera::EventMouseWheel(int dir)
+{
+    if (m_type == Gfx::CAM_TYPE_BACK)
+    {
+        if (dir > 0)
+        {
+            m_backDist -= 8.0f;
+            if (m_backDist < m_backMin)
+                m_backDist = m_backMin;
+        }
+        if (dir < 0)
+        {
+            m_backDist += 8.0f;
+            if (m_backDist > 200.0f)
+                m_backDist = 200.0f;
+        }
+    }
+
+    if ( m_type == Gfx::CAM_TYPE_FIX   ||
+         m_type == Gfx::CAM_TYPE_PLANE )
+    {
+        if (dir > 0)
+        {
+            m_fixDist -= 8.0f;
+            if (m_fixDist < 10.0f)
+                m_fixDist = 10.0f;
+        }
+        if (dir < 0)
+        {
+            m_fixDist += 8.0f;
+            if (m_fixDist > 200.0f)
+                m_fixDist = 200.0f;
+        }
+    }
+
+    if ( m_type == Gfx::CAM_TYPE_VISIT )
+    {
+        if (dir > 0)
+        {
+            m_visitDist -= 8.0f;
+            if (m_visitDist < 20.0f)
+                m_visitDist = 20.0f;
+        }
+        if (dir < 0)
+        {
+            m_visitDist += 8.0f;
+            if (m_visitDist > 200.0f)
+                m_visitDist = 200.0f;
+        }
+    }
+}
+
+bool Gfx::CCamera::EventFrame(const Event &event)
+{
+    EffectFrame(event);
+    OverFrame(event);
+
+    if (m_type == Gfx::CAM_TYPE_FREE)
+        return EventFrameFree(event);
+
+    if (m_type == Gfx::CAM_TYPE_EDIT)
+        return EventFrameEdit(event);
+
+    if (m_type == Gfx::CAM_TYPE_DIALOG)
+        return EventFrameDialog(event);
+
+    if (m_type == Gfx::CAM_TYPE_BACK)
+        return EventFrameBack(event);
+
+    if (m_type == Gfx::CAM_TYPE_FIX   ||
+        m_type == Gfx::CAM_TYPE_PLANE)
+        return EventFrameFix(event);
+
+    if (m_type == Gfx::CAM_TYPE_EXPLO)
+        return EventFrameExplo(event);
+
+    if (m_type == Gfx::CAM_TYPE_ONBOARD)
+        return EventFrameOnBoard(event);
+
+    if (m_type == Gfx::CAM_TYPE_SCRIPT)
+        return EventFrameScript(event);
+
+    if (m_type == Gfx::CAM_TYPE_INFO)
+        return EventFrameInfo(event);
+
+    if (m_type == Gfx::CAM_TYPE_VISIT)
+        return EventFrameVisit(event);
+
+    return true;
+}
+
+Gfx::EngineMouseType Gfx::CCamera::GetMouseDef(Math::Point pos)
+{
+    Gfx::EngineMouseType type = Gfx::ENG_MOUSE_NORM;
+    m_mousePos = pos;
+
+    if (m_type == Gfx::CAM_TYPE_INFO)
+        return type;
+
+    if (m_rightDown)  // the right button pressed?
+    {
+        m_rightPosMove.x = pos.x - m_rightPosCenter.x;
+        m_rightPosMove.y = pos.y - m_rightPosCenter.y;
+        type = Gfx::ENG_MOUSE_MOVE;
+    }
+    else
+    {
+        if (!m_cameraScroll)
+            return type;
+
+        m_mouseDirH = 0.0f;
+        m_mouseDirV = 0.0f;
+
+        if (pos.x < m_mouseMarging)
+            m_mouseDirH = pos.x / m_mouseMarging - 1.0f;
+
+        if (pos.x > 1.0f - m_mouseMarging)
+            m_mouseDirH = 1.0f - (1.0f - pos.x) / m_mouseMarging;
+
+        if (pos.y < m_mouseMarging)
+            m_mouseDirV = pos.y / m_mouseMarging - 1.0f;
+
+        if (pos.y > 1.0f-m_mouseMarging)
+            m_mouseDirV = 1.0f - (1.0f - pos.y) / m_mouseMarging;
+
+        if ( m_type == Gfx::CAM_TYPE_FREE  ||
+             m_type == Gfx::CAM_TYPE_EDIT  ||
+             m_type == Gfx::CAM_TYPE_BACK  ||
+             m_type == Gfx::CAM_TYPE_FIX   ||
+             m_type == Gfx::CAM_TYPE_PLANE ||
+             m_type == Gfx::CAM_TYPE_EXPLO )
+        {
+            if (m_mouseDirH > 0.0f)
+                type = Gfx::ENG_MOUSE_SCROLLR;
+            if (m_mouseDirH < 0.0f)
+                type = Gfx::ENG_MOUSE_SCROLLL;
+        }
+
+        if ( m_type == Gfx::CAM_TYPE_FREE ||
+             m_type == Gfx::CAM_TYPE_EDIT )
+        {
+            if (m_mouseDirV > 0.0f)
+                type = Gfx::ENG_MOUSE_SCROLLU;
+            if (m_mouseDirV < 0.0f)
+                type = Gfx::ENG_MOUSE_SCROLLD;
+        }
+
+        if (m_cameraInvertX)
+            m_mouseDirH = -m_mouseDirH;
+    }
+
+    return type;
+}
+
+bool Gfx::CCamera::EventFrameFree(const Event &event)
+{
+    float factor = m_heightEye * 0.5f + 30.0f;
+
+    if ( m_mouseDirH != 0.0f )
+        m_directionH -= m_mouseDirH * event.rTime * 0.7f * m_speed;
+    if ( m_mouseDirV != 0.0f )
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, m_mouseDirV * event.rTime * factor * m_speed);
+
+    // Up/Down
+    m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, event.axeY * event.rTime * factor * m_speed);
+
+    // Left/Right
+    if ( event.keyState & KS_CONTROL )
+    {
+        if ( event.axeX < 0.0f )
+            m_eyePt = Math::LookatPoint(m_eyePt, m_directionH + Math::PI / 2.0f, m_directionV, -event.axeX * event.rTime * factor * m_speed);
+        if ( event.axeX > 0.0f )
+            m_eyePt = Math::LookatPoint(m_eyePt, m_directionH - Math::PI / 2.0f, m_directionV,  event.axeX * event.rTime * factor * m_speed);
+    }
+    else
+    {
+        m_directionH -= event.axeX * event.rTime * 0.7f * m_speed;
+    }
+
+    // PageUp/PageDown
+    if ( event.keyState & KS_NUMMINUS )
+    {
+        if (m_heightEye < 500.0f)
+            m_heightEye += event.rTime * factor * m_speed;
+    }
+    if ( event.keyState & KS_NUMPLUS )
+    {
+        if (m_heightEye > -2.0f)
+            m_heightEye -= event.rTime * factor * m_speed;
+    }
+
+    m_terrain->ValidPosition(m_eyePt, 10.0f);
+
+    if (m_terrain->MoveOnFloor(m_eyePt, true))
+    {
+        m_eyePt.y += m_heightEye;
+
+        Math::Vector pos = m_eyePt;
+        if (m_terrain->MoveOnFloor(pos, true))
+        {
+            pos.y -= 2.0f;
+            if (m_eyePt.y < pos.y)
+                m_eyePt.y = pos.y;
+        }
+
+    }
+
+    Math::Vector lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
+
+    if (m_terrain->MoveOnFloor(lookatPt, true))
+        lookatPt.y += m_heightLookat;
+
+    SetViewTime(m_eyePt, lookatPt, event.rTime);
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameEdit(const Event &event)
+{
+    float factor = m_editHeight * 0.5f + 30.0f;
+
+    if (m_mouseDirH != 0.0f)
+        m_directionH -= m_mouseDirH * event.rTime * 0.7f * m_speed;
+    if (m_mouseDirV != 0.0f)
+        m_eyePt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, m_mouseDirV * event.rTime * factor * m_speed);
+
+    if (m_cameraScroll)
+    {
+        // Left/Right.
+        m_fixDirectionH += m_mouseDirH * event.rTime * 1.0f * m_speed;
+        m_fixDirectionH = Math::NormAngle(m_fixDirectionH);
+    }
+
+    m_terrain->ValidPosition(m_eyePt, 10.0f);
+
+    if (m_terrain->MoveOnFloor(m_eyePt, false))
+    {
+        m_eyePt.y += m_editHeight;
+
+        Math::Vector pos = m_eyePt;
+        if (m_terrain->MoveOnFloor(pos, false))
+        {
+            pos.y += 2.0f;
+            if (m_eyePt.y < pos.y)
+                m_eyePt.y = pos.y;
+        }
+
+    }
+
+    Math::Vector lookatPt = Math::LookatPoint( m_eyePt, m_directionH, m_directionV, 50.0f );
+
+    if ( m_terrain->MoveOnFloor(lookatPt, true))
+        lookatPt.y += m_heightLookat;
+
+    SetViewTime(m_eyePt, lookatPt, event.rTime);
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameDialog(const Event &event)
+{
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameBack(const Event &event)
+{
+    ObjectType type;
+    if (m_cameraObj == NULL)
+        type = OBJECT_NULL;
+    else
+        type = m_cameraObj->GetType();
+
+    // +/-.
+    if (event.keyState & KS_NUMPLUS)
+    {
+        m_backDist -= event.rTime * 30.0f * m_speed;
+        if (m_backDist < m_backMin) m_backDist = m_backMin;
+    }
+    if (event.keyState & KS_NUMMINUS)
+    {
+        m_backDist += event.rTime * 30.0f * m_speed;
+        if (m_backDist > 200.0f) m_backDist = 200.0f;
+    }
+
+    m_motorTurn = 0.0f;
+
+    if (m_rightDown)
+    {
+        m_addDirectionH =  m_rightPosMove.x * 6.0f;
+        m_addDirectionV = -m_rightPosMove.y * 2.0f;
+    }
+    else
+    {
+        if (m_cameraScroll)
+        {
+            // Left/Right
+            m_addDirectionH += m_mouseDirH * event.rTime * 1.0f * m_speed;
+            m_addDirectionH = Math::NormAngle(m_addDirectionH);
+        }
+    }
+
+    if ((m_mouseDirH != 0) || (m_mouseDirV != 0))
+        AbortCentering();  // special stops framing
+
+    // Increase the special framework
+    float centeringH = 0.0f;
+    float centeringV = 0.0f;
+    float centeringD = 0.0f;
+
+    if (m_centeringPhase == Gfx::CAM_PHASE_START)
+    {
+        m_centeringProgress += event.rTime / m_centeringTime;
+        if (m_centeringProgress > 1.0f) m_centeringProgress = 1.0f;
+        centeringH = m_centeringProgress;
+        centeringV = m_centeringProgress;
+        centeringD = m_centeringProgress;
+        if (m_centeringProgress >= 1.0f)
+            m_centeringPhase = Gfx::CAM_PHASE_WAIT;
+    }
+
+    if (m_centeringPhase == Gfx::CAM_PHASE_WAIT)
+    {
+        centeringH = 1.0f;
+        centeringV = 1.0f;
+        centeringD = 1.0f;
+    }
+
+    if (m_centeringPhase == Gfx::CAM_PHASE_STOP)
+    {
+        m_centeringProgress += event.rTime / m_centeringTime;
+        if (m_centeringProgress > 1.0f) m_centeringProgress = 1.0f;
+        centeringH = 1.0f-m_centeringProgress;
+        centeringV = 1.0f-m_centeringProgress;
+        centeringD = 1.0f-m_centeringProgress;
+        if (m_centeringProgress >= 1.0f)
+            m_centeringPhase = Gfx::CAM_PHASE_NULL;
+    }
+
+    if (m_centeringAngleH == 99.9f) centeringH = 0.0f;
+    if (m_centeringAngleV == 99.9f) centeringV = 0.0f;
+    if (m_centeringDist   ==  0.0f) centeringD = 0.0f;
+
+    if (m_cameraObj != NULL)
+    {
+        Math::Vector lookatPt = m_cameraObj->GetPosition(0);
+             if (type == OBJECT_BASE ) lookatPt.y += 40.0f;
+        else if (type == OBJECT_HUMAN) lookatPt.y +=  1.0f;
+        else if (type == OBJECT_TECH ) lookatPt.y +=  1.0f;
+        else                           lookatPt.y +=  4.0f;
+
+        float h = -m_cameraObj->GetAngleY(0);  // angle vehicle / building
+
+        if ( type == OBJECT_DERRICK  ||
+             type == OBJECT_FACTORY  ||
+             type == OBJECT_REPAIR   ||
+             type == OBJECT_DESTROYER||
+             type == OBJECT_STATION  ||
+             type == OBJECT_CONVERT  ||
+             type == OBJECT_TOWER    ||
+             type == OBJECT_RESEARCH ||
+             type == OBJECT_RADAR    ||
+             type == OBJECT_INFO     ||
+             type == OBJECT_ENERGY   ||
+             type == OBJECT_LABO     ||
+             type == OBJECT_NUCLEAR  ||
+             type == OBJECT_PARA     ||
+             type == OBJECT_SAFE     ||
+             type == OBJECT_HUSTON   ||
+             type == OBJECT_START    ||
+             type == OBJECT_END      )  // building?
+        {
+            h += Math::PI * 0.20f;  // nearly face
+        }
+        else    // vehicle?
+        {
+            h += Math::PI;  // back
+        }
+        h = Math::NormAngle(h)+m_remotePan;
+        float v = 0.0f;  //?
+
+        h += m_centeringCurrentH;
+        h += m_addDirectionH * (1.0f - centeringH);
+        h = Math::NormAngle(h);
+
+        if (type == OBJECT_MOBILEdr)  // designer?
+            v -= 0.3f;  // Camera top
+
+        v += m_centeringCurrentV;
+        v += m_addDirectionV * (1.0f - centeringV);
+
+        float d = m_backDist;
+        d += m_centeringDist * centeringD;
+
+        m_centeringCurrentH = m_centeringAngleH * centeringH;
+        m_centeringCurrentV = m_centeringAngleV * centeringV;
+
+        m_eyePt = RotateView(lookatPt, h, v, d);
+
+        CPhysics* physics = m_cameraObj->GetPhysics();
+        if ( (physics != NULL) && physics->GetLand() )  // ground?
+        {
+            Math::Vector pos = lookatPt + (lookatPt - m_eyePt);
+            float floor = m_terrain->GetFloorHeight(pos) - 4.0f;
+            if (floor > 0.0f)
+                m_eyePt.y += floor;  // shows the descent in front
+        }
+
+        m_eyePt = ExcludeTerrain(m_eyePt, lookatPt, h, v);
+        m_eyePt = ExcludeObject(m_eyePt, lookatPt, h, v);
+
+        SetViewTime(m_eyePt, lookatPt, event.rTime);
+
+        m_directionH = h + Math::PI / 2.0f;
+        m_directionV = v;
+    }
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameFix(const Event &event)
+{
+    // +/-.
+    if (event.keyState & KS_NUMPLUS)
+    {
+        m_fixDist -= event.rTime * 30.0f * m_speed;
+        if (m_fixDist < 10.0f) m_fixDist = 10.0f;
+    }
+    if (event.keyState & KS_NUMMINUS)
+    {
+        m_fixDist += event.rTime * 30.0f * m_speed;
+        if (m_fixDist > 200.0f) m_fixDist = 200.0f;
+    }
+
+    if (m_cameraScroll)
+    {
+        // Left/Right
+        m_fixDirectionH += m_mouseDirH * event.rTime * 1.0f * m_speed;
+        m_fixDirectionH = Math::NormAngle(m_fixDirectionH);
+    }
+
+    if ((m_mouseDirH != 0) || (m_mouseDirV != 0))
+        AbortCentering();  // special stops framing
+
+    if (m_cameraObj != NULL)
+    {
+        Math::Vector lookatPt = m_cameraObj->GetPosition(0);
+
+        float h = m_fixDirectionH + m_remotePan;
+        float v = m_fixDirectionV;
+
+        float d = m_fixDist;
+        m_eyePt = RotateView(lookatPt, h, v, d);
+        if (m_type == Gfx::CAM_TYPE_PLANE) m_eyePt.y += m_fixDist / 2.0f;
+        m_eyePt = ExcludeTerrain(m_eyePt, lookatPt, h, v);
+        m_eyePt = ExcludeObject(m_eyePt, lookatPt, h, v);
+
+        SetViewTime(m_eyePt, lookatPt, event.rTime);
+
+        m_directionH = h + Math::PI / 2.0f;
+        m_directionV = v;
+    }
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameExplo(const Event &event)
+{
+    float factor = m_heightEye * 0.5f + 30.0f;
+
+    if (m_mouseDirH != 0.0f)
+        m_directionH -= m_mouseDirH * event.rTime * 0.7f * m_speed;
+
+    m_terrain->ValidPosition(m_eyePt, 10.0f);
+
+    if ( m_terrain->MoveOnFloor(m_eyePt, false) )
+    {
+        m_eyePt.y += m_heightEye;
+
+        Math::Vector pos = m_eyePt;
+        if ( m_terrain->MoveOnFloor(pos, false) )
+        {
+            pos.y += 2.0f;
+            if ( m_eyePt.y < pos.y )
+                m_eyePt.y = pos.y;
+        }
+
+    }
+
+    Math::Vector lookatPt = Math::LookatPoint(m_eyePt, m_directionH, m_directionV, 50.0f);
+
+    if (m_terrain->MoveOnFloor(lookatPt, true))
+        lookatPt.y += m_heightLookat;
+
+    SetViewTime(m_eyePt, lookatPt, event.rTime);
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameOnBoard(const Event &event)
+{
+    if (m_cameraObj != NULL)
+    {
+        Math::Vector lookatPt, upVec;
+        m_cameraObj->SetViewFromHere(m_eyePt, m_directionH, m_directionV,
+                                     lookatPt, vUpVec, m_type);
+        Math::Vector eye    = m_effectOffset * 0.3f + m_eyePt;
+        Math::Vector lookat = m_effectOffset * 0.3f + lookatPt;
+
+        SetViewParams(eye, lookat, upVec);
+        m_actualEye    = eye;
+        m_actualLookat = lookat;
+    }
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameInfo(const Event &event)
+{
+    SetViewTime(Math::Vector(0.0f, 0.0f, 0.0f),
+                Math::Vector(0.0f, 0.0f, 1.0f),
+                event.rTime);
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameVisit(const Event &event)
+{
+    m_visitTime += event.rTime;
+
+    // +/-.
+    if (event.keyState & KS_NUMPLUS)
+    {
+        m_visitDist -= event.rTime * 50.0f * m_speed;
+        if (m_visitDist < 20.0f) m_visitDist = 20.0f;
+    }
+    if (event.keyState & KS_NUMMINUS)
+    {
+        m_visitDist += event.rTime * 50.0f * m_speed;
+        if (m_visitDist > 200.0f) m_visitDist = 200.0f;
+    }
+
+    // PageUp/Down.
+    if (event.keyState & KS_PAGEUP)
+    {
+        m_visitDirectionV -= event.rTime * 1.0f * m_speed;
+        if (m_visitDirectionV < -Math::PI * 0.40f) m_visitDirectionV = -Math::PI * 0.40f;
+    }
+    if (event.keyState & KS_PAGEDOWN)
+    {
+        m_visitDirectionV += event.rTime * 1.0f * m_speed;
+        if (m_visitDirectionV > 0.0f ) m_visitDirectionV = 0.0f;
+    }
+
+    if (m_cameraScroll)
+    {
+        m_visitDist -= m_mouseDirV * event.rTime * 30.0f * m_speed;
+        if (m_visitDist <  20.0f)  m_visitDist =  20.0f;
+        if (m_visitDist > 200.0f)  m_visitDist = 200.0f;
+    }
+
+    float angleH = (m_visitTime / 10.0f) * (Math::PI * 2.0f);
+    float angleV = m_visitDirectionV;
+    Math::Vector eye = RotateView(m_visitGoal, angleH, angleV, m_visitDist);
+    eye = ExcludeTerrain(eye, m_visitGoal, angleH, angleV);
+    eye = ExcludeObject(eye, m_visitGoal, angleH, angleV);
+    SetViewTime(eye, m_visitGoal, event.rTime);
+
+    return true;
+}
+
+bool Gfx::CCamera::EventFrameScript(const Event &event)
+{
+    SetViewTime(m_scriptEye + m_effectOffset,
+                m_scriptLookat + m_effectOffset, event.rTime);
+    return true;
+}
+
+void Gfx::CCamera::SetScriptEye(Math::Vector eye)
+{
+    m_scriptEye = eye;
+}
+
+void Gfx::CCamera::SetScriptLookat(Math::Vector lookat)
+{
+    m_scriptLookat = lookat;
+}
+
+void Gfx::CCamera::SetViewParams(const Math::Vector &eye, const Math::Vector &lookat,
+                            const Math::Vector &up)
+{
+    m_engine->SetViewParams(eye, lookat, up, m_eyeDistance);
+
+    bool under = (eye.y < m_water->GetLevel());  // Is it underwater?
+    if (m_type == Gfx::CAM_TYPE_INFO)
+        under = false;
+
+    m_engine->SetRankView(under ? 1 : 0);
+}
+
+Math::Vector Gfx::CCamera::ExcludeTerrain(Math::Vector eye, Math::Vector lookat,
+                                          float &angleH, float &angleV)
+{
+    Math::Vector pos = eye;
+    if (m_terrain->MoveOnFloor(pos))
+    {
+        float dist = Math::DistanceProjected(lookat, pos);
+        pos.y += 2.0f+dist*0.1f;
+        if ( pos.y > eye.y )
+        {
+            angleV = -Math::RotateAngle(dist, pos.y-lookat.y);
+            eye = RotateView(lookat, angleH, angleV, dist);
+        }
+    }
+    return eye;
+}
+
+Math::Vector Gfx::CCamera::ExcludeObject(Math::Vector eye, Math::Vector lookat,
+                                         float &angleH, float &angleV)
+{
+    return eye;
+
+// TODO: check the commented out code:
+/*
+    for (int i = 0; i < 1000000; i++)
+    {
+        CObject* obj = static_cast<CObject*>( m_iMan->SearchInstance(CLASS_OBJECT, i) );
+        if (obj == NULL)
+            break;
+
+        int j = 0;
+        Math::Vector oPos;
+        float oRad;
+        while (obj->GetCrashSphere(j++, oPos, oRad))
+        {
+            float dist = Math::Distance(oPos, eye);
+            if (dist < oRad + 2.0f)
+                eye.y = oPos.y + oRad + 2.0f;
+        }
+    }
+
+    return eye;*/
+}
diff --git a/src/graphics/engine/camera.h b/src/graphics/engine/camera.h
new file mode 100644
index 0000000..935f8b0
--- /dev/null
+++ b/src/graphics/engine/camera.h
@@ -0,0 +1,386 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// camera.h
+
+#pragma once
+
+#include "engine.h"
+#include "common/event.h"
+
+
+class CInstanceManager;
+class CObject;
+
+namespace Gfx {
+
+
+/**
+  \enum CameraType
+  \brief Type of camera */
+enum CameraType
+{
+    //! Undefined
+    CAM_TYPE_NULL     = 0,
+    //! Free camera (? never in principle ?)
+    CAM_TYPE_FREE     = 1,
+    //! Camera while editing a program
+    CAM_TYPE_EDIT     = 2,
+    //! Camera on board a robot
+    CAM_TYPE_ONBOARD  = 3,
+    //! Camera behind a robot
+    CAM_TYPE_BACK     = 4,
+    //! Static camera following robot
+    CAM_TYPE_FIX      = 5,
+    //! Camera steady after explosion
+    CAM_TYPE_EXPLO    = 6,
+    //! Camera during a film script
+    CAM_TYPE_SCRIPT   = 7,
+    //! Camera for displaying information
+    CAM_TYPE_INFO     = 8,
+    //! Visit instead of an error
+    CAM_TYPE_VISIT    = 9,
+    //! Camera for dialog
+    CAM_TYPE_DIALOG   = 10,
+    //! Static camera height
+    CAM_TYPE_PLANE    = 11,
+};
+
+enum CameraSmooth
+{
+    //! Sharp
+    CAM_SMOOTH_NONE         = 0,
+    //! Normal
+    CAM_SMOOTH_NORM         = 1,
+    //! Hard
+    CAM_SMOOTH_HARD         = 2,
+    //! Special
+    CAM_SMOOTH_SPEC         = 3,
+};
+
+enum CenteringPhase
+{
+    CAM_PHASE_NULL         = 0,
+    CAM_PHASE_START        = 1,
+    CAM_PHASE_WAIT         = 2,
+    CAM_PHASE_STOP         = 3,
+};
+
+enum CameraEffect
+{
+    //! No effect
+    CAM_EFFECT_NULL         = 0,
+    //! Digging in
+    CAM_EFFECT_TERRAFORM    = 1,
+    //! ? Vehicle driving is severely ?
+    CAM_EFFECT_CRASH        = 2,
+    //! Explosion
+    CAM_EFFECT_EXPLO        = 3,
+    //! ? Not mortal shot ?
+    CAM_EFFECT_SHOT         = 4,
+    //! Vibration during construction
+    CAM_EFFECT_VIBRATION    = 5,
+    //! ? Spleen reactor ?
+    CAM_EFFECT_PET          = 6,
+};
+
+enum CameraOverEffect
+{
+    //! No effect
+    CAM_OVER_EFFECT_NULL           = 0,
+    //! Flash red
+    CAM_OVER_EFFECT_BLOOD          = 1,
+    //! White -> nothing
+    CAM_OVER_EFFECT_FADEIN_WHITE   = 2,
+    //! Nothing -> white
+    CAM_OVER_EFFECT_FADEOUT_WHITE  = 3,
+    //! Nothing -> blue
+    CAM_OVER_EFFECT_FADEOUT_BLACK  = 4,
+    //! Lightning
+    CAM_OVER_EFFECT_LIGHTNING      = 5,
+};
+
+
+/**
+  \class CCamera
+  \brief Camera moving in 3D scene
+
+  ... */
+class CCamera {
+
+    public:
+    CCamera(CInstanceManager* iMan);
+    ~CCamera();
+
+    //! Management of an event
+    bool        EventProcess(const Event &event);
+
+    //! Initializes the camera
+    void        Init(Math::Vector eye, Math::Vector lookat, float delay);
+
+    //! Sets the object controlling the camera
+    void        SetObject(CObject* object);
+    CObject*    GetObject();
+
+    //! Change the type of camera
+    void            SetType(Gfx::CameraType type);
+    Gfx::CameraType GetType();
+
+    //! Management of the smoothing mode
+    void              SetSmooth(CameraSmooth type);
+    Gfx::CameraSmooth GetSmoth();
+
+    //! Management of the setback distance
+    void        SetDist(float dist);
+    float       GetDist();
+
+    //! Manage angle mode Gfx::CAM_TYPE_FIX
+    void        SetFixDirection(float angle);
+    float       GetFixDirection();
+
+    //! Managing the triggering mode of the camera panning
+    void        SetRemotePan(float value);
+    float       GetRemotePan();
+
+    //! Management of the remote zoom (0 .. 1) of the camera
+    void        SetRemoteZoom(float value);
+    float       GetRemoteZoom();
+
+    //! Start with a tour round the camera
+    void        StartVisit(Math::Vector goal, float dist);
+    //! Circular end of a visit with the camera
+    void        StopVisit();
+
+    //! Returns the point of view of the camera
+    void        GetCamera(Math::Vector &eye, Math::Vector &lookat);
+
+    //! Specifies a special movement of camera to frame action
+    bool        StartCentering(CObject *object, float angleH, float angleV, float dist, float time);
+    //! Ends a special movement of camera to frame action
+    bool        StopCentering(CObject *object, float time);
+    //! Stop framing special in the current position
+    void        AbortCentering();
+
+    //! Removes the special effect with the camera
+    void        FlushEffect();
+    //! Starts a special effect with the camera
+    void        StartEffect(Gfx::CameraEffect effect, Math::Vector pos, float force);
+
+    //! Removes the effect of superposition in the foreground
+    void        FlushOver();
+    //! Specifies the base color
+    void        SetOverBaseColor(Gfx::Color color);
+    void        StartOver(Gfx::CameraOverEffect effect, Math::Vector pos, float force);
+
+    //! Sets the soft movement of the camera
+    void        FixCamera();
+    void        SetScriptEye(Math::Vector eye);
+    void        SetScriptLookat(Math::Vector lookat);
+
+    void        SetEffect(bool enable);
+    void        SetCameraScroll(bool scroll);
+    void        SetCameraInvertX(bool invert);
+    void        SetCameraInvertY(bool invert);
+
+    //! Returns an additional force to turn
+    float       GetMotorTurn();
+    //! Returns the default sprite to use for the mouse
+    Gfx::EngineMouseType GetMouseDef(Math::Point pos);
+
+protected:
+    //! Changes the camera according to the mouse moved
+    bool        EventMouseMove(const Event &event);
+    //! Mouse wheel operation
+    void        EventMouseWheel(int dir);
+    //! Changes the camera according to the time elapsed
+    bool        EventFrame(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameFree(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameEdit(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameDialog(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameBack(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameFix(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameExplo(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameOnBoard(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameInfo(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameVisit(const Event &event);
+    //! Moves the point of view
+    bool        EventFrameScript(const Event &event);
+
+    //! Specifies the location and direction of view to the 3D engine
+    void        SetViewTime(const Math::Vector &vEyePt, const Math::Vector &vLookatPt, float rTime);
+    //! Avoid the obstacles
+    bool        IsCollision(Math::Vector &eye, Math::Vector lookat);
+    //! Avoid the obstacles
+    bool        IsCollisionBack(Math::Vector &eye, Math::Vector lookat);
+    //! Avoid the obstacles
+    bool        IsCollisionFix(Math::Vector &eye, Math::Vector lookat);
+
+    //! Adjusts the camera not to enter the ground
+    Math::Vector ExcludeTerrain(Math::Vector eye, Math::Vector lookat, float &angleH, float &angleV);
+    //! Adjusts the camera not to enter an object
+    Math::Vector ExcludeObject(Math::Vector eye, Math::Vector lookat, float &angleH, float &angleV);
+
+    //! Specifies the location and direction of view
+    void        SetViewParams(const Math::Vector &eye, const Math::Vector &lookat, const Math::Vector &up);
+    //! Advances the effect of the camera
+    void        EffectFrame(const Event &event);
+    //! Advanced overlay effect in the foreground
+    void        OverFrame(const Event &event);
+
+protected:
+    CInstanceManager* m_iMan;
+    Gfx::CEngine*     m_engine;
+    Gfx::CTerrain*    m_terrain;
+    Gfx::CWater*      m_water;
+
+    //! The type of camera
+    Gfx::CameraType   m_type;
+    //! Type of smoothing
+    Gfx::CameraSmooth m_smooth;
+    //! Object linked to the camera
+    CObject*          m_cameraObj;
+
+    //! Distance between the eyes
+    float       m_eyeDistance;
+    //! Time of initial centering
+    float       m_initDelay;
+
+    //! Current eye
+    Math::Vector    m_actualEye;
+    //! Current aim
+    Math::Vector    m_actualLookat;
+    //! Final eye
+    Math::Vector    m_finalEye;
+    //! Final aim
+    Math::Vector    m_finalLookat;
+    //! Normal eye
+    Math::Vector    m_normEye;
+    //! Normal aim
+    Math::Vector    m_normLookat;
+
+    float       m_focus;
+
+    bool            m_rightDown;
+    Math::Point     m_rightPosInit;
+    Math::Point     m_rightPosCenter;
+    Math::Point     m_rightPosMove;
+
+    //! CAM_TYPE_FREE: eye
+    Math::Vector    m_eyePt;
+    //! CAM_TYPE_FREE: horizontal direction
+    float       m_directionH;
+    //! CAM_TYPE_FREE: vertical direction
+    float       m_directionV;
+    //! CAM_TYPE_FREE: height above the ground
+    float       m_heightEye;
+    //! CAM_TYPE_FREE: height above the ground
+    float       m_heightLookat;
+    //! CAM_TYPE_FREE: speed of movement
+    float       m_speed;
+
+    //! CAM_TYPE_BACK: distance
+    float       m_backDist;
+    //! CAM_TYPE_BACK: distance minimal
+    float       m_backMin;
+    //! CAM_TYPE_BACK: additional direction
+    float       m_addDirectionH;
+    //! CAM_TYPE_BACK: additional direction
+    float       m_addDirectionV;
+    bool        m_transparency;
+
+    //! CAM_TYPE_FIX: distance
+    float       m_fixDist;
+    //! CAM_TYPE_FIX: direction
+    float       m_fixDirectionH;
+    //! CAM_TYPE_FIX: direction
+    float       m_fixDirectionV;
+
+    //! CAM_TYPE_VISIT: target position
+    Math::Vector m_visitGoal;
+    //! CAM_TYPE_VISIT: distance
+    float        m_visitDist;
+    //! CAM_TYPE_VISIT: relative time
+    float        m_visitTime;
+    //! CAM_TYPE_VISIT: initial type
+    Gfx::CameraType   m_visitType;
+    //! CAM_TYPE_VISIT: direction
+    float        m_visitDirectionH;
+    //! CAM_TYPE_VISIT: direction
+    float        m_visitDirectionV;
+
+    //! CAM_TYPE_EDIT: height
+    float        m_editHeight;
+
+    float        m_remotePan;
+    float        m_remoteZoom;
+
+    Math::Point  m_mousePos;
+    float        m_mouseDirH;
+    float        m_mouseDirV;
+    float        m_mouseMarging;
+
+    float        m_motorTurn;
+
+    Gfx::CenteringPhase m_centeringPhase;
+    float       m_centeringAngleH;
+    float       m_centeringAngleV;
+    float       m_centeringDist;
+    float       m_centeringCurrentH;
+    float       m_centeringCurrentV;
+    float       m_centeringTime;
+    float       m_centeringProgress;
+
+    CameraEffect m_effectType;
+    Math::Vector m_effectPos;
+    float        m_effectForce;
+    float        m_effectProgress;
+    Math::Vector m_effectOffset;
+
+    OverEffect  m_overType;
+    float       m_overForce;
+    float       m_overTime;
+    Gfx::Color  m_overColorBase;
+    Gfx::Color  m_overColor;
+    int         m_overMode;
+    float       m_overFadeIn;
+    float       m_overFadeOut;
+
+    Math::Vector m_scriptEye;
+    Math::Vector m_scriptLookat;
+
+    //! Shocks if explosion?
+    bool        m_effect;
+    //! Scroll in the edges?
+    bool        m_cameraScroll;
+    //! X inversion in the edges?
+    bool        m_cameraInvertX;
+    //! Y inversion in the edges?
+    bool        m_cameraInvertY;
+
+};
+
+
+}; // namespace Gfx
diff --git a/src/graphics/common/cloud.cpp b/src/graphics/engine/cloud.cpp
index 707f641..d0e5ed8 100644
--- a/src/graphics/common/cloud.cpp
+++ b/src/graphics/engine/cloud.cpp
@@ -17,7 +17,7 @@
 
 // cloud.cpp
 
-#include "graphics/common/cloud.h"
+#include "graphics/engine/cloud.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/cloud.h b/src/graphics/engine/cloud.h
index 19b689f..d2d29d7 100644
--- a/src/graphics/common/cloud.h
+++ b/src/graphics/engine/cloud.h
@@ -20,7 +20,7 @@
 #pragma once
 
 #include "common/event.h"
-#include "graphics/common/color.h"
+#include "graphics/core/color.h"
 #include "math/point.h"
 #include "math/vector.h"
 
diff --git a/src/graphics/engine/engine.cpp b/src/graphics/engine/engine.cpp
new file mode 100644
index 0000000..e544ee3
--- /dev/null
+++ b/src/graphics/engine/engine.cpp
@@ -0,0 +1,743 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// engine.cpp
+
+#include "graphics/engine/engine.h"
+
+#include "app/app.h"
+#include "common/iman.h"
+#include "common/image.h"
+#include "common/key.h"
+#include "common/logger.h"
+#include "graphics/core/device.h"
+#include "math/geometry.h"
+
+// Initial size of various vectors
+const int OBJECT_PREALLOCATE_COUNT       = 1200;
+const int SHADOW_PREALLOCATE_COUNT       = 500;
+const int GROUNDSPOT_PREALLOCATE_COUNT   = 100;
+
+const int LEVEL1_PREALLOCATE_COUNT        = 50;
+const int LEVEL2_PREALLOCATE_COUNT        = 100;
+const int LEVEL3_PREALLOCATE_COUNT        = 5;
+const int LEVEL4_PREALLOCATE_COUNT        = 10;
+const int LEVEL5_PREALLOCATE_COUNT        = 100;
+const int LEVEL5_VERTEX_PREALLOCATE_COUNT = 200;
+
+
+Gfx::CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
+{
+    m_iMan   = iMan;
+    m_app    = app;
+    m_device = NULL;
+
+    m_wasInit = false;
+
+    m_iMan = iMan;
+    m_iMan->AddInstance(CLASS_ENGINE, this);
+    m_app = app;
+
+    m_lightMan      = NULL;
+    m_text       = NULL;
+    m_particle   = NULL;
+    m_water      = NULL;
+    m_cloud      = NULL;
+    m_lightning  = NULL;
+    m_planet     = NULL;
+    m_sound      = NULL;
+    m_terrain    = NULL;
+
+    m_focus = 0.75f;
+    m_baseTime = 0;
+    m_lastTime = 0;
+    m_absTime = 0.0f;
+    m_rankView = 0;
+
+    m_ambientColor[0] = Gfx::Color(0.5f, 0.5f, 0.5f, 0.5f);
+    m_ambientColor[1] = Gfx::Color(0.5f, 0.5f, 0.5f, 0.5f);
+    m_fogColor[0]     = Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f);
+    m_fogColor[1]     = Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f);
+    m_deepView[0]     = 1000.0f;
+    m_deepView[1]     = 1000.0f;
+    m_fogStart[0]     = 0.75f;
+    m_fogStart[1]     = 0.75f;
+    m_waterAddColor   = Gfx::Color(0.0f, 0.0f, 0.0f, 0.0f);
+
+    m_pause             = false;
+    m_render            = true;
+    m_movieLock         = false;
+    m_shadowVisible     = true;
+    m_groundSpotVisible = true;
+    m_dirty             = true;
+    m_fog               = true;
+    m_speed             = 1.0f;
+    m_secondTexNum      = 0;
+    m_eyeDirH           = 0.0f;
+    m_eyeDirV           = 0.0f;
+    m_backgroundName    = "";  // no background image
+    m_backgroundColorUp   = 0;
+    m_backgroundColorDown = 0;
+    m_backgroundCloudUp   = 0;
+    m_backgroundCloudDown = 0;
+    m_backgroundFull = false;
+    m_backgroundQuarter = false;
+    m_overFront = true;
+    m_overColor = 0;
+    m_overMode  = ENG_RSTATE_TCOLOR_BLACK;
+    m_frontsizeName = "";  // no front image
+    m_hiliteRank[0] = -1;  // empty list
+    m_eyePt    = Math::Vector(0.0f, 0.0f, 0.0f);
+    m_lookatPt = Math::Vector(0.0f, 0.0f, 1.0f);
+    m_drawWorld = true;
+    m_drawFront = false;
+    m_limitLOD[0] = 100.0f;
+    m_limitLOD[1] = 200.0f;
+    m_particuleDensity = 1.0f;
+    m_clippingDistance = 1.0f;
+    m_lastClippingDistance = m_clippingDistance;
+    m_objectDetail = 1.0f;
+    m_lastObjectDetail = m_objectDetail;
+    m_terrainVision = 1000.0f;
+    m_gadgetQuantity = 1.0f;
+    m_textureQuality = 1;
+    m_totoMode = true;
+    m_lensMode = true;
+    m_waterMode = true;
+    m_skyMode = true;
+    m_backForce = true;
+    m_planetMode = true;
+    m_lightMode = true;
+    m_editIndentMode = true;
+    m_editIndentValue = 4;
+    m_tracePrecision = 1.0f;
+
+    m_alphaMode = 1;
+
+    m_forceStateColor = true;
+    m_stateColor = false;
+
+    m_blackSrcBlend[0]    = 0;
+    m_blackDestBlend[0]   = 0;
+    m_whiteSrcBlend[0]    = 0;
+    m_whiteDestBlend[0]   = 0;
+    m_diffuseSrcBlend[0]  = 0;
+    m_diffuseDestBlend[0] = 0;
+    m_alphaSrcBlend[0]    = 0;
+    m_alphaDestBlend[0]   = 0;
+
+    m_updateGeometry = false;
+
+    m_mice[Gfx::ENG_MOUSE_NORM]    = Gfx::EngineMouse( 0,  1, 32, Gfx::ENG_RSTATE_TCOLOR_WHITE, Gfx::ENG_RSTATE_TCOLOR_BLACK, Math::Point( 1.0f,  1.0f));
+    m_mice[Gfx::ENG_MOUSE_WAIT]    = Gfx::EngineMouse( 2,  3, 33, Gfx::ENG_RSTATE_TCOLOR_WHITE, Gfx::ENG_RSTATE_TCOLOR_BLACK, Math::Point( 8.0f, 12.0f));
+    m_mice[Gfx::ENG_MOUSE_HAND]    = Gfx::EngineMouse( 4,  5, 34, Gfx::ENG_RSTATE_TCOLOR_WHITE, Gfx::ENG_RSTATE_TCOLOR_BLACK, Math::Point( 7.0f,  2.0f));
+    m_mice[Gfx::ENG_MOUSE_NO]      = Gfx::EngineMouse( 6,  7, 35, Gfx::ENG_RSTATE_TCOLOR_WHITE, Gfx::ENG_RSTATE_TCOLOR_BLACK, Math::Point(10.0f, 10.0f));
+    m_mice[Gfx::ENG_MOUSE_EDIT]    = Gfx::EngineMouse( 8,  9, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 6.0f, 10.0f));
+    m_mice[Gfx::ENG_MOUSE_CROSS]   = Gfx::EngineMouse(10, 11, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point(10.0f, 10.0f));
+    m_mice[Gfx::ENG_MOUSE_MOVEV]   = Gfx::EngineMouse(12, 13, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 5.0f, 11.0f));
+    m_mice[Gfx::ENG_MOUSE_MOVEH]   = Gfx::EngineMouse(14, 15, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point(11.0f,  5.0f));
+    m_mice[Gfx::ENG_MOUSE_MOVED]   = Gfx::EngineMouse(16, 17, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 9.0f,  9.0f));
+    m_mice[Gfx::ENG_MOUSE_MOVEI]   = Gfx::EngineMouse(18, 19, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 9.0f,  9.0f));
+    m_mice[Gfx::ENG_MOUSE_MOVE]    = Gfx::EngineMouse(20, 21, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point(11.0f, 11.0f));
+    m_mice[Gfx::ENG_MOUSE_TARGET]  = Gfx::EngineMouse(22, 23, -1, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point(15.0f, 15.0f));
+    m_mice[Gfx::ENG_MOUSE_SCROLLL] = Gfx::EngineMouse(24, 25, 43, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 2.0f,  9.0f));
+    m_mice[Gfx::ENG_MOUSE_SCROLLR] = Gfx::EngineMouse(26, 27, 44, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point(17.0f,  9.0f));
+    m_mice[Gfx::ENG_MOUSE_SCROLLU] = Gfx::EngineMouse(28, 29, 45, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 9.0f,  2.0f));
+    m_mice[Gfx::ENG_MOUSE_SCROLLD] = Gfx::EngineMouse(30, 31, 46, Gfx::ENG_RSTATE_TCOLOR_BLACK, Gfx::ENG_RSTATE_TCOLOR_WHITE, Math::Point( 9.0f, 17.0f));
+
+    m_mouseSize    = Math::Point(0.04f, 0.04f * (800.0f / 600.0f));
+    m_mousePos     = Math::Point(0.5f, 0.5f);
+    m_mouseType    = Gfx::ENG_MOUSE_NORM;
+    m_mouseVisible = false;
+
+    m_texPath = "textures/";
+    m_defaultTexParams.format = Gfx::TEX_IMG_RGBA;
+    m_defaultTexParams.mipmap = true;
+    m_defaultTexParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR;
+    m_defaultTexParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR;
+
+    m_objectTree.reserve(LEVEL1_PREALLOCATE_COUNT);
+    m_objects.reserve(OBJECT_PREALLOCATE_COUNT);
+    m_shadow.reserve(SHADOW_PREALLOCATE_COUNT);
+    m_groundSpot.reserve(GROUNDSPOT_PREALLOCATE_COUNT);
+}
+
+Gfx::CEngine::~CEngine()
+{
+    m_iMan   = NULL;
+    m_app    = NULL;
+    m_device = NULL;
+
+    m_sound = NULL;
+    m_terrain = NULL;
+}
+
+bool Gfx::CEngine::GetWasInit()
+{
+    return m_wasInit;
+}
+
+std::string Gfx::CEngine::GetError()
+{
+    return m_error;
+}
+
+bool Gfx::CEngine::Create()
+{
+    m_wasInit = true;
+
+    /*m_lightMan      = new Gfx::CLight(m_iMan, this);
+    m_text       = new Gfx::CText(m_iMan, this);
+    m_particle   = new Gfx::CParticle(m_iMan, this);
+    m_water      = new Gfx::CWater(m_iMan, this);
+    m_cloud      = new Gfx::CCloud(m_iMan, this);
+    m_lightning  = new Gfx::CLightning(m_iMan, this);
+    m_planet     = new Gfx::CPlanet(m_iMan, this);*/
+
+    m_matWorldInterface.LoadIdentity();
+    m_matViewInterface.LoadIdentity();
+    Math::LoadOrthoProjectionMatrix(m_matProjInterface, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f);
+
+    return true;
+}
+
+void Gfx::CEngine::Destroy()
+{
+    // TODO
+
+    /*delete m_lightMan;
+    m_lightMan = NULL;
+
+    delete m_text;
+    m_text = NULL;
+
+    delete m_particle;
+    m_particle = NULL;
+
+    delete m_water;
+    m_water = NULL;
+
+    delete m_cloud;
+    m_cloud = NULL;
+
+    delete m_lightning;
+    m_lightning = NULL;
+
+    delete m_planet;
+    m_planet = NULL;*/
+
+    m_wasInit = false;
+}
+
+void Gfx::CEngine::SetDevice(Gfx::CDevice *device)
+{
+    m_device = device;
+}
+
+Gfx::CDevice* Gfx::CEngine::GetDevice()
+{
+    return m_device;
+}
+
+bool Gfx::CEngine::AfterDeviceSetInit()
+{
+    m_device->SetClearColor(Gfx::Color(0.0f, 0.0f, 0.0f, 0.0f));
+
+    m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, false);
+
+    Gfx::TextureCreateParams params;
+    params.format = Gfx::TEX_IMG_RGB;
+    params.minFilter = Gfx::TEX_MIN_FILTER_NEAREST;
+    params.magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
+    params.mipmap = false;
+    m_miceTexture = CreateTexture("mouse.png", params);
+
+    return true;
+}
+
+void Gfx::CEngine::ResetAfterDeviceChanged()
+{
+    // TODO
+}
+
+
+Gfx::Texture Gfx::CEngine::CreateTexture(const std::string &texName, const Gfx::TextureCreateParams &params)
+{
+    CImage img;
+    if (! img.Load(m_app->GetDataFilePath(m_texPath, texName)))
+    {
+        std::stringstream str;
+        str << "Couldn't load texture '" << texName << "': " << img.GetError();
+        m_error = str.str();
+        return Gfx::Texture(); // invalid texture
+    }
+
+    Gfx::Texture result = m_device->CreateTexture(&img, params);
+
+    if (! result.valid)
+    {
+        std::stringstream str;
+        str << "Couldn't load texture '" << texName << "': " << m_device->GetError();
+        m_error = str.str();
+        return result;
+    }
+
+    m_texNameMap[texName] = result;
+    m_revTexNameMap[result] = texName;
+
+    return result;
+}
+
+Gfx::Texture Gfx::CEngine::CreateTexture(const std::string &texName)
+{
+    return CreateTexture(texName, m_defaultTexParams);
+}
+
+void Gfx::CEngine::DestroyTexture(const std::string &texName)
+{
+    std::map<std::string, Gfx::Texture>::iterator it = m_texNameMap.find(texName);
+    if (it == m_texNameMap.end())
+        return;
+
+    std::map<Gfx::Texture, std::string>::iterator revIt = m_revTexNameMap.find((*it).second);
+
+    m_device->DestroyTexture((*it).second);
+
+    m_revTexNameMap.erase(revIt);
+    m_texNameMap.erase(it);
+}
+
+void Gfx::CEngine::SetTexture(const std::string &name, int stage)
+{
+    std::map<std::string, Gfx::Texture>::iterator it = m_texNameMap.find(name);
+    if (it != m_texNameMap.end())
+        m_device->SetTexture(stage, (*it).second);
+
+    // TODO if not present...
+}
+
+void Gfx::CEngine::SetMaterial(const Gfx::Material &mat)
+{
+    m_device->SetMaterial(mat);
+}
+
+void Gfx::CEngine::SetState(int state, Gfx::Color color)
+{
+    if ( state == m_lastState && color == m_lastColor )
+        return;
+
+    m_lastState = state;
+    m_lastColor = color;
+
+    if ( m_alphaMode != 1 && (state & Gfx::ENG_RSTATE_ALPHA) )
+    {
+        state &= ~Gfx::ENG_RSTATE_ALPHA;
+
+        if (m_alphaMode == 2)
+            state |= Gfx::ENG_RSTATE_TTEXTURE_BLACK;
+    }
+
+    // TODO other modes & thorough testing
+
+    if (state & Gfx::ENG_RSTATE_TTEXTURE_BLACK)  // The transparent black texture?
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG,         false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_WRITE, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_BLENDING,    true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_ALPHA_TEST,  false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING,   true);
+
+        m_device->SetBlendFunc(Gfx::BLEND_ONE, Gfx::BLEND_INV_SRC_COLOR);
+        m_device->SetTextureEnabled(0, true);
+        m_device->SetTextureFactor(color);
+
+        Gfx::TextureStageParams params;
+        params.colorOperation = Gfx::TEX_MIX_OPER_MODULATE;
+        params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE;
+        params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR;
+        params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
+        m_device->SetTextureStageParams(0, params);
+    }
+    else if (state & Gfx::ENG_RSTATE_TTEXTURE_WHITE)  // The transparent white texture?
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG,         false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_WRITE, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_BLENDING,    true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_ALPHA_TEST,  false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING,   true);
+
+        m_device->SetBlendFunc(Gfx::BLEND_DST_COLOR, Gfx::BLEND_ZERO);
+        m_device->SetTextureEnabled(0, true);
+        m_device->SetTextureFactor(color.Inverse());
+
+        Gfx::TextureStageParams params;
+        params.colorOperation = Gfx::TEX_MIX_OPER_ADD;
+        params.colorArg1 = Gfx::TEX_MIX_ARG_TEXTURE;
+        params.colorArg2 = Gfx::TEX_MIX_ARG_FACTOR;
+        params.alphaOperation = Gfx::TEX_MIX_OPER_MODULATE;
+        m_device->SetTextureStageParams(0, params);
+    }
+    else if (state & Gfx::ENG_RSTATE_TCOLOR_BLACK)  // The transparent black color?
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_WRITE, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_BLENDING, true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_ALPHA_TEST, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
+
+        m_device->SetBlendFunc(Gfx::BLEND_ONE, Gfx::BLEND_INV_SRC_COLOR);
+
+        m_device->SetTextureFactor(color);
+        m_device->SetTextureEnabled(0, true);
+        m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
+    }
+    else if (state & Gfx::ENG_RSTATE_TCOLOR_WHITE)  // The transparent white color?
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_WRITE, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_BLENDING, true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_ALPHA_TEST, false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
+
+        m_device->SetBlendFunc(Gfx::BLEND_DST_COLOR, Gfx::BLEND_ZERO);
+
+        m_device->SetTextureFactor(color.Inverse());
+        m_device->SetTextureEnabled(0, true);
+        m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
+    }
+    else if (state & Gfx::ENG_RSTATE_TDIFFUSE)  // diffuse color as transparent?
+    {
+        /*m_device->SetRenderState(D3DRENDERSTATE_FOGENABLE, false);
+        m_device->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, false);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, true);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, false);
+        m_device->SetRenderState(D3DRENDERSTATE_SRCBLEND,  m_diffuseSrcBlend[1]);
+        m_device->SetRenderState(D3DRENDERSTATE_DESTBLEND, m_diffuseDestBlend[1]);
+
+        m_device->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1);
+        m_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+        m_device->SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);*/
+    }
+    else if (state & Gfx::ENG_RSTATE_ALPHA)  // image with alpha channel?
+    {
+        /*m_device->SetRenderState(D3DRENDERSTATE_FOGENABLE, true);
+        m_device->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, true);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, false);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, true);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHAFUNC, D3DCMP_GREATER);
+        m_device->SetRenderState(D3DRENDERSTATE_ALPHAREF,  (DWORD)(128));
+        m_device->SetRenderState(D3DRENDERSTATE_SRCBLEND,  m_alphaSrcBlend[1]);
+        m_device->SetRenderState(D3DRENDERSTATE_DESTBLEND, m_alphaSrcBlend[1]);
+
+        m_device->SetRenderState(D3DRENDERSTATE_TEXTUREFACTOR, color);
+        m_device->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_MODULATE);
+        m_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+        m_device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
+        m_device->SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1);
+        m_device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);*/
+    }
+    else    // normal ?
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG,         true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_DEPTH_WRITE, true);
+        m_device->SetRenderState(Gfx::RENDER_STATE_BLENDING,    false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_ALPHA_TEST,  false);
+        m_device->SetRenderState(Gfx::RENDER_STATE_TEXTURING,   true);
+
+        m_device->SetTextureEnabled(0, true);
+        m_device->SetTextureStageParams(0, Gfx::TextureStageParams());
+
+        /*m_device->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_MODULATE);
+        m_device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+        m_device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
+        m_device->SetTextureStageState(0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);*/
+    }
+
+    if (state & Gfx::ENG_RSTATE_FOG)
+        m_device->SetRenderState(Gfx::RENDER_STATE_FOG, true);
+
+
+    bool second = m_groundSpotVisible || m_dirty;
+
+    if ( !m_groundSpotVisible && (state & Gfx::ENG_RSTATE_SECOND) != 0 ) second = false;
+    if ( !m_dirty             && (state & Gfx::ENG_RSTATE_SECOND) == 0 ) second = false;
+
+    if ( (state & ENG_RSTATE_DUAL_BLACK) && second )
+    {
+        /*m_device->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_MODULATE);
+        m_device->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+        m_device->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
+        m_device->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
+        m_device->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);*/
+    }
+    else if ( (state & ENG_RSTATE_DUAL_WHITE) && second )
+    {
+        /*m_device->SetTextureStageState(1, D3DTSS_COLOROP,   D3DTOP_ADD);
+        m_device->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+        m_device->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
+        m_device->SetTextureStageState(1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE);
+        m_device->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);*/
+    }
+    else
+    {
+        m_device->SetTextureEnabled(1, false);
+    }
+
+    if (state & Gfx::ENG_RSTATE_WRAP)
+    {
+        /*m_device->SetTextureStageState(0, D3DTSS_ADDRESS, D3DTADDRESS_WRAP);
+        m_device->SetTextureStageState(1, D3DTSS_ADDRESS, D3DTADDRESS_WRAP);*/
+    }
+    else if (state & Gfx::ENG_RSTATE_CLAMP)
+    {
+        /*m_device->SetTextureStageState(0, D3DTSS_ADDRESS, D3DTADDRESS_CLAMP);
+        m_device->SetTextureStageState(1, D3DTSS_ADDRESS, D3DTADDRESS_CLAMP);*/
+    }
+    else
+    {
+        /*m_device->SetTextureStageState(0, D3DTSS_ADDRESS, D3DTADDRESS_CLAMP);
+        m_device->SetTextureStageState(1, D3DTSS_ADDRESS, D3DTADDRESS_CLAMP);*/
+    }
+
+    if (state & Gfx::ENG_RSTATE_2FACE)
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_CULLING, false);
+    }
+    else
+    {
+        m_device->SetRenderState(Gfx::RENDER_STATE_CULLING, true);
+        m_device->SetCullMode(Gfx::CULL_CCW);
+    }
+
+    if (state & Gfx::ENG_RSTATE_LIGHT)
+        m_device->SetGlobalAmbient(Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f));
+    else
+        m_device->SetGlobalAmbient(m_ambientColor[m_rankView]);
+}
+
+bool Gfx::CEngine::ProcessEvent(const Event &event)
+{
+    if (event.type == EVENT_MOUSE_MOVE)
+    {
+        m_mousePos = event.mouseMove.pos;
+    }
+    else if (event.type == EVENT_KEY_DOWN)
+    {
+        // !! Debug, to be removed later !!
+
+        if (event.key.key == KEY(F1))
+        {
+            m_mouseVisible = !m_mouseVisible;
+            m_app->SetSystemMouseVisible(! m_app->GetSystemMouseVisibile());
+        }
+        else if (event.key.key == KEY(F2))
+        {
+            int index = static_cast<int>(m_mouseType);
+            m_mouseType = static_cast<Gfx::EngineMouseType>( (index + 1) % Gfx::ENG_MOUSE_COUNT );
+        }
+    }
+
+    // By default, pass on all events
+    return true;
+}
+
+bool Gfx::CEngine::Render()
+{
+    m_statisticTriangle = 0;
+
+    m_lastState = -1;
+    SetState(Gfx::ENG_RSTATE_NORMAL);
+
+    m_device->BeginScene();
+
+    SetUp3DView();
+
+    if (! Draw3DScene() )
+        return false;
+
+    SetUpInterfaceView();
+
+    if (! DrawInterface() )
+        return false;
+
+    m_device->EndScene();
+
+    return true;
+}
+
+void Gfx::CEngine::SetUp3DView()
+{
+    // TODO
+}
+
+bool Gfx::CEngine::Draw3DScene()
+{
+    // TODO
+    return true;
+}
+
+void Gfx::CEngine::SetUpInterfaceView()
+{
+    m_device->SetTransform(Gfx::TRANSFORM_WORLD,      m_matWorldInterface);
+    m_device->SetTransform(Gfx::TRANSFORM_VIEW,       m_matViewInterface);
+    m_device->SetTransform(Gfx::TRANSFORM_PROJECTION, m_matProjInterface);
+}
+
+bool Gfx::CEngine::DrawInterface()
+{
+    Gfx::VertexCol vertices[3] =
+    {
+        Gfx::VertexCol(Math::Vector( 0.25f,  0.25f, 0.0f), Gfx::Color(1.0f, 0.0f, 0.0f)),
+        Gfx::VertexCol(Math::Vector( 0.75f,  0.25f, 0.0f), Gfx::Color(0.0f, 1.0f, 0.0f)),
+        Gfx::VertexCol(Math::Vector( 0.5f,   0.75f, 0.0f), Gfx::Color(0.0f, 0.0f, 1.0f))
+    };
+
+    m_device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, vertices, 3);
+
+    DrawMouse();
+
+    return true;
+}
+
+void Gfx::CEngine::DrawMouse()
+{
+    if (! m_mouseVisible)
+        return;
+
+    if (m_app->GetSystemMouseVisibile())
+        return;
+
+    Gfx::Material material;
+    material.diffuse = Gfx::Color(1.0f, 1.0f, 1.0f);
+    material.ambient = Gfx::Color(0.5f, 0.5f, 0.5f);
+
+    m_device->SetMaterial(material);
+    m_device->SetTexture(0, m_miceTexture);
+
+    int index = static_cast<int>(m_mouseType);
+
+    Math::Point pos = m_mousePos;
+    pos.x = m_mousePos.x - (m_mice[index].hotPoint.x * m_mouseSize.x) / 32.0f;
+    pos.y = m_mousePos.y - ((32.0f - m_mice[index].hotPoint.y) * m_mouseSize.y) / 32.0f;
+
+    Math::Point shadowPos;
+    shadowPos.x = pos.x + (4.0f/800.0f);
+    shadowPos.y = pos.y - (3.0f/600.0f);
+
+    SetState(Gfx::ENG_RSTATE_TCOLOR_WHITE);
+    DrawMouseSprite(shadowPos, m_mouseSize, m_mice[index].iconShadow);
+
+    SetState(m_mice[index].mode1);
+    DrawMouseSprite(pos, m_mouseSize, m_mice[index].icon1);
+
+    SetState(m_mice[index].mode2);
+    DrawMouseSprite(pos, m_mouseSize, m_mice[index].icon2);
+}
+
+void Gfx::CEngine::DrawMouseSprite(Math::Point pos, Math::Point size, int icon)
+{
+    if (icon == -1)
+        return;
+
+    Math::Point p1 = pos;
+    Math::Point p2 = p1 + size;
+
+    float u1 = (32.0f / 256.0f) * (icon % 8);
+    float v1 = (32.0f / 256.0f) * (icon / 8);
+    float u2 = u1 + (32.0f / 256.0f);
+    float v2 = v1 + (32.0f / 256.0f);
+
+    float dp = 0.5f / 256.0f;
+    u1 += dp;
+    v1 += dp;
+    u2 -= dp;
+    v2 -= dp;
+
+    Math::Vector normal(0.0f, 0.0f, -1.0f);
+
+    Gfx::Vertex vertex[4] =
+    {
+        Gfx::Vertex(Math::Vector(p1.x, p1.y, 0.0f), normal, Math::Point(u1, v2)),
+        Gfx::Vertex(Math::Vector(p2.x, p1.y, 0.0f), normal, Math::Point(u2, v2)),
+        Gfx::Vertex(Math::Vector(p1.x, p2.y, 0.0f), normal, Math::Point(u1, v1)),
+        Gfx::Vertex(Math::Vector(p2.x, p2.y, 0.0f), normal, Math::Point(u2, v1))
+    };
+
+    m_device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, vertex, 4);
+    AddStatisticTriangle(2);
+}
+
+bool Gfx::CEngine::GetPause()
+{
+    return m_pause;
+}
+
+Math::Vector Gfx::CEngine::GetLookatPt()
+{
+    return m_lookatPt;
+}
+
+Math::Vector Gfx::CEngine::GetEyePt()
+{
+    return m_eyePt;
+}
+
+void Gfx::CEngine::SetMouseVisible(bool visible)
+{
+    m_mouseVisible = visible;
+}
+
+bool Gfx::CEngine::GetMouseVisible()
+{
+    return m_mouseVisible;
+}
+
+void Gfx::CEngine::SetMousePos(Math::Point pos)
+{
+    m_mousePos = pos;
+}
+
+Math::Point Gfx::CEngine::GetMousePos()
+{
+    return m_mousePos;
+}
+
+void Gfx::CEngine::SetMouseType(Gfx::EngineMouseType type)
+{
+    m_mouseType = type;
+}
+
+Gfx::EngineMouseType Gfx::CEngine::GetMouseType()
+{
+    return m_mouseType;
+}
+
+void Gfx::CEngine::AddStatisticTriangle(int count)
+{
+    m_statisticTriangle += count;
+}
+
+void Gfx::CEngine::SetShowStat(bool show)
+{
+    m_showStats = show;
+}
+
+bool Gfx::CEngine::GetShowStat()
+{
+    return m_showStats;
+}
+
diff --git a/src/graphics/engine/engine.h b/src/graphics/engine/engine.h
new file mode 100644
index 0000000..25c5e5d
--- /dev/null
+++ b/src/graphics/engine/engine.h
@@ -0,0 +1,1002 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// engine.h
+
+#pragma once
+
+
+#include "common/event.h"
+#include "graphics/core/color.h"
+#include "graphics/core/material.h"
+#include "graphics/core/texture.h"
+#include "graphics/core/vertex.h"
+#include "math/intpoint.h"
+#include "math/intsize.h"
+#include "math/matrix.h"
+#include "math/point.h"
+#include "math/vector.h"
+
+
+#include <string>
+#include <vector>
+#include <map>
+
+
+class CApplication;
+class CInstanceManager;
+class CObject;
+class CSound;
+
+
+namespace Gfx {
+
+class CDevice;
+class CLightManager;
+class CText;
+class CParticle;
+class CWater;
+class CCloud;
+class CLightning;
+class CPlanet;
+class CTerrain;
+
+
+/**
+  \enum EngineTriangleType
+  \brief Type of triangles drawn for engine objects */
+enum EngineTriangleType
+{
+    //! Triangles
+    ENG_TRIANGLE_TYPE_6T        = 1,
+    //! Surfaces
+    ENG_TRIANGLE_TYPE_6S        = 2
+};
+
+/**
+  \struct EngineTriangle
+  \brief A triangle drawn by the graphics engine */
+struct EngineTriangle
+{
+    //! Triangle vertices
+    Gfx::VertexTex2     triangle[3];
+    //! Material
+    Gfx::Material       material;
+    //! Render state (TODO: ?)
+    int                 state;
+    //! 1st texture
+    Gfx::Texture        tex1;
+    //! 2nd texture
+    Gfx::Texture        tex2;
+
+    EngineTriangle()
+    {
+        state = 0;
+    }
+};
+
+/**
+  \enum EngineObjectType
+  \brief Class of graphics engine object */
+enum EngineObjectType
+{
+    //! Object doesn't exist
+    ENG_OBJTYPE_NULL        = 0,
+    //! Terrain
+    ENG_OBJTYPE_TERRAIN     = 1,
+    //! Fixed object
+    ENG_OBJTYPE_FIX         = 2,
+    //! Moving object
+    ENG_OBJTYPE_VEHICULE    = 3,
+    //! Part of a moving object
+    ENG_OBJTYPE_DESCENDANT  = 4,
+    //! Fixed object type quartz
+    ENG_OBJTYPE_QUARTZ      = 5,
+    //! Fixed object type metal
+    ENG_OBJTYPE_METAL       = 6
+};
+
+/**
+  \struct EngineObject
+  \brief Object drawn by the graphics engine */
+struct EngineObject
+{
+    //! If true, the object is drawn
+    bool                   visible;
+    //! If true, object is behind the 2D interface
+    bool                   drawWorld;
+    //! If true, the shape is before the 2D interface
+    bool                   drawFront;
+    //! Number of triangles
+    int                    totalTriangles;
+    //! Type of object
+    Gfx::EngineObjectType  type;
+    //! Transformation matrix
+    Math::Matrix           transform;
+    //! Distance view - origin (TODO: ?)
+    float                  distance;
+    //! Bounding box min (origin 0,0,0 always included)
+    Math::Vector           bboxMin;
+    //! bounding box max (origin 0,0,0 always included)
+    Math::Vector           bboxMax;
+    //! Radius of the sphere at the origin
+    float                  radius;
+    //! Rank of the associated shadow
+    int                    shadowRank;
+    //! Transparency of the object [0, 1]
+    float                  transparency;
+
+    EngineObject()
+    {
+        visible = false;
+        drawWorld = false;
+        drawFront = false;
+        totalTriangles = 0;
+        distance = 0.0f;
+        radius = 0.0f;
+        shadowRank = 0;
+        transparency = 0.0f;
+    }
+};
+
+struct EngineObjLevel1;
+struct EngineObjLevel2;
+struct EngineObjLevel3;
+struct EngineObjLevel4;
+struct EngineObjLevel5;
+
+/**
+  \struct EngineObjLevel5
+  \brief Tier 5 of object tree */
+struct EngineObjLevel5
+{
+    Gfx::Material                material;
+    int                          state;
+    Gfx::EngineTriangleType      type;
+    std::vector<Gfx::VertexTex2> vertices;
+
+    EngineObjLevel5();
+};
+
+/**
+  \struct EngineObjLevel4
+  \brief Tier 4 of object tree */
+struct EngineObjLevel4
+{
+    int                                reserved;
+    std::vector<Gfx::EngineObjLevel5>  up;
+    Gfx::EngineObjLevel3*              down;
+
+    EngineObjLevel4();
+};
+
+/**
+  \struct EngineObjLevel3
+  \brief Tier 3 of object tree */
+struct EngineObjLevel3
+{
+    float                              min;
+    float                              max;
+    std::vector<Gfx::EngineObjLevel4>  up;
+    Gfx::EngineObjLevel2*              down;
+
+    EngineObjLevel3();
+};
+
+/**
+  \struct EngineObjLevel2
+  \brief Tier 2 of object tree */
+struct EngineObjLevel2
+{
+    int                                objRank;
+    std::vector<Gfx::EngineObjLevel3>  up;
+    Gfx::EngineObjLevel1*              down;
+
+    EngineObjLevel2();
+};
+
+/**
+  \struct EngineObjLevel1
+  \brief Tier 1 of object tree */
+struct EngineObjLevel1
+{
+    Gfx::Texture                       tex1;
+    Gfx::Texture                       tex2;
+    std::vector<Gfx::EngineObjLevel2>  up;
+
+    EngineObjLevel1();
+};
+
+/**
+  \struct EngineShadowType
+  \brief Type of shadow drawn by the graphics engine */
+enum EngineShadowType
+{
+    //! Normal shadow
+    ENG_SHADOW_NORM = 0,
+    //! TODO: ?
+    ENG_SHADOW_WORM = 1
+};
+
+/**
+  \struct EngineShadow
+  \brief Shadow drawn by the graphics engine */
+struct EngineShadow
+{
+    //! If true, shadow is invisible (object being carried for example)
+    bool                hide;
+    //! Rank of the associated object
+    int                 objRank;
+    //! Type of shadow
+    Gfx::EngineShadowType type;
+    //! Position of the shadow
+    Math::Vector        pos;
+    //! Normal to the terrain
+    Math::Vector        normal;
+    //! Angle of the shadow
+    float               angle;
+    //! Radius of the shadow
+    float               radius;
+    //! Intensity of the shadow
+    float               intensity;
+    //! Height from the ground
+    float               height;
+
+    EngineShadow()
+    {
+        hide = false;
+        objRank = 0;
+        angle = radius = intensity = height = 0.0f;
+    }
+};
+
+/**
+  \struct EngineGroundSpot
+  \brief A spot (large shadow) drawn on the ground by the graphics engine */
+struct EngineGroundSpot
+{
+    //! Color of the shadow
+    Gfx::Color      color;
+    //! Min altitude
+    float           min;
+    //! Max altitude
+    float           max;
+    //! Transition area
+    float           smooth;
+    //! Position for the shadow
+    Math::Vector    pos;
+    //! Radius of the shadow
+    float           radius;
+    //! Position of the shadow drawn
+    Math::Vector    drawPos;
+    //! Radius of the shadow drawn
+    float           drawRadius;
+
+    EngineGroundSpot()
+    {
+        min = max = smooth = radius = drawRadius = 0.0f;
+    }
+};
+
+/**
+  \enum EngineGroundMarkPhase
+  \brief Phase of life of an EngineGroundMark */
+enum EngineGroundMarkPhase
+{
+    //! Increase
+    ENG_GR_MARK_PHASE_INC = 1,
+    //! Fixed
+    ENG_GR_MARK_PHASE_FIX = 2,
+    //! Decrease
+    ENG_GR_MARK_PHASE_DEC = 2
+};
+
+/**
+  \struct EngineGroundMark
+  \brief A mark on ground drawn by the graphics engine */
+struct EngineGroundMark
+{
+    //! If true, draw mark
+    bool                        draw;
+    //! Phase of life
+    Gfx::EngineGroundMarkPhase  phase;
+    //! Times for 3 life phases
+    float                       delay[3];
+    //! Fixed time
+    float                       fix;
+    //! Position for marks
+    Math::Vector                pos;
+    //! Radius of marks
+    float                       radius;
+    //! Color intensity
+    float                       intensity;
+    //! Draw position for marks
+    Math::Vector                drawPos;
+    //! Radius for  marks
+    float                       drawRadius;
+    //! Draw intensity for marks
+    float                       drawIntensity;
+    //! X dimension of table
+    int                         dx;
+    //! Y dimension of table
+    int                         dy;
+    //! Pointer to the table
+    char*                       table;
+
+    EngineGroundMark()
+    {
+        draw = false;
+        delay[0] = delay[1] = delay[2] = 0.0f;
+        fix = radius = intensity = drawRadius = drawIntensity = 0.0f;
+        dx = dy = 0;
+        table = NULL;
+    }
+};
+
+/**
+  \enum EngineTextureMapping
+  \brief Type of texture mapping
+ */
+enum EngineTextureMapping
+{
+    ENG_TEX_MAPPING_X       = 1,
+    ENG_TEX_MAPPING_Y       = 2,
+    ENG_TEX_MAPPING_Z       = 3,
+    ENG_TEX_MAPPING_1X      = 4,
+    ENG_TEX_MAPPING_1Y      = 5,
+    ENG_TEX_MAPPING_1Z      = 6
+};
+
+
+/**
+  \enum EngineRenderState
+  \brief Render state of graphics engine
+
+  States are used for settings certain modes, for instance texturing and blending.
+  The enum is a bitmask and some of the states can be OR'd together. */
+enum EngineRenderState
+{
+    //! Normal opaque materials
+    ENG_RSTATE_NORMAL           = 0,
+    //! The transparent texture (black = no)
+    ENG_RSTATE_TTEXTURE_BLACK   = (1<<0),
+    //! The transparent texture (white = no)
+    ENG_RSTATE_TTEXTURE_WHITE   = (1<<1),
+    //! The transparent diffuse color
+    ENG_RSTATE_TDIFFUSE         = (1<<2),
+    //! Texture wrap
+    ENG_RSTATE_WRAP             = (1<<3),
+    //! Texture borders with solid color
+    ENG_RSTATE_CLAMP            = (1<<4),
+    //! Light texture (ambient max)
+    ENG_RSTATE_LIGHT            = (1<<5),
+    //! Double black texturing
+    ENG_RSTATE_DUAL_BLACK       = (1<<6),
+    //! Double white texturing
+    ENG_RSTATE_DUAL_WHITE       = (1<<7),
+    //! Part 1 (no change in. MOD!)
+    ENG_RSTATE_PART1            = (1<<8),
+    //! Part 2
+    ENG_RSTATE_PART2            = (1<<9),
+    //! Part 3
+    ENG_RSTATE_PART3            = (1<<10),
+    //! Part 4
+    ENG_RSTATE_PART4            = (1<<11),
+    //! Double-sided face
+    ENG_RSTATE_2FACE            = (1<<12),
+    //! Image using alpha channel
+    ENG_RSTATE_ALPHA            = (1<<13),
+    //! Always use 2nd floor texturing
+    ENG_RSTATE_SECOND           = (1<<14),
+    //! Causes the fog
+    ENG_RSTATE_FOG              = (1<<15),
+    //! The transparent color (black = no)
+    ENG_RSTATE_TCOLOR_BLACK     = (1<<16),
+    //! The transparent color (white = no)
+    ENG_RSTATE_TCOLOR_WHITE     = (1<<17)
+};
+
+
+/**
+  \enum EngineMouseType
+  \brief Type of mouse cursor displayed in-game */
+enum EngineMouseType
+{
+    //! Normal cursor (arrow)
+    ENG_MOUSE_NORM      = 0,
+    //! Busy
+    ENG_MOUSE_WAIT      = 1,
+    //! Edit (I-beam)
+    ENG_MOUSE_EDIT      = 2,
+    //! Hand
+    ENG_MOUSE_HAND      = 3,
+    //! Small cross
+    ENG_MOUSE_CROSS     = 4,
+    //! TODO: ?
+    ENG_MOUSE_SHOW      = 5,
+    //! Crossed out sign
+    ENG_MOUSE_NO        = 6,
+    //! Resize
+    ENG_MOUSE_MOVE      = 7,
+    //! Resize horizontally
+    ENG_MOUSE_MOVEH     = 8,
+    //! Resize vertically
+    ENG_MOUSE_MOVEV     = 9,
+    //! Resize diagonally bottom-left to top-right
+    ENG_MOUSE_MOVED     = 10,
+    //! Resize diagonally top-left to bottom-right
+    ENG_MOUSE_MOVEI     = 11,
+    //! Scroll to the left
+    ENG_MOUSE_SCROLLL   = 12,
+    //! Scroll to the right
+    ENG_MOUSE_SCROLLR   = 13,
+    //! Scroll up
+    ENG_MOUSE_SCROLLU   = 14,
+    //! Scroll down
+    ENG_MOUSE_SCROLLD   = 15,
+    //! Larger crosshair
+    ENG_MOUSE_TARGET    = 16,
+
+    //! Number of items in enum
+    ENG_MOUSE_COUNT
+};
+
+/**
+  \struct EngineMouse
+  \brief Information about mouse cursor */
+struct EngineMouse
+{
+    //! Index of texture element for 1st image
+    int icon1;
+    //! Index of texture element for 2nd image
+    int icon2;
+    //! Shadow texture part
+    int iconShadow;
+    //! Mode to render 1st image in
+    Gfx::EngineRenderState mode1;
+    //! Mode to render 2nd image in
+    Gfx::EngineRenderState mode2;
+    //! Hot point
+    Math::Point hotPoint;
+
+    EngineMouse(int icon1 = -1, int icon2 = -1, int iconShadow = -1,
+                Gfx::EngineRenderState mode1 = Gfx::ENG_RSTATE_NORMAL,
+                Gfx::EngineRenderState mode2 = Gfx::ENG_RSTATE_NORMAL,
+                Math::Point hotPoint = Math::Point())
+    {
+        this->icon1      = icon1;
+        this->icon2      = icon2;
+        this->iconShadow = iconShadow;
+        this->mode1      = mode1;
+        this->mode2      = mode2;
+        this->hotPoint   = hotPoint;
+    }
+};
+
+
+/**
+  \class CEngine
+  \brief The graphics engine
+
+  This is the main class for graphics engine. It is responsible for drawing the 3D scene,
+  setting various render states, and facilitating the drawing of 2D interface.
+
+  It uses a lower-level CDevice object which is implementation-independent core engine.
+
+  \section Objecs Engine objects
+
+  The 3D scene is composed of objects which are basically collections of triangles forming
+  a surface or simply independent triangles in space. Objects are stored in the engine
+  as a tree structure which is composed of 5 tiers (EngineObjLevel1, EngineObjLevel2 and so on).
+  Each tier stores some data about object triangle, like textures or materials used.
+  Additional information on objects stored are in EngineObject structure.
+  Each object is uniquely identified by its rank.
+
+  ...
+ */
+class CEngine
+{
+public:
+    CEngine(CInstanceManager *iMan, CApplication *app);
+    ~CEngine();
+
+    //! Returns whether the device was initialized
+    bool            GetWasInit();
+    //! Returns the last error encountered
+    std::string     GetError();
+
+    //! Performs the first initialization, before a device was set
+    bool            Create();
+    //! Frees all resources before exit
+    void            Destroy();
+
+    //! Sets the device to be used
+    void            SetDevice(Gfx::CDevice *device);
+    //! Returns the current device
+    Gfx::CDevice*   GetDevice();
+
+    //! Performs initialization after a device was created and set
+    bool            AfterDeviceSetInit();
+
+    //! Resets some states and flushes textures after device was changed (e.g. resoulution changed)
+    void            ResetAfterDeviceChanged();
+
+    void            SetTerrain(Gfx::CTerrain* terrain);
+
+    //! Processes incoming event
+    bool            ProcessEvent(const Event &event);
+
+    //! Renders a single frame
+    bool            Render();
+
+
+    bool            WriteProfile();
+
+    void            SetPause(bool pause);
+    bool            GetPause();
+
+    void            SetMovieLock(bool lock);
+    bool            GetMovieLock();
+
+    void            SetShowStat(bool show);
+    bool            GetShowStat();
+
+    void            SetRenderEnable(bool enable);
+
+    int             OneTimeSceneInit();
+    int             InitDeviceObjects();
+    int             DeleteDeviceObjects();
+    int             RestoreSurfaces();
+    int             FrameMove(float rTime);
+    void            StepSimulation(float rTime);
+    int             FinalCleanup();
+    void            AddStatisticTriangle(int nb);
+    int             GetStatisticTriangle();
+    void            SetHiliteRank(int *rankList);
+    bool            GetHilite(Math::Point &p1, Math::Point &p2);
+    bool            GetSpriteCoord(int &x, int &y);
+    void            SetInfoText(int line, char* text);
+    char*           GetInfoText(int line);
+    void            FirstExecuteAdapt(bool first);
+
+    bool            GetFullScreen();
+
+    Math::Matrix*   GetMatView();
+    Math::Matrix*   GetMatLeftView();
+    Math::Matrix*   GetMatRightView();
+
+    void            TimeInit();
+    void            TimeEnterGel();
+    void            TimeExitGel();
+    float           TimeGet();
+
+    int             GetRestCreate();
+    int             CreateObject();
+    void            FlushObject();
+    bool            DeleteObject(int objRank);
+    bool            SetDrawWorld(int objRank, bool draw);
+    bool            SetDrawFront(int objRank, bool draw);
+
+    bool            AddTriangle(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat,
+                                int state, std::string texName1, std::string texName2,
+                                float min, float max, bool globalUpdate);
+    bool            AddSurface(int objRank, Gfx::VertexTex2* vertex, int nb, const Gfx::Material &mat,
+                               int state, std::string texName1, std::string texName2,
+                               float min, float max, bool globalUpdate);
+    bool            AddQuick(int objRank, Gfx::EngineObjLevel5* buffer,
+                             std::string texName1, std::string texName2,
+                             float min, float max, bool globalUpdate);
+    Gfx::EngineObjLevel5* SearchTriangle(int objRank, const Gfx::Material &mat,
+                                         int state, std::string texName1, std::string texName2,
+                                         float min, float max);
+
+    void            ChangeLOD();
+    bool            ChangeSecondTexture(int objRank, char* texName2);
+    int             GetTotalTriangles(int objRank);
+    int             GetTriangles(int objRank, float min, float max, Gfx::EngineTriangle* buffer, int size, float percent);
+    bool            GetBBox(int objRank, Math::Vector &min, Math::Vector &max);
+    bool            ChangeTextureMapping(int objRank, const Gfx::Material &mat, int state,
+                                         const std::string &texName1, const std::string &texName2,
+                                         float min, float max, Gfx::EngineTextureMapping mode,
+                                         float au, float bu, float av, float bv);
+    bool            TrackTextureMapping(int objRank, const Gfx::Material &mat, int state,
+                                        const std::string &texName1, const std::string &texName2,
+                                        float min, float max, Gfx::EngineTextureMapping mode,
+                                        float pos, float factor, float tl, float ts, float tt);
+    bool            SetObjectTransform(int objRank, const Math::Matrix &transform);
+    bool            GetObjectTransform(int objRank, Math::Matrix &transform);
+    bool            SetObjectType(int objRank, Gfx::EngineObjectType type);
+    Gfx::EngineObjectType GetObjectType(int objRank);
+    bool            SetObjectTransparency(int objRank, float value);
+
+    bool            ShadowCreate(int objRank);
+    void            ShadowDelete(int objRank);
+    bool            SetObjectShadowHide(int objRank, bool hide);
+    bool            SetObjectShadowType(int objRank, Gfx::EngineShadowType type);
+    bool            SetObjectShadowPos(int objRank, const Math::Vector &pos);
+    bool            SetObjectShadowNormal(int objRank, const Math::Vector &n);
+    bool            SetObjectShadowAngle(int objRank, float angle);
+    bool            SetObjectShadowRadius(int objRank, float radius);
+    bool            SetObjectShadowIntensity(int objRank, float intensity);
+    bool            SetObjectShadowHeight(int objRank, float h);
+    float           GetObjectShadowRadius(int objRank);
+
+    void            GroundSpotFlush();
+    int             GroundSpotCreate();
+    void            GroundSpotDelete(int rank);
+    bool            SetObjectGroundSpotPos(int rank, const Math::Vector &pos);
+    bool            SetObjectGroundSpotRadius(int rank, float radius);
+    bool            SetObjectGroundSpotColor(int rank, const Gfx::Color &color);
+    bool            SetObjectGroundSpotMinMax(int rank, float min, float max);
+    bool            SetObjectGroundSpotSmooth(int rank, float smooth);
+
+    int             GroundMarkCreate(Math::Vector pos, float radius,
+                                     float delay1, float delay2, float delay3,
+                                     int dx, int dy, char* table);
+    bool            GroundMarkDelete(int rank);
+
+    void            Update();
+
+    void            SetViewParams(const Math::Vector &eyePt, const Math::Vector &lookatPt,
+                                  const Math::Vector &upVec, float eyeDistance);
+
+    Gfx::Texture    CreateTexture(const std::string &texName,
+                                  const Gfx::TextureCreateParams &params);
+    Gfx::Texture    CreateTexture(const std::string &texName);
+    void            DestroyTexture(const std::string &texName);
+
+    bool            LoadTexture(const std::string &name, int stage = 0);
+    bool            LoadAllTextures();
+
+    void            SetLimitLOD(int rank, float limit);
+    float           GetLimitLOD(int rank, bool last=false);
+
+    void            SetTerrainVision(float vision);
+
+    void            SetGroundSpot(bool mode);
+    bool            GetGroundSpot();
+    void            SetShadow(bool mode);
+    bool            GetShadow();
+    void            SetDirty(bool mode);
+    bool            GetDirty();
+    void            SetFog(bool mode);
+    bool            GetFog();
+    bool            GetStateColor();
+
+    void            SetSecondTexture(int texNum);
+    int             GetSecondTexture();
+
+    void            SetRankView(int rank);
+    int             GetRankView();
+
+    void            SetDrawWorld(bool draw);
+    void            SetDrawFront(bool draw);
+
+    void            SetAmbientColor(const Gfx::Color &color, int rank = 0);
+    Gfx::Color      GetAmbientColor(int rank = 0);
+
+    void            SetWaterAddColor(const Gfx::Color &color);
+    Gfx::Color      GetWaterAddColor();
+
+    void            SetFogColor(const Gfx::Color &color, int rank = 0);
+    Gfx::Color      GetFogColor(int rank = 0);
+
+    void            SetDeepView(float length, int rank = 0, bool ref=false);
+    float           GetDeepView(int rank = 0);
+
+    void            SetFogStart(float start, int rank = 0);
+    float           GetFogStart(int rank = 0);
+
+    void            SetBackground(const std::string &name, Gfx::Color up = Gfx::Color(), Gfx::Color down = Gfx::Color(),
+                                  Gfx::Color cloudUp = Gfx::Color(), Gfx::Color cloudDown = Gfx::Color(),
+                                  bool full = false, bool quarter = false);
+    void            GetBackground(const std::string &name, Gfx::Color &up, Gfx::Color &down,
+                                  Gfx::Color &cloudUp, Gfx::Color &cloudDown,
+                                  bool &full, bool &quarter);
+    void            SetFrontsizeName(char *name);
+    void            SetOverFront(bool front);
+    void            SetOverColor(const Gfx::Color &color = Gfx::Color(), int mode = ENG_RSTATE_TCOLOR_BLACK);
+
+    void            SetParticleDensity(float value);
+    float           GetParticleDensity();
+    float           ParticleAdapt(float factor);
+
+    void            SetClippingDistance(float value);
+    float           GetClippingDistance();
+
+    void            SetObjectDetail(float value);
+    float           GetObjectDetail();
+
+    void            SetGadgetQuantity(float value);
+    float           GetGadgetQuantity();
+
+    void            SetTextureQuality(int value);
+    int             GetTextureQuality();
+
+    void            SetTotoMode(bool present);
+    bool            GetTotoMode();
+
+    void            SetLensMode(bool present);
+    bool            GetLensMode();
+
+    void            SetWaterMode(bool present);
+    bool            GetWaterMode();
+
+    void            SetLightingMode(bool present);
+    bool            GetLightingMode();
+
+    void            SetSkyMode(bool present);
+    bool            GetSkyMode();
+
+    void            SetBackForce(bool present);
+    bool            GetBackForce();
+
+    void            SetPlanetMode(bool present);
+    bool            GetPlanetMode();
+
+    void            SetLightMode(bool present);
+    bool            GetLightMode();
+
+    void            SetEditIndentMode(bool autoIndent);
+    bool            GetEditIndentMode();
+
+    void            SetEditIndentValue(int value);
+    int             GetEditIndentValue();
+
+    void            SetSpeed(float speed);
+    float           GetSpeed();
+
+    void            SetTracePrecision(float factor);
+    float           GetTracePrecision();
+
+    void            SetFocus(float focus);
+    float           GetFocus();
+    Math::Vector    GetEyePt();
+    Math::Vector    GetLookatPt();
+    float           GetEyeDirH();
+    float           GetEyeDirV();
+    Math::Point     GetDim();
+    void            UpdateMatProj();
+
+    void            ApplyChange();
+
+    void            FlushPressKey();
+    void            ResetKey();
+    void            SetKey(int keyRank, int option, int key);
+    int             GetKey(int keyRank, int option);
+
+    void            SetJoystick(bool enable);
+    bool            GetJoystick();
+
+    void            SetDebugMode(bool mode);
+    bool            GetDebugMode();
+    bool            GetSetupMode();
+
+    bool            IsVisiblePoint(const Math::Vector &pos);
+
+    int             DetectObject(Math::Point mouse);
+    void            SetState(int state, Gfx::Color color = Gfx::Color(1.0f, 1.0f, 1.0f, 1.0f));
+    void            SetTexture(const std::string &name, int stage = 0);
+    void            SetMaterial(const Gfx::Material &mat);
+
+    void                 SetMouseVisible(bool show);
+    bool                 GetMouseVisible();
+    void                 SetMousePos(Math::Point pos);
+    Math::Point          GetMousePos();
+    void                 SetMouseType(Gfx::EngineMouseType type);
+    Gfx::EngineMouseType GetMouseType();
+
+    CText*          GetText();
+
+    bool            ChangeColor(char *name, Gfx::Color colorRef1, Gfx::Color colorNew1,
+                                Gfx::Color colorRef2, Gfx::Color colorNew2,
+                                float tolerance1, float tolerance2,
+                                Math::Point ts, Math::Point ti,
+                                Math::Point *pExclu=0, float shift=0.0f, bool hSV=false);
+    bool            OpenImage(char *name);
+    bool            CopyImage();
+    bool            LoadImage();
+    bool            ScrollImage(int dx, int dy);
+    bool            SetDot(int x, int y, Gfx::Color color);
+    bool            CloseImage();
+    bool            WriteScreenShot(char *filename, int width, int height);
+    //bool      GetRenderDC(HDC &hDC);
+    //bool      ReleaseRenderDC(HDC &hDC);
+    //PBITMAPINFO   CreateBitmapInfoStruct(HBITMAP hBmp);
+    //bool      CreateBMPFile(LPTSTR pszFile, PBITMAPINFO pbi, HBITMAP hBMP, HDC hDC);
+
+protected:
+
+    void        SetUp3DView();
+    bool        Draw3DScene();
+
+    void        SetUpInterfaceView();
+    bool        DrawInterface();
+
+    void        DrawGroundSpot();
+    void        DrawShadow();
+    void        DrawBackground();
+    void        DrawBackgroundGradient(Gfx::Color up, Gfx::Color down);
+    void        DrawBackgroundImageQuarter(Math::Point p1, Math::Point p2, char *name);
+    void        DrawBackgroundImage();
+    void        DrawPlanet();
+    void        DrawFrontsize();
+    void        DrawOverColor();
+    void        DrawHilite();
+    void        DrawMouse();
+    void        DrawMouseSprite(Math::Point pos, Math::Point dim, int icon);
+
+    /*
+    Gfx::ObjLevel2* AddLevel1(Gfx::ObjLevel1 *&p1, char* texName1, char* texName2);
+    Gfx::ObjLevel3* AddLevel2(Gfx::ObjLevel2 *&p2, int objRank);
+    Gfx::ObjLevel4* AddLevel3(Gfx::ObjLevel3 *&p3, float min, float max);
+    Gfx::ObjLevel5* AddLevel4(Gfx::ObjLevel4 *&p4, int reserve);
+    Gfx::ObjLevel6* AddLevel5(Gfx::ObjLevel5 *&p5, Gfx::TriangleType type, const Gfx::Material &mat, int state, int nb);*/
+
+    bool        IsVisible(int objRank);
+    bool        DetectBBox(int objRank, Math::Point mouse);
+    bool        GetBBox2D(int objRank, Math::Point &min, Math::Point &max);
+    bool        DetectTriangle(Math::Point mouse, Gfx::VertexTex2 *triangle, int objRank, float &dist);
+    bool        TransformPoint(Math::Vector &p2D, int objRank, Math::Vector p3D);
+    void        ComputeDistance();
+    void        UpdateGeometry();
+
+protected:
+    CInstanceManager*   m_iMan;
+    CApplication*       m_app;
+    CSound*             m_sound;
+    Gfx::CDevice*       m_device;
+    Gfx::CText*         m_text;
+    Gfx::CLightManager* m_lightMan;
+    Gfx::CParticle*     m_particle;
+    Gfx::CWater*        m_water;
+    Gfx::CCloud*        m_cloud;
+    Gfx::CLightning*    m_lightning;
+    Gfx::CPlanet*       m_planet;
+    Gfx::CTerrain*      m_terrain;
+
+    bool            m_wasInit;
+    std::string     m_error;
+
+    //! Whether to show stats (FPS, etc)
+    bool            m_showStats;
+
+    int             m_blackSrcBlend[2];
+    int             m_blackDestBlend[2];
+    int             m_whiteSrcBlend[2];
+    int             m_whiteDestBlend[2];
+    int             m_diffuseSrcBlend[2];
+    int             m_diffuseDestBlend[2];
+    int             m_alphaSrcBlend[2];
+    int             m_alphaDestBlend[2];
+
+    Math::Matrix    m_matProj;
+    Math::Matrix    m_matLeftView;
+    Math::Matrix    m_matRightView;
+    Math::Matrix    m_matView;
+    float           m_focus;
+
+    Math::Matrix    m_matWorldInterface;
+    Math::Matrix    m_matProjInterface;
+    Math::Matrix    m_matViewInterface;
+
+    long            m_baseTime;
+    long            m_stopTime;
+    float           m_absTime;
+    float           m_lastTime;
+    float           m_speed;
+    bool            m_pause;
+    bool            m_render;
+    bool            m_movieLock;
+
+    //! Current size of window
+    Math::IntSize   m_size;
+    Math::IntSize   m_lastSize;
+
+    std::vector<Gfx::EngineObjLevel1>  m_objectTree;
+    std::vector<Gfx::EngineObject>     m_objects;
+    std::vector<Gfx::EngineShadow>     m_shadow;
+    std::vector<Gfx::EngineGroundSpot> m_groundSpot;
+    Gfx::EngineGroundMark              m_groundMark;
+
+    Math::Vector    m_eyePt;
+    Math::Vector    m_lookatPt;
+    float           m_eyeDirH;
+    float           m_eyeDirV;
+    int             m_rankView;
+    Gfx::Color      m_ambientColor[2];
+    Gfx::Color      m_backColor[2];
+    Gfx::Color      m_fogColor[2];
+    float           m_deepView[2];
+    float           m_fogStart[2];
+    Gfx::Color      m_waterAddColor;
+    int             m_statisticTriangle;
+    bool            m_updateGeometry;
+    //char            m_infoText[10][200];
+    int             m_alphaMode;
+    bool            m_stateColor;
+    bool            m_forceStateColor;
+    bool            m_groundSpotVisible;
+    bool            m_shadowVisible;
+    bool            m_dirty;
+    bool            m_fog;
+    bool            m_firstGroundSpot;
+    int             m_secondTexNum;
+    std::string     m_backgroundName;
+    Gfx::Color      m_backgroundColorUp;
+    Gfx::Color      m_backgroundColorDown;
+    Gfx::Color      m_backgroundCloudUp;
+    Gfx::Color      m_backgroundCloudDown;
+    bool            m_backgroundFull;
+    bool            m_backgroundQuarter;
+    bool            m_overFront;
+    Gfx::Color      m_overColor;
+    int             m_overMode;
+    std::string     m_frontsizeName;
+    bool            m_drawWorld;
+    bool            m_drawFront;
+    float           m_limitLOD[2];
+    float           m_particuleDensity;
+    float           m_clippingDistance;
+    float           m_lastClippingDistance;
+    float           m_objectDetail;
+    float           m_lastObjectDetail;
+    float           m_terrainVision;
+    float           m_gadgetQuantity;
+    int             m_textureQuality;
+    bool            m_totoMode;
+    bool            m_lensMode;
+    bool            m_waterMode;
+    bool            m_skyMode;
+    bool            m_backForce;
+    bool            m_planetMode;
+    bool            m_lightMode;
+    bool            m_editIndentMode;
+    int             m_editIndentValue;
+    float           m_tracePrecision;
+
+    int             m_hiliteRank[100];
+    bool            m_hilite;
+    Math::Point     m_hiliteP1;
+    Math::Point     m_hiliteP2;
+
+    int             m_lastState;
+    Gfx::Color      m_lastColor;
+    char            m_lastTexture[2][50];
+    Gfx::Material   m_lastMaterial;
+
+    std::string     m_texPath;
+    Gfx::TextureCreateParams m_defaultTexParams;
+
+    std::map<std::string, Gfx::Texture> m_texNameMap;
+    std::map<Gfx::Texture, std::string> m_revTexNameMap;
+
+    Gfx::EngineMouse     m_mice[Gfx::ENG_MOUSE_COUNT];
+    Gfx::Texture         m_miceTexture;
+    Math::Point          m_mouseSize;
+    Gfx::EngineMouseType m_mouseType;
+    Math::Point          m_mousePos;
+    bool                 m_mouseVisible;
+
+    //LPDIRECTDRAWSURFACE7 m_imageSurface;
+    //DDSURFACEDESC2        m_imageDDSD;
+    //WORD*             m_imageCopy;
+    //int                   m_imageDX;
+    //int                   m_imageDY;
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/engine/lightman.cpp b/src/graphics/engine/lightman.cpp
new file mode 100644
index 0000000..9e15b5a
--- /dev/null
+++ b/src/graphics/engine/lightman.cpp
@@ -0,0 +1,416 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// light.cpp
+
+#include "graphics/engine/lightman.h"
+
+#include "common/iman.h"
+#include "graphics/core/device.h"
+#include "math/geometry.h"
+
+#include <cmath>
+
+
+void Gfx::LightProgression::Init(float value)
+{
+    starting = value;
+    ending   = value;
+    current  = value;
+    progress = 0.0f;
+    speed    = 100.0f;
+}
+
+void Gfx::LightProgression::Update(float rTime)
+{
+    if (speed < 100.0f)
+    {
+        if (progress < 1.0f)
+        {
+            progress += speed * rTime;
+            if (progress > 1.0f)
+                progress = 1.0f;
+        }
+
+        current = starting + progress * (ending - starting);
+    }
+    else
+    {
+        current = ending;
+    }
+}
+
+void Gfx::LightProgression::SetTarget(float value)
+{
+    starting = current;
+    ending   = value;
+    progress = 0.0f;
+}
+
+
+Gfx::DynamicLight::DynamicLight()
+{
+    used = enabled = false;
+}
+
+
+
+Gfx::CLightManager::CLightManager(CInstanceManager* iMan, Gfx::CEngine* engine)
+{
+    m_iMan = iMan;
+    m_iMan->AddInstance(CLASS_LIGHT, this);
+
+    m_device = NULL;
+    m_engine = engine;
+
+    m_time = 0.0f;
+}
+
+Gfx::CLightManager::~CLightManager()
+{
+    m_iMan->DeleteInstance(CLASS_LIGHT, this);
+
+    m_iMan = NULL;
+    m_device = NULL;
+    m_engine = NULL;
+}
+
+void Gfx::CLightManager::SetDevice(Gfx::CDevice* device)
+{
+    m_device = device;
+
+    m_dynLights = std::vector<Gfx::DynamicLight>(m_device->GetMaxLightCount(), Gfx::DynamicLight());
+}
+
+void Gfx::CLightManager::FlushLights()
+{
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        m_dynLights[i].used = false;
+        m_device->SetLightEnabled(i, false);
+    }
+}
+
+/** Returns the index of light created or -1 if all lights are used. */
+int Gfx::CLightManager::CreateLight()
+{
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        if (m_dynLights[i].used) continue;
+
+        m_dynLights[i] = Gfx::DynamicLight();
+
+        m_dynLights[i].used    = true;
+        m_dynLights[i].enabled = true;
+
+        m_dynLights[i].includeType = Gfx::ENG_OBJTYPE_NULL;
+        m_dynLights[i].excludeType = Gfx::ENG_OBJTYPE_NULL;
+
+        m_dynLights[i].light.type      = Gfx::LIGHT_DIRECTIONAL;
+        m_dynLights[i].light.diffuse   = Gfx::Color(0.5f, 0.5f, 0.5f);
+        m_dynLights[i].light.position  = Math::Vector(-100.0f,  100.0f, -100.0f);
+        m_dynLights[i].light.direction = Math::Vector( 1.0f, -1.0f,  1.0f);
+
+        m_dynLights[i].intensity.Init(1.0f);  // maximum
+        m_dynLights[i].colorRed.Init(0.5f);
+        m_dynLights[i].colorGreen.Init(0.5f);
+        m_dynLights[i].colorBlue.Init(0.5f);  // gray
+
+        return i;
+    }
+
+    return -1;
+}
+
+bool Gfx::CLightManager::DeleteLight(int lightRank)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].used = false;
+    m_device->SetLightEnabled(lightRank, false);
+
+    return true;
+}
+
+// Specifies a light.
+
+bool Gfx::CLightManager::SetLight(int lightRank, const Gfx::Light &light)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].light = light;
+
+    m_dynLights[lightRank].colorRed.Init(m_dynLights[lightRank].light.diffuse.r);
+    m_dynLights[lightRank].colorGreen.Init(m_dynLights[lightRank].light.diffuse.g);
+    m_dynLights[lightRank].colorBlue.Init(m_dynLights[lightRank].light.diffuse.b);
+
+    return true;
+}
+
+bool Gfx::CLightManager::GetLight(int lightRank, Gfx::Light &light)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    light = m_dynLights[lightRank].light;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightEnabled(int lightRank, bool enabled)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].enabled = enabled;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightIncludeType(int lightRank, Gfx::EngineObjectType type)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].includeType = type;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightExcludeType(int lightRank, Gfx::EngineObjectType type)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].excludeType = type;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightPos(int lightRank, const Math::Vector &pos)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].light.position = pos;
+    return true;
+}
+
+Math::Vector Gfx::CLightManager::GetLightPos(int lightRank)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return Math::Vector(0.0f, 0.0f, 0.0f);
+
+    return m_dynLights[lightRank].light.position;
+}
+
+bool Gfx::CLightManager::SetLightDir(int lightRank, const Math::Vector &dir)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].light.direction = dir;
+    return true;
+}
+
+Math::Vector Gfx::CLightManager::GetLightDir(int lightRank)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return Math::Vector(0.0f, 0.0f, 0.0f);
+
+    return m_dynLights[lightRank].light.direction;
+}
+
+bool Gfx::CLightManager::SetLightIntensitySpeed(int lightRank, float speed)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].intensity.speed = speed;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightIntensity(int lightRank, float value)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].intensity.SetTarget(value);
+    return true;
+}
+
+float Gfx::CLightManager::GetLightIntensity(int lightRank)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return 0.0f;
+
+    return m_dynLights[lightRank].intensity.current;
+}
+
+
+bool Gfx::CLightManager::SetLightColorSpeed(int lightRank, float speed)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].colorRed.speed   = speed;
+    m_dynLights[lightRank].colorGreen.speed = speed;
+    m_dynLights[lightRank].colorBlue.speed  = speed;
+    return true;
+}
+
+bool Gfx::CLightManager::SetLightColor(int lightRank, const Gfx::Color &color)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return false;
+
+    m_dynLights[lightRank].colorRed.SetTarget(color.r);
+    m_dynLights[lightRank].colorGreen.SetTarget(color.g);
+    m_dynLights[lightRank].colorBlue.SetTarget(color.b);
+    return true;
+}
+
+Gfx::Color Gfx::CLightManager::GetLightColor(int lightRank)
+{
+    if ( (lightRank < 0) || (lightRank >= static_cast<int>( m_dynLights.size() )) )
+        return Gfx::Color(0.5f, 0.5f, 0.5f, 0.5f);
+
+    Gfx::Color color;
+    color.r = m_dynLights[lightRank].colorRed.current;
+    color.g = m_dynLights[lightRank].colorGreen.current;
+    color.b = m_dynLights[lightRank].colorBlue.current;
+    return color;
+}
+
+void Gfx::CLightManager::AdaptLightColor(const Gfx::Color &color, float factor)
+{
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        if (! m_dynLights[i].used)
+            continue;
+
+        Gfx::Color value;
+        value.r = m_dynLights[i].colorRed.current;
+        value.g = m_dynLights[i].colorGreen.current;
+        value.b = m_dynLights[i].colorBlue.current;
+
+        value.r += color.r * factor;
+        value.g += color.g * factor;
+        value.b += color.b * factor;
+
+        m_dynLights[i].colorRed.Init(value.r);
+        m_dynLights[i].colorGreen.Init(value.g);
+        m_dynLights[i].colorBlue.Init(value.b);
+    }
+
+    UpdateLights();
+}
+
+void Gfx::CLightManager::UpdateProgression(float rTime)
+{
+    if (m_engine->GetPause())
+        return;
+
+    m_time += rTime;
+
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        if (! m_dynLights[i].used)
+            continue;
+
+        m_dynLights[i].intensity.Update(rTime);
+        m_dynLights[i].colorRed.Update(rTime);
+        m_dynLights[i].colorGreen.Update(rTime);
+        m_dynLights[i].colorBlue.Update(rTime);
+
+        if (m_dynLights[i].includeType == Gfx::ENG_OBJTYPE_QUARTZ)
+        {
+            m_dynLights[i].light.direction.x = sinf(1.0f * (m_time + i*Math::PI*0.5f));
+            m_dynLights[i].light.direction.z = cosf(1.1f * (m_time + i*Math::PI*0.5f));
+            m_dynLights[i].light.direction.y = -1.0f + 0.5f * cosf((m_time + i*Math::PI*0.5f)*2.7f);
+        }
+
+        if (m_dynLights[i].includeType == Gfx::ENG_OBJTYPE_METAL)
+        {
+            Math::Vector dir = m_engine->GetEyePt() - m_engine->GetLookatPt();
+            float angle = Math::RotateAngle(dir.x, dir.z);
+            angle += Math::PI * 0.5f * i;
+            m_dynLights[i].light.direction.x = sinf(2.0f * angle);
+            m_dynLights[i].light.direction.z = cosf(2.0f * angle);
+        }
+    }
+}
+
+
+void Gfx::CLightManager::UpdateLights()
+{
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        if (! m_dynLights[i].used)
+            continue;
+
+        bool enabled = m_dynLights[i].enabled;
+        if (m_dynLights[i].intensity.current == 0.0f)
+            enabled = false;
+
+        if (enabled)
+        {
+            float value = m_dynLights[i].colorRed.current * m_dynLights[i].intensity.current;
+            m_dynLights[i].light.diffuse.r = value;
+
+            value = m_dynLights[i].colorGreen.current * m_dynLights[i].intensity.current;
+            m_dynLights[i].light.diffuse.g = value;
+
+            value = m_dynLights[i].colorBlue.current * m_dynLights[i].intensity.current;
+            m_dynLights[i].light.diffuse.b = value;
+
+            m_device->SetLight(i, m_dynLights[i].light);
+            m_device->SetLightEnabled(i, enabled);
+        }
+        else
+        {
+            m_dynLights[i].light.diffuse.r = 0.0f;
+            m_dynLights[i].light.diffuse.g = 0.0f;
+            m_dynLights[i].light.diffuse.b = 0.0f;
+
+            m_device->SetLightEnabled(i, enabled);
+        }
+    }
+}
+
+void Gfx::CLightManager::UpdateLightsEnableState(Gfx::EngineObjectType type)
+{
+    for (int i = 0; i < static_cast<int>( m_dynLights.size() ); i++)
+    {
+        if (! m_dynLights[i].used)
+            continue;
+        if (! m_dynLights[i].enabled)
+            continue;
+        if (m_dynLights[i].intensity.current == 0.0f)
+            continue;
+
+        if (m_dynLights[i].includeType != Gfx::ENG_OBJTYPE_NULL)
+        {
+            bool enabled = (m_dynLights[i].includeType == type);
+            m_device->SetLightEnabled(i, enabled);
+        }
+
+        if (m_dynLights[i].excludeType != Gfx::ENG_OBJTYPE_NULL)
+        {
+            bool enabled = (m_dynLights[i].excludeType != type);
+            m_device->SetLightEnabled(i, enabled);
+        }
+    }
+}
diff --git a/src/graphics/engine/lightman.h b/src/graphics/engine/lightman.h
new file mode 100644
index 0000000..8272125
--- /dev/null
+++ b/src/graphics/engine/lightman.h
@@ -0,0 +1,181 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// lightman.h
+
+#pragma once
+
+
+#include "graphics/core/color.h"
+#include "graphics/core/light.h"
+#include "graphics/engine/engine.h"
+#include "math/vector.h"
+
+
+namespace Gfx {
+
+/**
+  \struct LightProgression
+  \brief Describes the progression of light parameters change */
+struct LightProgression
+{
+    //! Starting value
+    float   starting;
+    //! Ending (destination) value
+    float   ending;
+    //! Current value
+    float   current;
+    //! Progress from start to end
+    float   progress;
+    //! Speed of progression
+    float   speed;
+
+    LightProgression()
+    {
+        starting = ending = current = progress = speed = 0.0f;
+    }
+
+    //! Initializes the progression
+    void Init(float value);
+
+    //! Updates the progression
+    void Update(float rTime);
+
+    //! Sets the new end value (starting is set to current)
+    void SetTarget(float value);
+};
+
+/**
+  \struct DynamicLight
+  \brief Dynamic light in 3D scene
+
+  It is an extension over standard light properties. Added are dynamic progressions for light
+  colors and intensity and types of objects included/excluded in lighting. */
+struct DynamicLight
+{
+    //! Whether the light is used
+    bool used;
+    //! Whether the light is turned on
+    bool enabled;
+
+    //! Configuration of the light
+    Gfx::Light light;
+
+    //! Progression of intensity [0, 1]
+    Gfx::LightProgression intensity;
+    //! Progression of red diffuse color
+    Gfx::LightProgression colorRed;
+    //! Progression of green diffuse color
+    Gfx::LightProgression colorGreen;
+    //! Progression of blue diffuse color
+    Gfx::LightProgression colorBlue;
+
+    //! Type of objects included in lighting with this light; if Gfx::ENG_OBJTYPE_NULL is used, it is ignored
+    Gfx::EngineObjectType includeType;
+    //! Type of objects excluded from lighting with this light; if Gfx::ENG_OBJTYPE_NULL is used, it is ignored
+    Gfx::EngineObjectType excludeType;
+
+    DynamicLight();
+};
+
+/**
+  \class CLightManager
+  \brief Manager for dynamic lights in 3D scene
+
+  (Old CLight class)
+
+  The class is responsible for managing dynamic lights (struct Gfx::DynamicLight) used in 3D scene.
+  The dynamic lights are created, updated and deleted through the class' interface.
+
+  Number of available lights depends on graphics device used. Class allocates vector
+  for the total number of lights, but only some are used.
+  */
+class CLightManager
+{
+public:
+    //! Constructor
+    CLightManager(CInstanceManager *iMan, Gfx::CEngine* engine);
+    //! Destructor
+    virtual ~CLightManager();
+
+    //! Sets the device to be used
+    void            SetDevice(Gfx::CDevice* device);
+
+    //! Clears and disables all lights
+    void            FlushLights();
+    //! Creates a new dynamic light and returns its index (lightRank)
+    int             CreateLight();
+    //! Deletes and disables the given dynamic light
+    bool            DeleteLight(int lightRank);
+    //! Sets the light parameters for dynamic light
+    bool            SetLight(int lightRank, const Gfx::Light &light);
+    //! Returns the light parameters for given dynamic light
+    bool            GetLight(int lightRank, Gfx::Light &light);
+    //! Enables/disables the given dynamic light
+    bool            SetLightEnabled(int lightRank, bool enable);
+
+    //! Sets what objects are included in given dynamic light
+    bool            SetLightIncludeType(int lightRank, Gfx::EngineObjectType type);
+    //! Sets what objects are excluded from given dynamic light
+    bool            SetLightExcludeType(int lightRank, Gfx::EngineObjectType type);
+
+    //! Sets the position of dynamic light
+    bool            SetLightPos(int lightRank, const Math::Vector &pos);
+    //! Returns the position of dynamic light
+    Math::Vector    GetLightPos(int lightRank);
+
+    //! Sets the direction of dynamic light
+    bool            SetLightDir(int lightRank, const Math::Vector &dir);
+    //! Returns the direction of dynamic light
+    Math::Vector    GetLightDir(int lightRank);
+
+    //! Sets the destination intensity for dynamic light's intensity progression
+    bool            SetLightIntensity(int lightRank, float value);
+    //! Returns the current light intensity
+    float           GetLightIntensity(int lightRank);
+    //! Sets the rate of change for dynamic light intensity
+    bool            SetLightIntensitySpeed(int lightRank, float speed);
+
+    //! Adjusts the color of all dynamic lights
+    void            AdaptLightColor(const Gfx::Color &color, float factor);
+
+    //! Sets the destination color for dynamic light's color progression
+    bool            SetLightColor(int lightRank, const Gfx::Color &color);
+    //! Returns current light color
+    Gfx::Color      GetLightColor(int lightRank);
+    //! Sets the rate of change for dynamic light colors (RGB)
+    bool            SetLightColorSpeed(int lightRank, float speed);
+
+    //! Updates progression of dynamic lights
+    void            UpdateProgression(float rTime);
+    //! Updates (recalculates) all dynamic lights
+    void            UpdateLights();
+    //! Enables or disables dynamic lights affecting the given object type
+    void            UpdateLightsEnableState(Gfx::EngineObjectType type);
+
+protected:
+    CInstanceManager* m_iMan;
+    CEngine*          m_engine;
+    CDevice*          m_device;
+
+    //! Current time
+    float             m_time;
+    //! List of dynamic lights
+    std::vector<Gfx::DynamicLight> m_dynLights;
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/common/lightning.cpp b/src/graphics/engine/lightning.cpp
index 076fcb4..4db5511 100644
--- a/src/graphics/common/lightning.cpp
+++ b/src/graphics/engine/lightning.cpp
@@ -17,7 +17,7 @@
 
 // lightning.cpp (aka blitz.cpp)
 
-#include "graphics/common/lightning.h"
+#include "graphics/engine/lightning.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/lightning.h b/src/graphics/engine/lightning.h
index 957344c..957344c 100644
--- a/src/graphics/common/lightning.h
+++ b/src/graphics/engine/lightning.h
diff --git a/src/graphics/engine/modelfile.cpp b/src/graphics/engine/modelfile.cpp
new file mode 100644
index 0000000..844958f
--- /dev/null
+++ b/src/graphics/engine/modelfile.cpp
@@ -0,0 +1,841 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// modelfile.cpp (aka modfile.cpp)
+
+#include "graphics/engine/modelfile.h"
+
+#include "common/iman.h"
+#include "common/ioutils.h"
+#include "common/logger.h"
+#include "common/stringutils.h"
+#include "math/geometry.h"
+
+#include <string.h>
+
+#include <fstream>
+
+
+//! How big the triangle vector is by default
+const int TRIANGLE_PREALLOCATE_COUNT = 2000;
+
+/**
+  \struct ModelHeader
+  \brief  Header info for model file
+ */
+struct ModelHeader
+{
+    //! Revision number
+    int     revision;
+    //! Version number
+    int     version;
+    //! Total number of vertices
+    int     totalVertices;
+    //! Reserved area
+    int     reserved[10];
+
+    ModelHeader()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+};
+
+
+struct OldModelTriangle1
+{
+    char            used;
+    char            selected;
+    Gfx::Vertex     p1;
+    Gfx::Vertex     p2;
+    Gfx::Vertex     p3;
+    Gfx::Material   material;
+    char            texName[20];
+    float           min;
+    float           max;
+
+    OldModelTriangle1()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+};
+
+struct OldModelTriangle2
+{
+    char            used;
+    char            selected;
+    Gfx::Vertex     p1;
+    Gfx::Vertex     p2;
+    Gfx::Vertex     p3;
+    Gfx::Material   material;
+    char            texName[20];
+    float           min;
+    float           max;
+    long            state;
+    short           reserved1;
+    short           reserved2;
+    short           reserved3;
+    short           reserved4;
+    OldModelTriangle2()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+};
+
+
+struct NewModelTriangle
+{
+    char            used;
+    char            selected;
+    Gfx::VertexTex2 p1;
+    Gfx::VertexTex2 p2;
+    Gfx::VertexTex2 p3;
+    Gfx::Material   material;
+    char            texName[20];
+    float           min;
+    float           max;
+    long            state;
+    short           texNum2;
+    short           reserved2;
+    short           reserved3;
+    short           reserved4;
+
+    NewModelTriangle()
+    {
+        memset(this, 0, sizeof(*this));
+    }
+};
+
+
+Gfx::Vertex ReadBinaryVertex(std::istream &stream)
+{
+    Gfx::Vertex result;
+
+    result.coord.x     = IOUtils::ReadBinaryFloat(stream);
+    result.coord.y     = IOUtils::ReadBinaryFloat(stream);
+    result.coord.z     = IOUtils::ReadBinaryFloat(stream);
+    result.normal.x    = IOUtils::ReadBinaryFloat(stream);
+    result.normal.y    = IOUtils::ReadBinaryFloat(stream);
+    result.normal.z    = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord.x  = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord.y  = IOUtils::ReadBinaryFloat(stream);
+
+    return result;
+}
+
+void WriteBinaryVertex(Gfx::Vertex vertex, std::ostream &stream)
+{
+    IOUtils::WriteBinaryFloat(vertex.coord.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.coord.y, stream);
+    IOUtils::WriteBinaryFloat(vertex.coord.z, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.y, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.z, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord.y, stream);
+}
+
+Gfx::VertexTex2 ReadBinaryVertexTex2(std::istream &stream)
+{
+    Gfx::VertexTex2 result;
+
+    result.coord.x     = IOUtils::ReadBinaryFloat(stream);
+    result.coord.y     = IOUtils::ReadBinaryFloat(stream);
+    result.coord.z     = IOUtils::ReadBinaryFloat(stream);
+    result.normal.x    = IOUtils::ReadBinaryFloat(stream);
+    result.normal.y    = IOUtils::ReadBinaryFloat(stream);
+    result.normal.z    = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord.x  = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord.y  = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord2.x = IOUtils::ReadBinaryFloat(stream);
+    result.texCoord2.y = IOUtils::ReadBinaryFloat(stream);
+
+    return result;
+}
+
+void WriteBinaryVertexTex2(Gfx::VertexTex2 vertex, std::ostream &stream)
+{
+    IOUtils::WriteBinaryFloat(vertex.coord.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.coord.y, stream);
+    IOUtils::WriteBinaryFloat(vertex.coord.z, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.y, stream);
+    IOUtils::WriteBinaryFloat(vertex.normal.z, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord.y, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord2.x, stream);
+    IOUtils::WriteBinaryFloat(vertex.texCoord2.y, stream);
+}
+
+Gfx::Material ReadBinaryMaterial(std::istream &stream)
+{
+    Gfx::Material result;
+
+    result.diffuse.r =  IOUtils::ReadBinaryFloat(stream);
+    result.diffuse.g =  IOUtils::ReadBinaryFloat(stream);
+    result.diffuse.b =  IOUtils::ReadBinaryFloat(stream);
+    result.diffuse.a =  IOUtils::ReadBinaryFloat(stream);
+
+    result.ambient.r =  IOUtils::ReadBinaryFloat(stream);
+    result.ambient.g =  IOUtils::ReadBinaryFloat(stream);
+    result.ambient.b =  IOUtils::ReadBinaryFloat(stream);
+    result.ambient.a =  IOUtils::ReadBinaryFloat(stream);
+
+    result.specular.r = IOUtils::ReadBinaryFloat(stream);
+    result.specular.g = IOUtils::ReadBinaryFloat(stream);
+    result.specular.b = IOUtils::ReadBinaryFloat(stream);
+    result.specular.a = IOUtils::ReadBinaryFloat(stream);
+
+    /* emissive.r = */  IOUtils::ReadBinaryFloat(stream);
+    /* emissive.g = */  IOUtils::ReadBinaryFloat(stream);
+    /* emissive.b = */  IOUtils::ReadBinaryFloat(stream);
+    /* emissive.a = */  IOUtils::ReadBinaryFloat(stream);
+
+    /* power = */       IOUtils::ReadBinaryFloat(stream);
+
+    return result;
+}
+
+void WriteBinaryMaterial(Gfx::Material material, std::ostream &stream)
+{
+    IOUtils::WriteBinaryFloat(material.diffuse.r, stream);
+    IOUtils::WriteBinaryFloat(material.diffuse.g, stream);
+    IOUtils::WriteBinaryFloat(material.diffuse.b, stream);
+    IOUtils::WriteBinaryFloat(material.diffuse.a, stream);
+
+    IOUtils::WriteBinaryFloat(material.ambient.r, stream);
+    IOUtils::WriteBinaryFloat(material.ambient.g, stream);
+    IOUtils::WriteBinaryFloat(material.ambient.b, stream);
+    IOUtils::WriteBinaryFloat(material.ambient.a, stream);
+
+    IOUtils::WriteBinaryFloat(material.specular.r, stream);
+    IOUtils::WriteBinaryFloat(material.specular.g, stream);
+    IOUtils::WriteBinaryFloat(material.specular.b, stream);
+    IOUtils::WriteBinaryFloat(material.specular.a, stream);
+
+    /* emissive.r */  IOUtils::WriteBinaryFloat(0.0f, stream);
+    /* emissive.g */  IOUtils::WriteBinaryFloat(0.0f, stream);
+    /* emissive.b */  IOUtils::WriteBinaryFloat(0.0f, stream);
+    /* emissive.a */  IOUtils::WriteBinaryFloat(0.0f, stream);
+
+    /* power */       IOUtils::WriteBinaryFloat(0.0f, stream);
+}
+
+Gfx::ModelTriangle::ModelTriangle()
+{
+    min = 0.0f;
+    max = 0.0f;
+    state = 0L;
+}
+
+
+Gfx::CModelFile::CModelFile(CInstanceManager* iMan)
+{
+    m_iMan = iMan;
+
+    m_engine = static_cast<CEngine*>(m_iMan->SearchInstance(CLASS_ENGINE));
+
+    m_triangles.reserve(TRIANGLE_PREALLOCATE_COUNT);
+}
+
+Gfx::CModelFile::~CModelFile()
+{
+}
+
+std::string Gfx::CModelFile::GetError()
+{
+    return m_error;
+}
+
+
+bool Gfx::CModelFile::ReadModel(const std::string &filename, bool edit, bool meta)
+{
+    m_triangles.clear();
+    m_error = "";
+
+    std::ifstream stream;
+    stream.open(filename.c_str(), std::ios_base::in | std::ios_base::binary);
+    if (! stream.good())
+    {
+        m_error = std::string("Could not open file '") + filename + std::string("'");
+        return false;
+    }
+
+    return ReadModel(stream, edit, meta);
+}
+
+bool Gfx::CModelFile::ReadModel(std::istream &stream, bool edit, bool meta)
+{
+    m_triangles.clear();
+    m_error = "";
+
+    // FIXME: for now, reading models only from files, not metafile
+
+    ModelHeader header;
+
+    header.revision      = IOUtils::ReadBinary<4, int>(stream);
+    header.version       = IOUtils::ReadBinary<4, int>(stream);
+    header.totalVertices = IOUtils::ReadBinary<4, int>(stream);
+    for (int i = 0; i < 10; ++i)
+        header.reserved[i] = IOUtils::ReadBinary<4, int>(stream);
+
+
+    if (! stream.good())
+    {
+        m_error = "Error reading model file header";
+        return false;
+    }
+
+    // Old model version #1
+    if ( (header.revision == 1) && (header.version == 0) )
+    {
+        for (int i = 0; i < header.totalVertices; ++i)
+        {
+            OldModelTriangle1 t;
+            t.used     = IOUtils::ReadBinary<1, char>(stream);
+            t.selected = IOUtils::ReadBinary<1, char>(stream);
+
+            t.p1 = ReadBinaryVertex(stream);
+            t.p2 = ReadBinaryVertex(stream);
+            t.p3 = ReadBinaryVertex(stream);
+
+            t.material = ReadBinaryMaterial(stream);
+            stream.read(t.texName, 20);
+            t.min = IOUtils::ReadBinaryFloat(stream);
+            t.max = IOUtils::ReadBinaryFloat(stream);
+
+            if (! stream.good())
+            {
+                m_error = "Error reading model data";
+                return false;
+            }
+
+            Gfx::ModelTriangle triangle;
+            triangle.p1.FromVertex(t.p1);
+            triangle.p2.FromVertex(t.p2);
+            triangle.p3.FromVertex(t.p3);
+
+            triangle.material = t.material;
+            triangle.tex1Name = std::string(t.texName);
+            triangle.min = t.min;
+            triangle.max = t.max;
+
+            m_triangles.push_back(triangle);
+        }
+    }
+    else if ( header.revision == 1 && header.version == 1 )
+    {
+        for (int i = 0; i < header.totalVertices; ++i)
+        {
+            OldModelTriangle2 t;
+            t.used     = IOUtils::ReadBinary<1, char>(stream);
+            t.selected = IOUtils::ReadBinary<1, char>(stream);
+
+            t.p1 = ReadBinaryVertex(stream);
+            t.p2 = ReadBinaryVertex(stream);
+            t.p3 = ReadBinaryVertex(stream);
+
+            t.material = ReadBinaryMaterial(stream);
+            stream.read(t.texName, 20);
+            t.min = IOUtils::ReadBinaryFloat(stream);
+            t.max = IOUtils::ReadBinaryFloat(stream);
+            t.state = IOUtils::ReadBinary<4, long>(stream);
+
+            t.reserved1 = IOUtils::ReadBinary<2, short>(stream);
+            t.reserved2 = IOUtils::ReadBinary<2, short>(stream);
+            t.reserved3 = IOUtils::ReadBinary<2, short>(stream);
+            t.reserved4 = IOUtils::ReadBinary<2, short>(stream);
+
+            if (! stream.good())
+            {
+                m_error = "Error reading model data";
+                return false;
+            }
+
+            Gfx::ModelTriangle triangle;
+            triangle.p1.FromVertex(t.p1);
+            triangle.p2.FromVertex(t.p2);
+            triangle.p3.FromVertex(t.p3);
+
+            triangle.material = t.material;
+            triangle.tex1Name = std::string(t.texName);
+            triangle.min = t.min;
+            triangle.max = t.max;
+            triangle.state = t.state;
+
+            m_triangles.push_back(triangle);
+        }
+    }
+    else
+    {
+        for (int i = 0; i < header.totalVertices; ++i)
+        {
+            NewModelTriangle t;
+            t.used     = IOUtils::ReadBinary<1, char>(stream);
+            t.selected = IOUtils::ReadBinary<1, char>(stream);
+
+            /* padding */ IOUtils::ReadBinary<2, unsigned int>(stream);
+
+            t.p1 = ReadBinaryVertexTex2(stream);
+            t.p2 = ReadBinaryVertexTex2(stream);
+            t.p3 = ReadBinaryVertexTex2(stream);
+
+            t.material = ReadBinaryMaterial(stream);
+            stream.read(t.texName, 20);
+            t.min = IOUtils::ReadBinaryFloat(stream);
+            t.max = IOUtils::ReadBinaryFloat(stream);
+            t.state = IOUtils::ReadBinary<4, long>(stream);
+            t.texNum2 = IOUtils::ReadBinary<2, short>(stream);
+
+            t.reserved2 = IOUtils::ReadBinary<2, short>(stream);
+            t.reserved3 = IOUtils::ReadBinary<2, short>(stream);
+            t.reserved4 = IOUtils::ReadBinary<2, short>(stream);
+
+            if (! stream.good())
+            {
+                m_error = "Error reading model data";
+                return false;
+            }
+
+            Gfx::ModelTriangle triangle;
+            triangle.p1 = t.p1;
+            triangle.p2 = t.p2;
+            triangle.p3 = t.p3;
+
+            triangle.material = t.material;
+            triangle.tex1Name = std::string(t.texName);
+            char tex2Name[20] = { 0 };
+            triangle.min = t.min;
+            triangle.max = t.max;
+            triangle.state = t.state;
+
+            if (t.texNum2 != 0)
+                sprintf(tex2Name, "dirty%.2d.tga", t.texNum2); // hardcoded as in the original code
+
+            triangle.tex2Name = std::string(tex2Name);
+
+            m_triangles.push_back(triangle);
+       }
+    }
+
+    for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
+    {
+        m_triangles[i].tex1Name = StrUtils::Replace(m_triangles[i].tex1Name, "bmp", "tga");
+
+        GetLogger()->Info("ModelTriangle %d\n", i+1);
+        std::string s1 = m_triangles[i].p1.ToString();
+        GetLogger()->Info(" p1: %s\n", s1.c_str());
+        std::string s2 = m_triangles[i].p2.ToString();
+        GetLogger()->Info(" p2: %s\n", s2.c_str());
+        std::string s3 = m_triangles[i].p3.ToString();
+        GetLogger()->Info(" p3: %s\n", s3.c_str());
+
+        std::string d = m_triangles[i].material.diffuse.ToString();
+        std::string a = m_triangles[i].material.ambient.ToString();
+        std::string s = m_triangles[i].material.specular.ToString();
+        GetLogger()->Info(" mat: d: %s  a: %s  s: %s\n", d.c_str(), a.c_str(), s.c_str());
+
+        GetLogger()->Info(" tex1: %s  tex2: %s\n", m_triangles[i].tex1Name.c_str(), m_triangles[i].tex2Name.c_str());
+        GetLogger()->Info(" min: %.2f  max: %.2f\n", m_triangles[i].min, m_triangles[i].max);
+        GetLogger()->Info(" state: %ld\n", m_triangles[i].state);
+    }
+
+    /*
+    if (! edit)
+    {
+        float limit[2];
+        limit[0] = m_engine->RetLimitLOD(0);  // frontier AB as config
+        limit[1] = m_engine->RetLimitLOD(1);  // frontier BC as config
+
+        // Standard frontiers -> config.
+        for (int i = 0; i < m_triangles.size(); ++i)
+        {
+            if ( m_triangles[i].min == 0.0f &&
+                 m_triangles[i].max == 100.0f )  // resolution A ?
+            {
+                m_triangles[i].max = limit[0];
+            }
+            else if ( m_triangles[i].min == 100.0f &&
+                      m_triangles[i].max == 200.0f )  // resolution B ?
+            {
+                m_triangles[i].min = limit[0];
+                m_triangles[i].max = limit[1];
+            }
+            else if ( m_triangles[i].min == 200.0f &&
+                      m_triangles[i].max == 1000000.0f )  // resolution C ?
+            {
+                m_triangles[i].min = limit[1];
+            }
+        }
+    }*/
+
+    return true;
+}
+
+bool Gfx::CModelFile::WriteModel(const std::string &filename)
+{
+    m_error = "";
+
+    std::ofstream stream;
+    stream.open(filename.c_str(), std::ios_base::out | std::ios_base::binary);
+    if (! stream.good())
+    {
+        m_error = std::string("Could not open file '") + filename + std::string("'");
+        return false;
+    }
+
+    return WriteModel(stream);
+}
+
+bool Gfx::CModelFile::WriteModel(std::ostream &stream)
+{
+    m_error = "";
+
+    if (m_triangles.size() == 0)
+    {
+        m_error = "Empty model";
+        return false;
+    }
+
+    ModelHeader header;
+    header.revision   = 1;
+    header.version  = 2;
+    header.totalVertices = m_triangles.size();
+
+    IOUtils::WriteBinary<4, int>(header.revision,      stream);
+    IOUtils::WriteBinary<4, int>(header.version,       stream);
+    IOUtils::WriteBinary<4, int>(header.totalVertices, stream);
+    for (int i = 0; i < 10; ++i)
+        IOUtils::WriteBinary<4, int>(header.reserved[i], stream);
+
+    for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
+    {
+        NewModelTriangle t;
+
+        t.used = true;
+
+        t.p1 = m_triangles[i].p1;
+        t.p2 = m_triangles[i].p2;
+        t.p3 = m_triangles[i].p3;
+
+        t.material = m_triangles[i].material;
+        strncpy(t.texName, m_triangles[i].tex1Name.c_str(), 20);
+        t.min = m_triangles[i].min;
+        t.max = m_triangles[i].max;
+        t.state = m_triangles[i].state;
+        int no = 0;
+        sscanf(m_triangles[i].tex2Name.c_str(), "dirty%d.tga", &no); // hardcoded as in the original code
+        t.texNum2 = no;
+
+
+        IOUtils::WriteBinary<1, char>(t.used,     stream);
+        IOUtils::WriteBinary<1, char>(t.selected, stream);
+
+        WriteBinaryVertexTex2(t.p1, stream);
+        WriteBinaryVertexTex2(t.p2, stream);
+        WriteBinaryVertexTex2(t.p3, stream);
+
+        WriteBinaryMaterial(t.material, stream);
+        stream.write(t.texName, 20);
+        IOUtils::WriteBinaryFloat(t.min, stream);
+        IOUtils::WriteBinaryFloat(t.max, stream);
+        IOUtils::WriteBinary<4, long>(t.state, stream);
+        IOUtils::WriteBinary<2, short>(t.texNum2, stream);
+
+        IOUtils::WriteBinary<2, short>(t.reserved2, stream);
+        IOUtils::WriteBinary<2, short>(t.reserved3, stream);
+        IOUtils::WriteBinary<2, short>(t.reserved4, stream);
+    }
+
+    return true;
+}
+
+bool Gfx::CModelFile::ReadDXF(const std::string &filename, float min, float max)
+{
+    m_triangles.clear();
+    m_error = "";
+
+    std::ifstream stream;
+    stream.open(filename.c_str(), std::ios_base::in);
+    if (! stream.good())
+    {
+        m_error = std::string("Couldn't open file '") + filename + std::string("'");
+        return false;
+    }
+
+    return ReadDXF(stream, min, max);
+}
+
+bool Gfx::CModelFile::ReadDXF(std::istream &stream, float min, float max)
+{
+    m_triangles.clear();
+    m_error = "";
+
+    if (! stream.good())
+    {
+        m_error = "Invalid stream";
+        return false;
+    }
+
+    // Input state
+    bool waitNumVertex = false;
+    bool waitNumFace   = false;
+    bool waitVertexX   = false;
+    bool waitVertexY   = false;
+    bool waitVertexZ   = false;
+    bool waitFaceX     = false;
+    bool waitFaceY     = false;
+    bool waitFaceZ     = false;
+
+    // Vertex array
+    std::vector<Math::Vector> vertices;
+    vertices.reserve(TRIANGLE_PREALLOCATE_COUNT);
+
+    // Number of vertices & faces of the primitive to be read
+    int          vertexNum = 0, faceNum = 0;
+    // Vertex coords
+    Math::Vector coords;
+    // Indexes of face (triangle) points
+    int          p1 = 0, p2 = 0, p3 = 0;
+
+    // Input line
+    std::string line;
+    while (! stream.eof() )
+    {
+        // Read line with command
+        std::getline(stream, line);
+        int command = StrUtils::FromString<int>(line);
+
+        // Read line with param
+        std::getline(stream, line);
+
+        bool ok = true;
+
+
+        if (command == 66)
+        {
+            waitNumVertex = true;
+        }
+
+        if ( command == 71 && waitNumVertex )
+        {
+            waitNumVertex = false;
+            vertexNum = StrUtils::FromString<int>(line, &ok);
+            waitNumFace = true;
+        }
+
+        if ( command == 72 && waitNumFace )
+        {
+            waitNumFace = false;
+            faceNum = StrUtils::FromString<int>(line, &ok);
+            waitVertexX = true;
+        }
+
+        if ( command == 10 && waitVertexX )
+        {
+            waitVertexX = false;
+            coords.x  = StrUtils::FromString<float>(line, &ok);
+            waitVertexY = true;
+        }
+
+        if ( command == 20 && waitVertexY )
+        {
+            waitVertexY = false;
+            coords.y  = StrUtils::FromString<float>(line, &ok);
+            waitVertexZ = true;
+        }
+
+        if ( command == 30 && waitVertexZ )
+        {
+            waitVertexZ = false;
+            coords.z = StrUtils::FromString<float>(line, &ok);
+
+            vertexNum --;
+            if ( vertexNum >= 0 )
+            {
+                Math::Vector p(coords.x, coords.z, coords.y);  // permutation of Y and Z!
+                vertices.push_back(p);
+                waitVertexX = true;
+            }
+            else
+            {
+                waitFaceX = true;
+            }
+        }
+
+        if ( command == 71 && waitFaceX )
+        {
+            waitFaceX = false;
+            p1 = StrUtils::FromString<int>(line, &ok);
+            if ( p1 < 0 )  p1 = -p1;
+            waitFaceY = true;
+        }
+
+        if ( command == 72 && waitFaceY )
+        {
+            waitFaceY = false;
+            p2 = StrUtils::FromString<int>(line, &ok);
+            if ( p2 < 0 )  p2 = -p2;
+            waitFaceZ = true;
+        }
+
+        if ( command == 73 && waitFaceZ )
+        {
+            waitFaceZ = false;
+            p3 = StrUtils::FromString<int>(line, &ok);
+            if ( p3 < 0 )  p3 = -p3;
+
+            faceNum --;
+            if ( faceNum >= 0 )
+            {
+                assert( (p1-1 >= 0) && (p1-1 < static_cast<int>(vertices.size())) );
+                assert( (p2-1 >= 0) && (p2-1 < static_cast<int>(vertices.size())) );
+                assert( (p3-1 >= 0) && (p3-1 < static_cast<int>(vertices.size())) );
+
+                CreateTriangle(vertices[p3-1], vertices[p2-1], vertices[p1-1], min, max);
+                waitFaceX = true;
+            }
+        }
+
+        if (! ok)
+        {
+            m_error = "Error reading data";
+            return false;
+        }
+
+    }
+
+    return true;
+}
+
+bool Gfx::CModelFile::CreateEngineObject(int objRank, int addState)
+{
+    /*char    texName1[20];
+    char    texName2[20];
+    int     texNum, i, state;
+
+    for (int i = 0; i < m_trianglesUsed; i++)
+    {
+        if (! m_triangles[i].used)  continue;
+
+        state = m_triangles[i].state;
+        strcpy(texName1, m_triangles[i].texName);
+        texName2[0] = 0;
+
+        if ( strcmp(texName1, "plant.tga") == 0 ) // ???
+        {
+            state |= D3DSTATEALPHA;
+        }
+
+        if ( m_triangles[i].texNum2 != 0 )
+        {
+            if ( m_triangles[i].texNum2 == 1 )
+            {
+                texNum = m_engine->RetSecondTexture();
+            }
+            else
+            {
+                texNum = m_triangles[i].texNum2;
+            }
+
+            if ( texNum >= 1 && texNum <= 10 )
+            {
+                state |= D3DSTATEDUALb;
+            }
+            if ( texNum >= 11 && texNum <= 20 )
+            {
+                state |= D3DSTATEDUALw;
+            }
+            sprintf(texName2, "dirty%.2d.tga", texNum); // ???
+        }
+
+        m_engine->AddTriangle(objRank, &m_triangles[i].p1, 3,
+                              m_triangles[i].material,
+                              state + addState,
+                              texName1, texName2,
+                              m_triangles[i].min,
+                              m_triangles[i].max, false);
+    }*/
+    return true;
+}
+
+void Gfx::CModelFile::Mirror()
+{
+    for (int i = 0; i < static_cast<int>( m_triangles.size() ); i++)
+    {
+        Gfx::VertexTex2  t = m_triangles[i].p1;
+        m_triangles[i].p1 = m_triangles[i].p2;
+        m_triangles[i].p2 = t;
+
+        m_triangles[i].p1.coord.z = -m_triangles[i].p1.coord.z;
+        m_triangles[i].p2.coord.z = -m_triangles[i].p2.coord.z;
+        m_triangles[i].p3.coord.z = -m_triangles[i].p3.coord.z;
+
+        m_triangles[i].p1.normal.z = -m_triangles[i].p1.normal.z;
+        m_triangles[i].p2.normal.z = -m_triangles[i].p2.normal.z;
+        m_triangles[i].p3.normal.z = -m_triangles[i].p3.normal.z;
+    }
+}
+
+std::vector<Gfx::ModelTriangle>& Gfx::CModelFile::GetTriangles()
+{
+    return m_triangles;
+}
+
+int Gfx::CModelFile::GetTriangleCount()
+{
+    return m_triangles.size();
+}
+
+float Gfx::CModelFile::GetHeight(Math::Vector pos)
+{
+    float limit = 5.0f;
+
+    for (int i = 0; i < static_cast<int>( m_triangles.size() ); i++)
+    {
+        if ( fabs(pos.x - m_triangles[i].p1.coord.x) < limit &&
+             fabs(pos.z - m_triangles[i].p1.coord.z) < limit )
+            return m_triangles[i].p1.coord.y;
+
+        if ( fabs(pos.x - m_triangles[i].p2.coord.x) < limit &&
+             fabs(pos.z - m_triangles[i].p2.coord.z) < limit )
+            return m_triangles[i].p2.coord.y;
+
+        if ( fabs(pos.x - m_triangles[i].p3.coord.x) < limit &&
+             fabs(pos.z - m_triangles[i].p3.coord.z) < limit )
+            return m_triangles[i].p3.coord.y;
+    }
+
+    return 0.0f;
+}
+
+void Gfx::CModelFile::CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max)
+{
+    Gfx::ModelTriangle triangle;
+
+    Math::Vector n = Math::NormalToPlane(p3, p2, p1);
+    triangle.p1 = Gfx::VertexTex2(p1, n);
+    triangle.p2 = Gfx::VertexTex2(p2, n);
+    triangle.p3 = Gfx::VertexTex2(p3, n);
+
+    triangle.material.diffuse = Gfx::Color(1.0f, 1.0f, 1.0f, 0.0f);
+    triangle.material.ambient = Gfx::Color(0.5f, 0.5f, 0.5f, 0.0f);
+
+    triangle.min = min;
+    triangle.max = max;
+
+    m_triangles.push_back(triangle);
+}
diff --git a/src/graphics/engine/modelfile.h b/src/graphics/engine/modelfile.h
new file mode 100644
index 0000000..6a30487
--- /dev/null
+++ b/src/graphics/engine/modelfile.h
@@ -0,0 +1,120 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// modelfile.h (aka modfile.h)
+
+#include "graphics/engine/engine.h"
+#include "graphics/core/vertex.h"
+#include "graphics/core/material.h"
+#include "math/vector.h"
+
+#include <string>
+#include <vector>
+#include <iostream>
+
+
+class CInstanceManager;
+
+
+namespace Gfx {
+
+/**
+  \struct ModelTriangle
+  \brief Triangle of a 3D model
+  */
+struct ModelTriangle
+{
+    //! 1st vertex
+    Gfx::VertexTex2  p1;
+    //! 2nd vertex
+    Gfx::VertexTex2  p2;
+    //! 3rd vertex
+    Gfx::VertexTex2  p3;
+    //! Material
+    Gfx::Material    material;
+    //! Name of 1st texture
+    std::string      tex1Name;
+    //! Name of 2nd texture
+    std::string      tex2Name;
+    //! Min LOD threshold
+    float            min;
+    //! Max LOD threshold
+    float            max;
+    //! Rendering state to be set
+    long             state;
+
+    ModelTriangle();
+};
+
+
+/**
+  \class CModelFile
+  \brief Model file reader/writer
+
+  Allows reading and writing model objects. Models are collections of ModelTriangle structs. */
+class CModelFile
+{
+public:
+    CModelFile(CInstanceManager* iMan);
+    ~CModelFile();
+
+    //! Returns the last error encountered
+    std::string GetError();
+
+    //! Reads a binary Colobot model from file
+    bool                 ReadModel(const std::string &filename, bool edit = false, bool meta = true);
+    //! Reads a binary Colobot model from stream
+    bool                 ReadModel(std::istream &stream, bool edit = false, bool meta = true);
+    //! Writes the model to Colobot binary model file
+    bool                 WriteModel(const std::string &filename);
+    //! Writes the model to Colobot binary model file
+    bool                 WriteModel(std::ostream &stream);
+
+    //! Reads a DXF model from file
+    bool                 ReadDXF(const std::string &filename, float min, float max);
+    //! Reads a DXF model from stream
+    bool                 ReadDXF(std::istream &stream, float min, float max);
+
+    //! Returns the number of triangles in model
+    int                  GetTriangleCount();
+    //! Returns the triangle vector
+    std::vector<Gfx::ModelTriangle>& GetTriangles();
+    //! Returns the height of model -- closest point to X and Z coords of \a pos
+    float                GetHeight(Math::Vector pos);
+
+    //! Mirrors the model along the Z axis
+    void                 Mirror();
+
+    //! Creates an object in the graphics engine from the model
+    bool                 CreateEngineObject(int objRank, int addState = 0);
+
+protected:
+    //! Adds a triangle to the list
+    void                 CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max);
+
+protected:
+    CInstanceManager*    m_iMan;
+    Gfx::CEngine*        m_engine;
+
+    //! Last error
+    std::string m_error;
+
+    //! Model triangles
+    std::vector<Gfx::ModelTriangle> m_triangles;
+};
+
+}; // namespace Gfx
diff --git a/src/graphics/common/particle.cpp b/src/graphics/engine/particle.cpp
index 322c2d0..84e2f9d 100644
--- a/src/graphics/common/particle.cpp
+++ b/src/graphics/engine/particle.cpp
@@ -17,7 +17,7 @@
 
 // particle.cpp (aka particule.cpp)
 
-#include "graphics/common/particle.h"
+#include "graphics/engine/particle.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/particle.h b/src/graphics/engine/particle.h
index e430e2a..bd9741f 100644
--- a/src/graphics/common/particle.h
+++ b/src/graphics/engine/particle.h
@@ -25,9 +25,8 @@
 
 class CInstanceManager;
 class CRobotMain;
-class Gfx::CTerrain;
-class Gfx::CWater;
 class CObject;
+class CSound;
 
 
 
@@ -52,7 +51,7 @@ const short SH_MAX = 3;
 // type == 4    ->  text     (white background)
 
 
-enum ParticuleType
+enum ParticleType
 {
     PARTIEXPLOT     = 1,        // technology explosion
     PARTIEXPLOO     = 2,        // organic explosion
@@ -195,20 +194,20 @@ enum ParticuleType
     PARTITRACE19        = 159,      // trace
 };
 
-enum ParticulePhase
+enum ParticlePhase
 {
     PARPHSTART      = 0,
     PARPHEND        = 1,
 };
 
-struct Particule
+struct Particle
 {
     char            bUsed;      // TRUE -> particle used
     char            bRay;       // TRUE -> ray with goal
     unsigned short      uniqueStamp;    // unique mark
     short           sheet;      // sheet (0..n)
-    ParticuleType       type;       // type PARTI*
-    ParticulePhase      phase;      // phase PARPH*
+    ParticleType       type;       // type PARTI*
+    ParticlePhase      phase;      // phase PARPH*
     float           mass;       // mass of the particle (in rebounding)
     float           weight;     // weight of the particle (for noise)
     float           duration;   // length of life
@@ -235,7 +234,7 @@ struct Particule
 struct Track
 {
     char            bUsed;      // TRUE -> drag used
-    char            bDrawParticule;
+    char            bDrawParticle;
     float           step;       // duration of not
     float           last;       // increase last not memorized
     float           intensity;  // intensity at starting (0..1)
@@ -248,7 +247,7 @@ struct Track
 
 struct WheelTrace
 {
-    ParticuleType       type;       // type PARTI*
+    ParticleType       type;       // type PARTI*
     Math::Vector        pos[4];     // rectangle positions
     float           startTime;  // beginning of life
 };
@@ -263,16 +262,16 @@ public:
 
     void        SetGLDevice(CDevice device);
 
-    void        FlushParticule();
-    void        FlushParticule(int sheet);
-    int         CreateParticule(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticuleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
-    int         CreateFrag(Math::Vector pos, Math::Vector speed, Triangle *triangle, ParticuleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
-    int         CreatePart(Math::Vector pos, Math::Vector speed, ParticuleType type, float duration=1.0f, float mass=0.0f, float weight=0.0f, float windSensitivity=1.0f, int sheet=0);
-    int         CreateRay(Math::Vector pos, Math::Vector goal, ParticuleType type, Math::Point dim, float duration=1.0f, int sheet=0);
-    int         CreateTrack(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticuleType type, float duration=1.0f, float mass=0.0f, float length=10.0f, float width=1.0f);
-    void        CreateWheelTrace(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3, const Math::Vector &p4, ParticuleType type);
-    void        DeleteParticule(ParticuleType type);
-    void        DeleteParticule(int channel);
+    void        FlushParticle();
+    void        FlushParticle(int sheet);
+    int         CreateParticle(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
+    int         CreateFrag(Math::Vector pos, Math::Vector speed, Gfx::EngineTriangle *triangle, ParticleType type, float duration=1.0f, float mass=0.0f, float windSensitivity=1.0f, int sheet=0);
+    int         CreatePart(Math::Vector pos, Math::Vector speed, ParticleType type, float duration=1.0f, float mass=0.0f, float weight=0.0f, float windSensitivity=1.0f, int sheet=0);
+    int         CreateRay(Math::Vector pos, Math::Vector goal, ParticleType type, Math::Point dim, float duration=1.0f, int sheet=0);
+    int         CreateTrack(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticleType type, float duration=1.0f, float mass=0.0f, float length=10.0f, float width=1.0f);
+    void        CreateWheelTrace(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3, const Math::Vector &p4, ParticleType type);
+    void        DeleteParticle(ParticleType type);
+    void        DeleteParticle(int channel);
     void        SetObjectLink(int channel, CObject *object);
     void        SetObjectFather(int channel, CObject *object);
     void        SetPosition(int channel, Math::Vector pos);
@@ -281,57 +280,57 @@ public:
     void        SetAngle(int channel, float angle);
     void        SetIntensity(int channel, float intensity);
     void        SetParam(int channel, Math::Vector pos, Math::Point dim, float zoom, float angle, float intensity);
-    void        SetPhase(int channel, ParticulePhase phase, float duration);
+    void        SetPhase(int channel, ParticlePhase phase, float duration);
     bool        GetPosition(int channel, Math::Vector &pos);
 
     Gfx::Color RetFogColor(Math::Vector pos);
 
     void        SetFrameUpdate(int sheet, bool bUpdate);
-    void        FrameParticule(float rTime);
-    void        DrawParticule(int sheet);
+    void        FrameParticle(float rTime);
+    void        DrawParticle(int sheet);
 
     bool        WriteWheelTrace(char *filename, int width, int height, Math::Vector dl, Math::Vector ur);
 
 protected:
     void        DeleteRank(int rank);
     bool        CheckChannel(int &channel);
-    void        DrawParticuleTriangle(int i);
-    void        DrawParticuleNorm(int i);
-    void        DrawParticuleFlat(int i);
-    void        DrawParticuleFog(int i);
-    void        DrawParticuleRay(int i);
-    void        DrawParticuleSphere(int i);
-    void        DrawParticuleCylinder(int i);
-    void        DrawParticuleWheel(int i);
-    CObject*    SearchObjectGun(Math::Vector old, Math::Vector pos, ParticuleType type, CObject *father);
-    CObject*    SearchObjectRay(Math::Vector pos, Math::Vector goal, ParticuleType type, CObject *father);
-    void        Play(Snd::Sound sound, Math::Vector pos, float amplitude);
+    void        DrawParticleTriangle(int i);
+    void        DrawParticleNorm(int i);
+    void        DrawParticleFlat(int i);
+    void        DrawParticleFog(int i);
+    void        DrawParticleRay(int i);
+    void        DrawParticleSphere(int i);
+    void        DrawParticleCylinder(int i);
+    void        DrawParticleWheel(int i);
+    CObject*    SearchObjectGun(Math::Vector old, Math::Vector pos, ParticleType type, CObject *father);
+    CObject*    SearchObjectRay(Math::Vector pos, Math::Vector goal, ParticleType type, CObject *father);
+    void        Play(Sound sound, Math::Vector pos, float amplitude);
     bool        TrackMove(int i, Math::Vector pos, float progress);
-    void        TrackDraw(int i, ParticuleType type);
+    void        TrackDraw(int i, ParticleType type);
 
 protected:
-    CInstanceManager*   m_iMan;
-    CEngine*        m_engine;
-    CDevice*        m_pDevice;
-    CRobotMain*         m_main;
-    CTerrain*       m_terrain;
-    CWater*     m_water;
-    CSound*             m_sound;
+    CInstanceManager* m_iMan;
+    CEngine*     m_engine;
+    CDevice*     m_pDevice;
+    CRobotMain*  m_main;
+    CTerrain*    m_terrain;
+    CWater*      m_water;
+    CSound*      m_sound;
 
-    Particule   m_particule[MAXPARTICULE*MAXPARTITYPE];
-    Gfx::Triangle   m_triangle[MAXPARTICULE];  // triangle if PartiType == 0
-    Track       m_track[MAXTRACK];
-    int         m_wheelTraceTotal;
-    int         m_wheelTraceIndex;
-    WheelTrace  m_wheelTrace[MAXWHEELTRACE];
-    int         m_totalInterface[MAXPARTITYPE][SH_MAX];
-    bool        m_bFrameUpdate[SH_MAX];
-    int         m_fogTotal;
-    int         m_fog[MAXPARTIFOG];
-    int         m_uniqueStamp;
-    int         m_exploGunCounter;
-    float       m_lastTimeGunDel;
-    float       m_absTime;
+    Gfx::Particle m_particule[MAXPARTICULE*MAXPARTITYPE];
+    Gfx::EngineTriangle m_triangle[MAXPARTICULE];  // triangle if PartiType == 0
+    Track         m_track[MAXTRACK];
+    int           m_wheelTraceTotal;
+    int           m_wheelTraceIndex;
+    WheelTrace    m_wheelTrace[MAXWHEELTRACE];
+    int           m_totalInterface[MAXPARTITYPE][SH_MAX];
+    bool          m_bFrameUpdate[SH_MAX];
+    int           m_fogTotal;
+    int           m_fog[MAXPARTIFOG];
+    int           m_uniqueStamp;
+    int           m_exploGunCounter;
+    float         m_lastTimeGunDel;
+    float         m_absTime;
 };
 
 
diff --git a/src/graphics/common/planet.cpp b/src/graphics/engine/planet.cpp
index 4fa17a1..4f1f614 100644
--- a/src/graphics/common/planet.cpp
+++ b/src/graphics/engine/planet.cpp
@@ -17,7 +17,7 @@
 
 // planet.cpp
 
-#include "graphics/common/planet.h"
+#include "graphics/engine/planet.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/planet.h b/src/graphics/engine/planet.h
index 264d05c..264d05c 100644
--- a/src/graphics/common/planet.h
+++ b/src/graphics/engine/planet.h
diff --git a/src/graphics/common/pyro.cpp b/src/graphics/engine/pyro.cpp
index 6b5b1af..e699db2 100644
--- a/src/graphics/common/pyro.cpp
+++ b/src/graphics/engine/pyro.cpp
@@ -17,7 +17,7 @@
 
 // pyro.cpp
 
-#include "graphics/common/pyro.h"
+#include "graphics/engine/pyro.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/pyro.h b/src/graphics/engine/pyro.h
index fda74b3..d663ca5 100644
--- a/src/graphics/common/pyro.h
+++ b/src/graphics/engine/pyro.h
@@ -20,7 +20,7 @@
 #pragma once
 
 #include "common/misc.h"
-#include "graphics/common/engine.h"
+#include "graphics/engine/engine.h"
 //#include "object/object.h"
 // TEMPORARILY!
 enum ObjectType {};
diff --git a/src/graphics/common/terrain.cpp b/src/graphics/engine/terrain.cpp
index 9b61dfc..c489321 100644
--- a/src/graphics/common/terrain.cpp
+++ b/src/graphics/engine/terrain.cpp
@@ -17,7 +17,7 @@
 
 // terrain.cpp
 
-#include "graphics/common/terrain.h"
+#include "graphics/engine/terrain.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/terrain.h b/src/graphics/engine/terrain.h
index fd9a1a6..8d8b165 100644
--- a/src/graphics/common/terrain.h
+++ b/src/graphics/engine/terrain.h
@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include "graphics/common/engine.h"
+#include "graphics/engine/engine.h"
 
 
 class CInstanceManager;
diff --git a/src/graphics/engine/test/CMakeLists.txt b/src/graphics/engine/test/CMakeLists.txt
new file mode 100644
index 0000000..bd83773
--- /dev/null
+++ b/src/graphics/engine/test/CMakeLists.txt
@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_BUILD_TYPE debug)
+set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -O0")
+
+include_directories(. ../../..)
+add_executable(modelfile_test modelfile_test.cpp ../modelfile.cpp ../../../common/logger.cpp ../../../common/stringutils.cpp ../../../common/iman.cpp)
diff --git a/src/graphics/engine/test/modelfile_test.cpp b/src/graphics/engine/test/modelfile_test.cpp
new file mode 100644
index 0000000..f7ed87f
--- /dev/null
+++ b/src/graphics/engine/test/modelfile_test.cpp
@@ -0,0 +1,48 @@
+#include "graphics/engine/modelfile.h"
+#include "common/iman.h"
+
+#include <iostream>
+
+
+int main(int argc, char *argv[])
+{
+    if (argc != 4)
+    {
+        std::cerr << "Usage: " << argv[0] << " {mod|dxf} in_file out_file" << std::endl;
+        return 1;
+    }
+
+    CInstanceManager iMan;
+    Gfx::CModelFile modfile(&iMan);
+
+    std::string mode(argv[1]);
+    if (mode == "mod")
+    {
+        if (! modfile.ReadModel(argv[2], false, false) )
+        {
+            std::cerr << "Read error: " << modfile.GetError() << std::endl;
+            return 2;
+        }
+    }
+    else if (mode == "dxf")
+    {
+        if (! modfile.ReadDXF(argv[2], false, false) )
+        {
+            std::cerr << "Read error: " << modfile.GetError() << std::endl;
+            return 2;
+        }
+    }
+    else
+    {
+        std::cerr << "Usage: " << argv[0] << " {mod|dxf} in_file out_file" << std::endl;
+        return 1;
+    }
+
+    if (! modfile.WriteModel(argv[3]) )
+    {
+        std::cerr << "Write error: " << modfile.GetError() << std::endl;
+        return 3;
+    }
+
+    return 0;
+}
diff --git a/src/graphics/common/text.cpp b/src/graphics/engine/text.cpp
index 0c5eb66..2a9543c 100644
--- a/src/graphics/common/text.cpp
+++ b/src/graphics/engine/text.cpp
@@ -17,7 +17,7 @@
 
 // text.cpp
 
-#include "graphics/common/text.h"
+#include "graphics/engine/text.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/text.h b/src/graphics/engine/text.h
index 00b73f2..c2de220 100644
--- a/src/graphics/common/text.h
+++ b/src/graphics/engine/text.h
@@ -19,8 +19,8 @@
 
 #pragma once
 
-#include "graphics/common/engine.h"
-#include "graphics/common/device.h"
+#include "graphics/engine/engine.h"
+#include "graphics/core/device.h"
 #include "math/point.h"
 
 
@@ -73,7 +73,7 @@ public:
     CText(CInstanceManager *iMan, Gfx::CEngine* engine);
     ~CText();
 
-    void        SetGLDevice(Gfx::CDevice device);
+    void        SetDevice(Gfx::CDevice *device);
 
     void        DrawText(char *string, char *format, int len, Math::Point pos, float width, int justif, float size, float stretch, int eol);
     void        DrawText(char *string, char *format, Math::Point pos, float width, int justif, float size, float stretch, int eol);
@@ -106,7 +106,7 @@ protected:
 protected:
     CInstanceManager*   m_iMan;
     Gfx::CEngine*       m_engine;
-    Gfx::CDevice        m_pDevice;
+    Gfx::CDevice*       m_device;
 
 };
 
diff --git a/src/graphics/common/water.cpp b/src/graphics/engine/water.cpp
index 5172b9f..a157e82 100644
--- a/src/graphics/common/water.cpp
+++ b/src/graphics/engine/water.cpp
@@ -17,7 +17,7 @@
 
 // water.cpp
 
-#include "graphics/common/water.h"
+#include "graphics/engine/water.h"
 
 
 // TODO implementation
diff --git a/src/graphics/common/water.h b/src/graphics/engine/water.h
index 5999eac..67be9dc 100644
--- a/src/graphics/common/water.h
+++ b/src/graphics/engine/water.h
@@ -19,8 +19,8 @@
 
 #pragma once
 
-#include "graphics/common/engine.h"
-#include "graphics/common/particle.h"
+#include "graphics/engine/engine.h"
+#include "graphics/engine/particle.h"
 #include "common/event.h"
 
 
@@ -48,7 +48,7 @@ const short MAXWATVAPOR = 10;
 struct WaterVapor
 {
     bool            bUsed;
-    ParticuleType   type;
+    ParticleType   type;
     Math::Vector        pos;
     float           delay;
     float           time;
@@ -96,7 +96,7 @@ protected:
     bool        CreateLine(int x, int y, int len);
 
     void        VaporFlush();
-    bool        VaporCreate(ParticuleType type, Math::Vector pos, float delay);
+    bool        VaporCreate(ParticleType type, Math::Vector pos, float delay);
     void        VaporFrame(int i, float rTime);
 
 protected:
diff --git a/src/graphics/opengl/README.txt b/src/graphics/opengl/README.txt
index 11aba8d..0aba0ed 100644
--- a/src/graphics/opengl/README.txt
+++ b/src/graphics/opengl/README.txt
@@ -2,5 +2,5 @@ src/graphics/opengl
 
 OpenGL engine implementation
 
-Contains the concreate implementation using OpenGL of functions
-of grahpics engine in graphics/common.
+Contains the concrete implementation using OpenGL of abstract CDevice class
+from src/graphics/core
diff --git a/src/graphics/opengl/gldevice.cpp b/src/graphics/opengl/gldevice.cpp
index 7938e62..3a255f4 100644
--- a/src/graphics/opengl/gldevice.cpp
+++ b/src/graphics/opengl/gldevice.cpp
@@ -18,4 +18,1194 @@
 
 #include "graphics/opengl/gldevice.h"
 
-// TODO
+#include "common/config.h"
+#include "common/image.h"
+#include "math/geometry.h"
+
+
+#if defined(USE_GLEW)
+
+// When using GLEW, only glew.h is needed
+#include <GL/glew.h>
+
+#else
+
+// Should define prototypes of used extensions as OpenGL functions
+#define GL_GLEXT_PROTOTYPES
+
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <GL/glext.h>
+
+#endif // if defined(GLEW)
+
+#include <SDL/SDL.h>
+
+#include <cassert>
+
+
+
+void Gfx::GLDeviceConfig::LoadDefault()
+{
+    Gfx::DeviceConfig::LoadDefault();
+
+    hardwareAccel = true;
+
+    redSize = 8;
+    blueSize = 8;
+    greenSize = 8;
+    alphaSize = 8;
+    depthSize = 24;
+}
+
+
+
+
+Gfx::CGLDevice::CGLDevice(const Gfx::GLDeviceConfig &config)
+{
+    m_config = config;
+    m_wasInit = false;
+    m_lighting = false;
+    m_texturing = false;
+}
+
+
+Gfx::CGLDevice::~CGLDevice()
+{
+}
+
+bool Gfx::CGLDevice::GetWasInit()
+{
+    return m_wasInit;
+}
+
+std::string Gfx::CGLDevice::GetError()
+{
+    return m_error;
+}
+
+bool Gfx::CGLDevice::Create()
+{
+#if defined(USE_GLEW)
+    static bool glewInited = false;
+
+    if (!glewInited)
+    {
+        glewInited = true;
+
+        if (glewInit() != GLEW_OK)
+        {
+            m_error = "GLEW initialization failed";
+            return false;
+        }
+
+        if ( (! GLEW_ARB_multitexture) || (! GLEW_EXT_texture_env_combine) || (! GLEW_EXT_secondary_color) )
+        {
+            m_error = "GLEW reports required extensions not supported";
+            return false;
+        }
+    }
+#endif
+
+    /* NOTE: when not using GLEW, extension testing is not performed, as it is assumed that
+             glext.h is up-to-date and the OpenGL shared library has the required functions present. */
+
+    m_wasInit = true;
+
+    // This is mostly done in all modern hardware by default
+    // DirectX doesn't even allow the option to turn off perspective correction anymore
+    // So turn it on permanently
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
+    // To use separate specular color in drawing primitives
+    glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
+
+    // To avoid problems with scaling & lighting
+    glEnable(GL_RESCALE_NORMAL);
+
+    // Set just to be sure
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    glViewport(0, 0, m_config.size.w, m_config.size.h);
+
+
+    m_lights        = std::vector<Gfx::Light>(GL_MAX_LIGHTS, Gfx::Light());
+    m_lightsEnabled = std::vector<bool>      (GL_MAX_LIGHTS, false);
+
+    int maxTextures = 0;
+    glGetIntegerv(GL_MAX_TEXTURE_UNITS, &maxTextures);
+
+    m_currentTextures    = std::vector<Gfx::Texture>           (maxTextures, Gfx::Texture());
+    m_texturesEnabled    = std::vector<bool>                   (maxTextures, false);
+    m_textureStageParams = std::vector<Gfx::TextureStageParams>(maxTextures, Gfx::TextureStageParams());
+
+    return true;
+}
+
+void Gfx::CGLDevice::Destroy()
+{
+    // Delete the remaining textures
+    // Should not be strictly necessary, but just in case
+    DestroyAllTextures();
+
+    m_lights.clear();
+    m_lightsEnabled.clear();
+
+    m_currentTextures.clear();
+    m_texturesEnabled.clear();
+    m_textureStageParams.clear();
+
+    m_wasInit = false;
+}
+
+void Gfx::CGLDevice::ConfigChanged(const Gfx::GLDeviceConfig& newConfig)
+{
+    m_config = newConfig;
+
+    // Reset state
+    m_lighting = false;
+    m_texturing = false;
+    Destroy();
+    Create();
+}
+
+void Gfx::CGLDevice::BeginScene()
+{
+    Clear();
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadMatrixf(m_projectionMat.Array());
+
+    UpdateModelviewMatrix();
+}
+
+void Gfx::CGLDevice::EndScene()
+{
+    glFlush();
+}
+
+void Gfx::CGLDevice::Clear()
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void Gfx::CGLDevice::SetTransform(Gfx::TransformType type, const Math::Matrix &matrix)
+{
+    if      (type == Gfx::TRANSFORM_WORLD)
+    {
+        m_worldMat = matrix;
+        UpdateModelviewMatrix();
+    }
+    else if (type == Gfx::TRANSFORM_VIEW)
+    {
+        m_viewMat = matrix;
+        UpdateModelviewMatrix();
+    }
+    else if (type == Gfx::TRANSFORM_PROJECTION)
+    {
+        m_projectionMat = matrix;
+        glMatrixMode(GL_PROJECTION);
+        glLoadMatrixf(m_projectionMat.Array());
+    }
+    else
+    {
+        assert(false);
+    }
+}
+
+const Math::Matrix& Gfx::CGLDevice::GetTransform(Gfx::TransformType type)
+{
+    if      (type == Gfx::TRANSFORM_WORLD)
+        return m_worldMat;
+    else if (type == Gfx::TRANSFORM_VIEW)
+        return m_viewMat;
+    else if (type == Gfx::TRANSFORM_PROJECTION)
+        return m_projectionMat;
+    else
+        assert(false);
+
+    return m_worldMat; // to avoid warning
+}
+
+void Gfx::CGLDevice::MultiplyTransform(Gfx::TransformType type, const Math::Matrix &matrix)
+{
+    if      (type == Gfx::TRANSFORM_WORLD)
+    {
+        m_worldMat = Math::MultiplyMatrices(m_worldMat, matrix);
+        UpdateModelviewMatrix();
+    }
+    else if (type == Gfx::TRANSFORM_VIEW)
+    {
+        m_viewMat = Math::MultiplyMatrices(m_viewMat, matrix);
+        UpdateModelviewMatrix();
+    }
+    else if (type == Gfx::TRANSFORM_PROJECTION)
+    {
+        m_projectionMat = Math::MultiplyMatrices(m_projectionMat, matrix);
+        glMatrixMode(GL_PROJECTION);
+        glLoadMatrixf(m_projectionMat.Array());
+    }
+    else
+    {
+        assert(false);
+    }
+}
+
+void Gfx::CGLDevice::UpdateModelviewMatrix()
+{
+    m_modelviewMat = Math::MultiplyMatrices(m_viewMat, m_worldMat);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    glScalef(1.0f, 1.0f, -1.0f);
+    glMultMatrixf(m_modelviewMat.Array());
+
+    if (m_lighting)
+    {
+        for (int index = 0; index < static_cast<int>( m_lights.size() ); ++index)
+            UpdateLightPosition(index);
+    }
+}
+
+void Gfx::CGLDevice::SetMaterial(const Gfx::Material &material)
+{
+    m_material = material;
+
+    glMaterialfv(GL_FRONT, GL_AMBIENT,  m_material.ambient.Array());
+    glMaterialfv(GL_FRONT, GL_DIFFUSE,  m_material.diffuse.Array());
+    glMaterialfv(GL_FRONT, GL_SPECULAR, m_material.specular.Array());
+}
+
+const Gfx::Material& Gfx::CGLDevice::GetMaterial()
+{
+    return m_material;
+}
+
+int Gfx::CGLDevice::GetMaxLightCount()
+{
+    return m_lights.size();
+}
+
+void Gfx::CGLDevice::SetLight(int index, const Gfx::Light &light)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_lights.size() ));
+
+    m_lights[index] = light;
+
+    // Indexing from GL_LIGHT0 should always work
+    glLightfv(GL_LIGHT0 + index, GL_AMBIENT,  const_cast<GLfloat*>(light.ambient.Array()));
+    glLightfv(GL_LIGHT0 + index, GL_DIFFUSE,  const_cast<GLfloat*>(light.diffuse.Array()));
+    glLightfv(GL_LIGHT0 + index, GL_SPECULAR, const_cast<GLfloat*>(light.specular.Array()));
+
+    glLightf(GL_LIGHT0 + index, GL_CONSTANT_ATTENUATION,  light.attenuation0);
+    glLightf(GL_LIGHT0 + index, GL_LINEAR_ATTENUATION,    light.attenuation1);
+    glLightf(GL_LIGHT0 + index, GL_QUADRATIC_ATTENUATION, light.attenuation2);
+
+    if (light.type == Gfx::LIGHT_SPOT)
+    {
+        glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, light.spotAngle);
+        glLightf(GL_LIGHT0 + index, GL_SPOT_EXPONENT, light.spotIntensity);
+    }
+    else
+    {
+        glLightf(GL_LIGHT0 + index, GL_SPOT_CUTOFF, 180.0f);
+    }
+
+    UpdateLightPosition(index);
+}
+
+void Gfx::CGLDevice::UpdateLightPosition(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_lights.size() ));
+
+    if ((! m_lighting) || (! m_lightsEnabled[index]))
+        return;
+
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+
+    glLoadIdentity();
+    glScalef(1.0f, 1.0f, -1.0f);
+    glMultMatrixf(m_viewMat.Array());
+
+    if (m_lights[index].type == LIGHT_DIRECTIONAL)
+    {
+        GLfloat position[4] = { m_lights[index].direction.x, m_lights[index].direction.y, m_lights[index].direction.z, 0.0f };
+        glLightfv(GL_LIGHT0 + index, GL_POSITION, position);
+    }
+    else
+    {
+        GLfloat position[4] = { m_lights[index].position.x, m_lights[index].position.y, m_lights[index].position.z, 1.0f };
+        glLightfv(GL_LIGHT0 + index, GL_POSITION, position);
+    }
+
+    if (m_lights[index].type == Gfx::LIGHT_SPOT)
+    {
+        GLfloat direction[4] = { m_lights[index].direction.x, m_lights[index].direction.y, m_lights[index].direction.z, 0.0f };
+        glLightfv(GL_LIGHT0 + index, GL_SPOT_DIRECTION, direction);
+    }
+
+    glPopMatrix();
+}
+
+const Gfx::Light& Gfx::CGLDevice::GetLight(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_lights.size() ));
+
+    return m_lights[index];
+}
+
+void Gfx::CGLDevice::SetLightEnabled(int index, bool enabled)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_lights.size() ));
+
+    m_lightsEnabled[index] = enabled;
+
+    glEnable(GL_LIGHT0 + index);
+}
+
+bool Gfx::CGLDevice::GetLightEnabled(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_lights.size() ));
+
+    return m_lightsEnabled[index];
+}
+
+/** If image is invalid, returns invalid texture.
+    Otherwise, returns pointer to new Gfx::Texture struct.
+    This struct must not be deleted in other way than through DeleteTexture() */
+Gfx::Texture Gfx::CGLDevice::CreateTexture(CImage *image, const Gfx::TextureCreateParams &params)
+{
+    Gfx::Texture result;
+
+    ImageData *data = image->GetData();
+    if (data == NULL)
+    {
+        m_error = "Invalid texture data";
+        return result; // invalid texture
+    }
+
+    result.valid = true;
+    result.size.w = data->surface->w;
+    result.size.h = data->surface->h;
+
+    // Use & enable 1st texture stage
+    glActiveTexture(GL_TEXTURE0);
+    glEnable(GL_TEXTURE_2D);
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    glGenTextures(1, &result.id);
+    glBindTexture(GL_TEXTURE_2D, result.id);
+
+    // Set params
+
+    GLint minF = 0;
+    if      (params.minFilter == Gfx::TEX_MIN_FILTER_NEAREST)                minF = GL_NEAREST;
+    else if (params.minFilter == Gfx::TEX_MIN_FILTER_LINEAR)                 minF = GL_LINEAR;
+    else if (params.minFilter == Gfx::TEX_MIN_FILTER_NEAREST_MIPMAP_NEAREST) minF = GL_NEAREST_MIPMAP_NEAREST;
+    else if (params.minFilter == Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_NEAREST)  minF = GL_LINEAR_MIPMAP_NEAREST;
+    else if (params.minFilter == Gfx::TEX_MIN_FILTER_NEAREST_MIPMAP_LINEAR)  minF = GL_NEAREST_MIPMAP_LINEAR;
+    else if (params.minFilter == Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR)   minF = GL_LINEAR_MIPMAP_LINEAR;
+    else  assert(false);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minF);
+
+    GLint magF = 0;
+    if      (params.magFilter == Gfx::TEX_MAG_FILTER_NEAREST) magF = GL_NEAREST;
+    else if (params.magFilter == Gfx::TEX_MAG_FILTER_LINEAR)  magF = GL_LINEAR;
+    else  assert(false);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magF);
+
+    if (params.mipmap)
+        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
+    else
+        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
+
+    GLenum sourceFormat = 0;
+    if (params.format == Gfx::TEX_IMG_RGB)
+    {
+        sourceFormat = GL_RGB;
+        result.alpha = false;
+    }
+    else if (params.format == Gfx::TEX_IMG_BGR)
+    {
+        sourceFormat = GL_BGR;
+        result.alpha = false;
+    }
+    else if (params.format == Gfx::TEX_IMG_RGBA)
+    {
+        sourceFormat = GL_RGBA;
+        result.alpha = true;
+    }
+    else if (params.format == Gfx::TEX_IMG_BGRA)
+    {
+        sourceFormat = GL_BGRA;
+        result.alpha = true;
+    }
+    else
+        assert(false);
+
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data->surface->w, data->surface->h,
+                 0, sourceFormat, GL_UNSIGNED_BYTE, data->surface->pixels);
+
+
+    // Restore the previous state of 1st stage
+    if (m_currentTextures[0].valid)
+        glBindTexture(GL_TEXTURE_2D, m_currentTextures[0].id);
+    else
+        glBindTexture(GL_TEXTURE_2D, 0);
+
+    if ( (! m_texturing) || (! m_texturesEnabled[0]) )
+        glDisable(GL_TEXTURE_2D);
+
+    return result;
+}
+
+void Gfx::CGLDevice::DestroyTexture(const Gfx::Texture &texture)
+{
+    std::set<Gfx::Texture>::iterator it = m_allTextures.find(texture);
+    if (it != m_allTextures.end())
+        m_allTextures.erase(it);
+
+    // Unbind the texture if in use anywhere
+    for (int index = 0; index < static_cast<int>( m_currentTextures.size() ); ++index)
+    {
+        if (m_currentTextures[index] == texture)
+            SetTexture(index, Gfx::Texture()); // set to invalid texture
+    }
+
+    glDeleteTextures(1, &texture.id);
+}
+
+void Gfx::CGLDevice::DestroyAllTextures()
+{
+    std::set<Gfx::Texture> allCopy = m_allTextures;
+    std::set<Gfx::Texture>::iterator it;
+    for (it = allCopy.begin(); it != allCopy.end(); ++it)
+        DestroyTexture(*it);
+}
+
+int Gfx::CGLDevice::GetMaxTextureCount()
+{
+    return m_currentTextures.size();
+}
+
+/**
+  If \a texture is invalid, unbinds the given texture.
+  If valid, binds the texture and enables the given texture stage.
+  The setting is remembered, even if texturing is disabled at the moment. */
+void Gfx::CGLDevice::SetTexture(int index, const Gfx::Texture &texture)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    // Enable the given texture stage
+    glActiveTexture(GL_TEXTURE0 + index);
+    glEnable(GL_TEXTURE_2D);
+
+    m_currentTextures[index] = texture; // remember the change
+
+    if (! texture.valid)
+    {
+        glBindTexture(GL_TEXTURE_2D, 0); // unbind texture
+    }
+    else
+    {
+        glBindTexture(GL_TEXTURE_2D, texture.id);                  // bind the texture
+        SetTextureStageParams(index, m_textureStageParams[index]); // texture stage params need to be re-set for the new texture
+    }
+
+    // Disable the stage if it is set so
+    if ( (! m_texturing) || (! m_texturesEnabled[index]) )
+        glDisable(GL_TEXTURE_2D);
+}
+
+/**
+  Returns the previously assigned texture or invalid texture if the given stage is not enabled. */
+Gfx::Texture Gfx::CGLDevice::GetTexture(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    return m_currentTextures[index];
+}
+
+void Gfx::CGLDevice::SetTextureEnabled(int index, bool enabled)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    m_texturesEnabled[index] = enabled;
+
+    glActiveTexture(GL_TEXTURE0 + index);
+    if (enabled)
+        glEnable(GL_TEXTURE_2D);
+    else
+        glDisable(GL_TEXTURE_2D);
+}
+
+bool Gfx::CGLDevice::GetTextureEnabled(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    return m_texturesEnabled[index];
+}
+
+/**
+  Sets the texture parameters for the given texture stage.
+  If the given texture was not set (bound) yet, nothing happens.
+  The settings are remembered, even if texturing is disabled at the moment. */
+void Gfx::CGLDevice::SetTextureStageParams(int index, const Gfx::TextureStageParams &params)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    // Remember the settings
+    m_textureStageParams[index] = params;
+
+    // Don't actually do anything if texture not set
+    if (! m_currentTextures[index].valid)
+        return;
+
+    // Enable the given stage
+    glActiveTexture(GL_TEXTURE0 + index);
+    glEnable(GL_TEXTURE_2D);
+
+    glBindTexture(GL_TEXTURE_2D, m_currentTextures[index].id);
+
+    // To save some trouble
+    if ( (params.colorOperation == Gfx::TEX_MIX_OPER_DEFAULT) &&
+         (params.alphaOperation == Gfx::TEX_MIX_OPER_DEFAULT) )
+    {
+        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        goto after_tex_operations;
+    }
+
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
+
+    // Only these modes of getting color & alpha are used
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
+    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
+
+    // Color operation
+
+    if (params.colorOperation == Gfx::TEX_MIX_OPER_DEFAULT)
+    {
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
+        goto after_tex_color;
+    }
+    else if (params.colorOperation == Gfx::TEX_MIX_OPER_REPLACE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
+    else if (params.colorOperation == Gfx::TEX_MIX_OPER_MODULATE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
+    else if (params.colorOperation == Gfx::TEX_MIX_OPER_ADD)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);
+    else if (params.colorOperation == Gfx::TEX_MIX_OPER_SUBTRACT)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_SUBTRACT);
+    else  assert(false);
+
+    // Color arg1
+    if (params.colorArg1 == Gfx::TEX_MIX_ARG_TEXTURE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
+    else if (params.colorArg1 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
+    else if (params.colorArg1 == Gfx::TEX_MIX_ARG_SRC_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
+    else if (params.colorArg1 == Gfx::TEX_MIX_ARG_FACTOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
+    else  assert(false);
+
+    // Color arg2
+    if (params.colorArg2 == Gfx::TEX_MIX_ARG_TEXTURE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
+    else if (params.colorArg2 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
+    else if (params.colorArg2 == Gfx::TEX_MIX_ARG_SRC_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
+    else if (params.colorArg2 == Gfx::TEX_MIX_ARG_FACTOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
+    else  assert(false);
+
+
+after_tex_color:
+
+    // Alpha operation
+    if (params.alphaOperation == Gfx::TEX_MIX_OPER_DEFAULT)
+    {
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
+        goto after_tex_operations;
+    }
+    else if (params.colorOperation == Gfx::TEX_MIX_OPER_REPLACE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
+    else if (params.alphaOperation == Gfx::TEX_MIX_OPER_MODULATE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
+    else if (params.alphaOperation == Gfx::TEX_MIX_OPER_ADD)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_ADD);
+    else if (params.alphaOperation == Gfx::TEX_MIX_OPER_SUBTRACT)
+        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_SUBTRACT);
+    else  assert(false);
+
+    // Alpha arg1
+    if (params.alphaArg1 == Gfx::TEX_MIX_ARG_TEXTURE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
+    else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
+    else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_SRC_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
+    else if (params.alphaArg1 == Gfx::TEX_MIX_ARG_FACTOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_CONSTANT);
+    else  assert(false);
+
+    // Alpha arg2
+    if (params.alphaArg2 == Gfx::TEX_MIX_ARG_TEXTURE)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
+    else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_COMPUTED_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PREVIOUS);
+    else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_SRC_COLOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_PRIMARY_COLOR);
+    else if (params.alphaArg2 == Gfx::TEX_MIX_ARG_FACTOR)
+        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
+    else  assert(false);
+
+
+after_tex_operations:
+
+    if      (params.wrapS == Gfx::TEX_WRAP_CLAMP)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    else if (params.wrapS == Gfx::TEX_WRAP_REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    else  assert(false);
+
+    if      (params.wrapT == Gfx::TEX_WRAP_CLAMP)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    else if (params.wrapT == Gfx::TEX_WRAP_REPEAT)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    else  assert(false);
+
+    // Disable the stage if it is set so
+    if ( (! m_texturing) || (! m_texturesEnabled[index]) )
+        glDisable(GL_TEXTURE_2D);
+}
+
+Gfx::TextureStageParams Gfx::CGLDevice::GetTextureStageParams(int index)
+{
+    assert(index >= 0);
+    assert(index < static_cast<int>( m_currentTextures.size() ));
+
+    return m_textureStageParams[index];
+}
+
+void Gfx::CGLDevice::SetTextureFactor(const Gfx::Color &color)
+{
+    // Needs to be set for all texture stages
+    for (int index = 0; index < static_cast<int>( m_currentTextures.size() ); ++index)
+    {
+        // Activate stage
+        glActiveTexture(GL_TEXTURE0 + index);
+        glEnable(GL_TEXTURE_2D);
+
+        glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color.Array());
+
+        // Disable the stage if it is set so
+        if ( (! m_texturing) || (! m_texturesEnabled[index]) )
+            glDisable(GL_TEXTURE_2D);
+    }
+}
+
+Gfx::Color Gfx::CGLDevice::GetTextureFactor()
+{
+    // Get from 1st stage (should be the same for all stages)
+    glActiveTexture(GL_TEXTURE0);
+    glEnable(GL_TEXTURE_2D);
+
+    GLfloat color[4] = { 0.0f };
+    glGetTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
+
+    // Disable the 1st stage if it is set so
+    if ( (! m_texturing) || (! m_texturesEnabled[0]) )
+        glDisable(GL_TEXTURE_2D);
+
+    return Gfx::Color(color[0], color[1], color[2], color[3]);
+}
+
+GLenum TranslateGfxPrimitive(Gfx::PrimitiveType type)
+{
+    GLenum flag = 0;
+    switch (type)
+    {
+        case Gfx::PRIMITIVE_POINTS:         flag = GL_POINTS; break;
+        case Gfx::PRIMITIVE_LINES:          flag = GL_LINES; break;
+        case Gfx::PRIMITIVE_LINE_STRIP:     flag = GL_LINE_STRIP; break;
+        case Gfx::PRIMITIVE_TRIANGLES:      flag = GL_TRIANGLES; break;
+        case Gfx::PRIMITIVE_TRIANGLE_STRIP: flag = GL_TRIANGLE_STRIP; break;
+        default: assert(false); break;
+    }
+    return flag;
+}
+
+void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const Vertex *vertices, int vertexCount)
+{
+    glBegin(TranslateGfxPrimitive(type));
+
+    glColor3f(1.0f, 1.0f, 1.0f);
+
+    for (int i = 0; i < vertexCount; ++i)
+    {
+        glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array()));
+        glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
+        glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
+    }
+
+    glEnd();
+}
+
+void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexCol *vertices, int vertexCount)
+{
+    glBegin(TranslateGfxPrimitive(type));
+
+    for (int i = 0; i < vertexCount; ++i)
+    {
+        glColor4fv(const_cast<GLfloat*>(vertices[i].color.Array()));
+        glSecondaryColor3fv(const_cast<GLfloat*>(vertices[i].specular.Array()));
+        glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
+        glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
+    }
+
+    glEnd();
+}
+
+void Gfx::CGLDevice::DrawPrimitive(Gfx::PrimitiveType type, const VertexTex2 *vertices, int vertexCount)
+{
+    glBegin(TranslateGfxPrimitive(type));
+
+    glColor3f(1.0f, 1.0f, 1.0f);
+
+    for (int i = 0; i < vertexCount; ++i)
+    {
+        glNormal3fv(const_cast<GLfloat*>(vertices[i].normal.Array()));
+        glMultiTexCoord2fv(GL_TEXTURE0, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
+        glMultiTexCoord2fv(GL_TEXTURE1, const_cast<GLfloat*>(vertices[i].texCoord.Array()));
+        glVertex3fv(const_cast<GLfloat*>(vertices[i].coord.Array()));
+    }
+
+    glEnd();
+}
+
+bool InPlane(Math::Vector normal, float originPlane, Math::Vector center, float radius)
+{
+    float distance = (originPlane + Math::DotProduct(normal, center)) / normal.Length();
+
+    if (distance < -radius)
+        return true;
+
+    return false;
+}
+
+/*
+   The implementation of ComputeSphereVisibility is taken from libwine's device.c
+   Copyright of the WINE team, licensed under GNU LGPL v 2.1
+ */
+
+// TODO: testing
+int Gfx::CGLDevice::ComputeSphereVisibility(const Math::Vector &center, float radius)
+{
+    Math::Matrix m;
+    m.LoadIdentity();
+    m = Math::MultiplyMatrices(m, m_worldMat);
+    m = Math::MultiplyMatrices(m, m_viewMat);
+    m = Math::MultiplyMatrices(m, m_projectionMat);
+
+    Math::Vector vec[6];
+    float originPlane[6];
+
+    // Left plane
+    vec[0].x = m.Get(4, 1) + m.Get(1, 1);
+    vec[0].y = m.Get(4, 2) + m.Get(1, 2);
+    vec[0].z = m.Get(4, 3) + m.Get(1, 3);
+    originPlane[0] = m.Get(4, 4) + m.Get(1, 4);
+
+    // Right plane
+    vec[1].x = m.Get(4, 1) - m.Get(1, 1);
+    vec[1].y = m.Get(4, 2) - m.Get(1, 2);
+    vec[1].z = m.Get(4, 3) - m.Get(1, 3);
+    originPlane[1] = m.Get(4, 4) - m.Get(1, 4);
+
+    // Top plane
+    vec[2].x = m.Get(4, 1) - m.Get(2, 1);
+    vec[2].y = m.Get(4, 2) - m.Get(2, 2);
+    vec[2].z = m.Get(4, 3) - m.Get(2, 3);
+    originPlane[2] = m.Get(4, 4) - m.Get(2, 4);
+
+    // Bottom plane
+    vec[3].x = m.Get(4, 1) + m.Get(2, 1);
+    vec[3].y = m.Get(4, 2) + m.Get(2, 2);
+    vec[3].z = m.Get(4, 3) + m.Get(2, 3);
+    originPlane[3] = m.Get(4, 4) + m.Get(2, 4);
+
+    // Front plane
+    vec[4].x = m.Get(3, 1);
+    vec[4].y = m.Get(3, 2);
+    vec[4].z = m.Get(3, 3);
+    originPlane[4] = m.Get(3, 4);
+
+    // Back plane
+    vec[5].x = m.Get(4, 1) - m.Get(3, 1);
+    vec[5].y = m.Get(4, 2) - m.Get(3, 2);
+    vec[5].z = m.Get(4, 3) - m.Get(3, 3);
+    originPlane[5] = m.Get(4, 4) - m.Get(3, 4);
+
+    int result = 0;
+
+    if (InPlane(vec[0], originPlane[0], center, radius))
+        result |= Gfx::INTERSECT_PLANE_LEFT;
+    if (InPlane(vec[1], originPlane[1], center, radius))
+        result |= Gfx::INTERSECT_PLANE_RIGHT;
+    if (InPlane(vec[2], originPlane[2], center, radius))
+        result |= Gfx::INTERSECT_PLANE_TOP;
+    if (InPlane(vec[3], originPlane[3], center, radius))
+        result |= Gfx::INTERSECT_PLANE_BOTTOM;
+    if (InPlane(vec[4], originPlane[4], center, radius))
+        result |= Gfx::INTERSECT_PLANE_FRONT;
+    if (InPlane(vec[5], originPlane[5], center, radius))
+        result |= Gfx::INTERSECT_PLANE_BACK;
+
+    return result;
+}
+
+void Gfx::CGLDevice::SetRenderState(Gfx::RenderState state, bool enabled)
+{
+    if (state == Gfx::RENDER_STATE_DEPTH_WRITE)
+    {
+        glDepthMask(enabled ? GL_TRUE : GL_FALSE);
+        return;
+    }
+    else if (state == Gfx::RENDER_STATE_LIGHTING)
+    {
+        m_lighting = enabled;
+
+        if (enabled)
+            glEnable(GL_LIGHTING);
+        else
+            glDisable(GL_LIGHTING);
+
+        if (enabled)
+        {
+            for (int index = 0; index < static_cast<int>( m_lights.size() ); ++index)
+                UpdateLightPosition(index);
+        }
+
+        return;
+    }
+    else if (state == Gfx::RENDER_STATE_TEXTURING)
+    {
+        m_texturing = enabled;
+
+        // Enable/disable stages with new setting
+        for (int index = 0; index < static_cast<int>( m_currentTextures.size() ); ++index)
+        {
+            glActiveTexture(GL_TEXTURE0 + index);
+            if (m_texturing && m_texturesEnabled[index])
+                glEnable(GL_TEXTURE_2D);
+            else
+                glDisable(GL_TEXTURE_2D);
+        }
+
+        return;
+    }
+
+    GLenum flag = 0;
+
+    switch (state)
+    {
+        case Gfx::RENDER_STATE_BLENDING:    flag = GL_BLEND; break;
+        case Gfx::RENDER_STATE_FOG:         flag = GL_FOG; break;
+        case Gfx::RENDER_STATE_DEPTH_TEST:  flag = GL_DEPTH_TEST; break;
+        case Gfx::RENDER_STATE_ALPHA_TEST:  flag = GL_ALPHA_TEST; break;
+        case Gfx::RENDER_STATE_CULLING:     flag = GL_CULL_FACE; break;
+        case Gfx::RENDER_STATE_DITHERING:   flag = GL_DITHER; break;
+        default: assert(false); break;
+    }
+
+    if (enabled)
+        glEnable(flag);
+    else
+        glDisable(flag);
+}
+
+bool Gfx::CGLDevice::GetRenderState(Gfx::RenderState state)
+{
+    if (state == Gfx::RENDER_STATE_LIGHTING)
+        return m_lighting;
+
+    if (state == Gfx::RENDER_STATE_TEXTURING)
+        return m_texturing;
+
+    GLenum flag = 0;
+
+    switch (state)
+    {
+        case Gfx::RENDER_STATE_DEPTH_WRITE: flag = GL_DEPTH_WRITEMASK; break;
+        case Gfx::RENDER_STATE_BLENDING:    flag = GL_BLEND; break;
+        case Gfx::RENDER_STATE_FOG:         flag = GL_FOG; break;
+        case Gfx::RENDER_STATE_DEPTH_TEST:  flag = GL_DEPTH_TEST; break;
+        case Gfx::RENDER_STATE_ALPHA_TEST:  flag = GL_ALPHA_TEST; break;
+        case Gfx::RENDER_STATE_CULLING:     flag = GL_CULL_FACE; break;
+        case Gfx::RENDER_STATE_DITHERING:   flag = GL_DITHER; break;
+        default: assert(false); break;
+    }
+
+    GLboolean result = GL_FALSE;
+    glGetBooleanv(flag, &result);
+
+    return result == GL_TRUE;
+}
+
+Gfx::CompFunc TranslateGLCompFunc(GLenum flag)
+{
+    switch (flag)
+    {
+        case GL_NEVER:    return Gfx::COMP_FUNC_NEVER;
+        case GL_LESS:     return Gfx::COMP_FUNC_LESS;
+        case GL_EQUAL:    return Gfx::COMP_FUNC_EQUAL;
+        case GL_NOTEQUAL: return Gfx::COMP_FUNC_NOTEQUAL;
+        case GL_LEQUAL:   return Gfx::COMP_FUNC_LEQUAL;
+        case GL_GREATER:  return Gfx::COMP_FUNC_GREATER;
+        case GL_GEQUAL:   return Gfx::COMP_FUNC_GEQUAL;
+        case GL_ALWAYS:   return Gfx::COMP_FUNC_ALWAYS;
+        default: assert(false); break;
+    }
+    return Gfx::COMP_FUNC_NEVER;
+}
+
+GLenum TranslateGfxCompFunc(Gfx::CompFunc func)
+{
+    switch (func)
+    {
+        case Gfx::COMP_FUNC_NEVER:    return GL_NEVER;
+        case Gfx::COMP_FUNC_LESS:     return GL_LESS;
+        case Gfx::COMP_FUNC_EQUAL:    return GL_EQUAL;
+        case Gfx::COMP_FUNC_NOTEQUAL: return GL_NOTEQUAL;
+        case Gfx::COMP_FUNC_LEQUAL:   return GL_LEQUAL;
+        case Gfx::COMP_FUNC_GREATER:  return GL_GREATER;
+        case Gfx::COMP_FUNC_GEQUAL:   return GL_GEQUAL;
+        case Gfx::COMP_FUNC_ALWAYS:   return GL_ALWAYS;
+        default: assert(false); break;
+    }
+    return 0;
+}
+
+void Gfx::CGLDevice::SetDepthTestFunc(Gfx::CompFunc func)
+{
+    glDepthFunc(TranslateGfxCompFunc(func));
+}
+
+Gfx::CompFunc Gfx::CGLDevice::GetDepthTestFunc()
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_DEPTH_FUNC, &flag);
+    return TranslateGLCompFunc(static_cast<GLenum>(flag));
+}
+
+void Gfx::CGLDevice::SetDepthBias(float factor)
+{
+    glPolygonOffset(factor, 0.0f);
+}
+
+float Gfx::CGLDevice::GetDepthBias()
+{
+    GLfloat result = 0.0f;
+    glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &result);
+    return result;
+}
+
+void Gfx::CGLDevice::SetAlphaTestFunc(Gfx::CompFunc func, float refValue)
+{
+    glAlphaFunc(TranslateGfxCompFunc(func), refValue);
+}
+
+void Gfx::CGLDevice::GetAlphaTestFunc(Gfx::CompFunc &func, float &refValue)
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_ALPHA_TEST_FUNC, &flag);
+    func = TranslateGLCompFunc(static_cast<GLenum>(flag));
+
+    glGetFloatv(GL_ALPHA_TEST_REF, static_cast<GLfloat*>(&refValue));
+}
+
+Gfx::BlendFunc TranslateGLBlendFunc(GLenum flag)
+{
+    switch (flag)
+    {
+        case GL_ZERO:                return Gfx::BLEND_ZERO;
+        case GL_ONE:                 return Gfx::BLEND_ONE;
+        case GL_SRC_COLOR:           return Gfx::BLEND_SRC_COLOR;
+        case GL_ONE_MINUS_SRC_COLOR: return Gfx::BLEND_INV_SRC_COLOR;
+        case GL_DST_COLOR:           return Gfx::BLEND_DST_COLOR;
+        case GL_ONE_MINUS_DST_COLOR: return Gfx::BLEND_INV_DST_COLOR;
+        case GL_SRC_ALPHA:           return Gfx::BLEND_SRC_ALPHA;
+        case GL_ONE_MINUS_SRC_ALPHA: return Gfx::BLEND_INV_SRC_ALPHA;
+        case GL_DST_ALPHA:           return Gfx::BLEND_DST_ALPHA;
+        case GL_ONE_MINUS_DST_ALPHA: return Gfx::BLEND_INV_DST_ALPHA;
+        case GL_SRC_ALPHA_SATURATE:  return Gfx::BLEND_SRC_ALPHA_SATURATE;
+        default: assert(false); break;
+    }
+
+    return Gfx::BLEND_ZERO;
+}
+
+GLenum TranslateGfxBlendFunc(Gfx::BlendFunc func)
+{
+    switch (func)
+    {
+        case Gfx::BLEND_ZERO:               return GL_ZERO;
+        case Gfx::BLEND_ONE:                return GL_ONE;
+        case Gfx::BLEND_SRC_COLOR:          return GL_SRC_COLOR;
+        case Gfx::BLEND_INV_SRC_COLOR:      return GL_ONE_MINUS_SRC_COLOR;
+        case Gfx::BLEND_DST_COLOR:          return GL_DST_COLOR;
+        case Gfx::BLEND_INV_DST_COLOR:      return GL_ONE_MINUS_DST_COLOR;
+        case Gfx::BLEND_SRC_ALPHA:          return GL_SRC_ALPHA;
+        case Gfx::BLEND_INV_SRC_ALPHA:      return GL_ONE_MINUS_SRC_ALPHA;
+        case Gfx::BLEND_DST_ALPHA:          return GL_DST_ALPHA;
+        case Gfx::BLEND_INV_DST_ALPHA:      return GL_ONE_MINUS_DST_ALPHA;
+        case Gfx::BLEND_SRC_ALPHA_SATURATE: return GL_SRC_ALPHA_SATURATE;
+        default: assert(false); break;
+    }
+    return 0;
+}
+
+void Gfx::CGLDevice::SetBlendFunc(Gfx::BlendFunc srcBlend, Gfx::BlendFunc dstBlend)
+{
+    glBlendFunc(TranslateGfxBlendFunc(srcBlend), TranslateGfxBlendFunc(dstBlend));
+}
+
+void Gfx::CGLDevice::GetBlendFunc(Gfx::BlendFunc &srcBlend, Gfx::BlendFunc &dstBlend)
+{
+    GLint srcFlag = 0;
+    glGetIntegerv(GL_ALPHA_TEST_FUNC, &srcFlag);
+    srcBlend = TranslateGLBlendFunc(static_cast<GLenum>(srcFlag));
+
+    GLint dstFlag = 0;
+    glGetIntegerv(GL_ALPHA_TEST_FUNC, &dstFlag);
+    dstBlend = TranslateGLBlendFunc(static_cast<GLenum>(dstFlag));
+}
+
+void Gfx::CGLDevice::SetClearColor(const Gfx::Color &color)
+{
+    glClearColor(color.r, color.g, color.b, color.a);
+}
+
+Gfx::Color Gfx::CGLDevice::GetClearColor()
+{
+    GLfloat color[4] = { 0.0f };
+    glGetFloatv(GL_COLOR_CLEAR_VALUE, color);
+    return Gfx::Color(color[0], color[1], color[2], color[3]);
+}
+
+void Gfx::CGLDevice::SetGlobalAmbient(const Gfx::Color &color)
+{
+    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color.Array());
+}
+
+Gfx::Color Gfx::CGLDevice::GetGlobalAmbient()
+{
+    GLfloat color[4] = { 0.0f };
+    glGetFloatv(GL_LIGHT_MODEL_AMBIENT, color);
+    return Gfx::Color(color[0], color[1], color[2], color[3]);
+}
+
+void Gfx::CGLDevice::SetFogParams(Gfx::FogMode mode, const Gfx::Color &color, float start, float end, float density)
+{
+    if      (mode == Gfx::FOG_LINEAR) glFogi(GL_FOG_MODE, GL_LINEAR);
+    else if (mode == Gfx::FOG_EXP)    glFogi(GL_FOG_MODE, GL_EXP);
+    else if (mode == Gfx::FOG_EXP2)   glFogi(GL_FOG_MODE, GL_EXP2);
+    else assert(false);
+
+    glFogf(GL_FOG_START,   start);
+    glFogf(GL_FOG_END,     end);
+    glFogf(GL_FOG_DENSITY, density);
+}
+
+void Gfx::CGLDevice::GetFogParams(Gfx::FogMode &mode, Gfx::Color &color, float &start, float &end, float &density)
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_FOG_MODE, &flag);
+    if      (flag == GL_LINEAR) mode = Gfx::FOG_LINEAR;
+    else if (flag == GL_EXP)    mode = Gfx::FOG_EXP;
+    else if (flag == GL_EXP2)   mode = Gfx::FOG_EXP2;
+    else assert(false);
+
+    glGetFloatv(GL_FOG_START,   static_cast<GLfloat*>(&start));
+    glGetFloatv(GL_FOG_END,     static_cast<GLfloat*>(&end));
+    glGetFloatv(GL_FOG_DENSITY, static_cast<GLfloat*>(&density));
+}
+
+void Gfx::CGLDevice::SetCullMode(Gfx::CullMode mode)
+{
+    if      (mode == Gfx::CULL_CW)  glCullFace(GL_CW);
+    else if (mode == Gfx::CULL_CCW) glCullFace(GL_CCW);
+    else assert(false);
+}
+
+Gfx::CullMode Gfx::CGLDevice::GetCullMode()
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_CULL_FACE, &flag);
+    if      (flag == GL_CW)  return Gfx::CULL_CW;
+    else if (flag == GL_CCW) return Gfx::CULL_CCW;
+    else assert(false);
+    return Gfx::CULL_CW;
+}
+
+void Gfx::CGLDevice::SetShadeModel(Gfx::ShadeModel model)
+{
+    if      (model == Gfx::SHADE_FLAT)   glShadeModel(GL_FLAT);
+    else if (model == Gfx::SHADE_SMOOTH) glShadeModel(GL_SMOOTH);
+    else  assert(false);
+}
+
+Gfx::ShadeModel Gfx::CGLDevice::GetShadeModel()
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_SHADE_MODEL, &flag);
+    if      (flag == GL_FLAT)    return Gfx::SHADE_FLAT;
+    else if (flag == GL_SMOOTH)  return Gfx::SHADE_SMOOTH;
+    else  assert(false);
+    return Gfx::SHADE_FLAT;
+}
+
+void Gfx::CGLDevice::SetFillMode(Gfx::FillMode mode)
+{
+    if      (mode == Gfx::FILL_POINT) glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
+    else if (mode == Gfx::FILL_LINES) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    else if (mode == Gfx::FILL_FILL)  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    else assert(false);
+}
+
+Gfx::FillMode Gfx::CGLDevice::GetFillMode()
+{
+    GLint flag = 0;
+    glGetIntegerv(GL_POLYGON_MODE, &flag);
+    if      (flag == GL_POINT) return Gfx::FILL_POINT;
+    else if (flag == GL_LINE)  return Gfx::FILL_LINES;
+    else if (flag == GL_FILL)  return Gfx::FILL_FILL;
+    else  assert(false);
+    return Gfx::FILL_POINT;
+}
diff --git a/src/graphics/opengl/gldevice.h b/src/graphics/opengl/gldevice.h
index a2fb4a0..1864000 100644
--- a/src/graphics/opengl/gldevice.h
+++ b/src/graphics/opengl/gldevice.h
@@ -19,13 +19,185 @@
 #pragma once
 
 
-#include "graphics/common/device.h"
+#include "graphics/core/device.h"
+
+#include <string>
+#include <vector>
+#include <set>
+
 
 namespace Gfx {
 
+/**
+ \struct GLDeviceConfig
+ \brief Additional config with OpenGL-specific settings */
+struct GLDeviceConfig : public DeviceConfig
+{
+    //! Size of red channel in bits
+    int redSize;
+    //! Size of green channel in bits
+    int greenSize;
+    //! Size of blue channel in bits
+    int blueSize;
+    //! Size of alpha channel in bits
+    int alphaSize;
+    //! Color depth in bits
+    int depthSize;
+
+    //! Force hardware acceleration (video mode set will fail on lack of hw accel)
+    bool hardwareAccel;
+
+    //! Constructor calls LoadDefaults()
+    GLDeviceConfig() { LoadDefault(); }
+
+    //! Loads the default values
+    void LoadDefault();
+};
+
+struct GLDevicePrivate;
+
+/**
+  \class CGLDevice
+  \brief Implementation of CDevice interface in OpenGL
+
+  Provides the concrete implementation of 3D device in OpenGL.
+
+  This class should be initialized (by calling Initialize() ) only after
+  setting the video mode by CApplication, once the OpenGL context is defined.
+  Because of that, CGLDeviceConfig is outside the CDevice class and must be set
+  in CApplication.
+*/
 class CGLDevice : public Gfx::CDevice
 {
-  // TODO
+public:
+    CGLDevice(const Gfx::GLDeviceConfig &config);
+    virtual ~CGLDevice();
+
+    virtual bool GetWasInit();
+    virtual std::string GetError();
+
+    virtual bool Create();
+    virtual void Destroy();
+
+    void ConfigChanged(const Gfx::GLDeviceConfig &newConfig);
+
+    virtual void BeginScene();
+    virtual void EndScene();
+
+    virtual void Clear();
+
+    virtual void SetTransform(Gfx::TransformType type, const Math::Matrix &matrix);
+    virtual const Math::Matrix& GetTransform(Gfx::TransformType type);
+    virtual void MultiplyTransform(Gfx::TransformType type, const Math::Matrix &matrix);
+
+    virtual void SetMaterial(const Gfx::Material &material);
+    virtual const Gfx::Material& GetMaterial();
+
+    virtual int GetMaxLightCount();
+    virtual void SetLight(int index, const Gfx::Light &light);
+    virtual const Gfx::Light& GetLight(int index);
+    virtual void SetLightEnabled(int index, bool enabled);
+    virtual bool GetLightEnabled(int index);
+
+    virtual Gfx::Texture CreateTexture(CImage *image, const Gfx::TextureCreateParams &params);
+    virtual void DestroyTexture(const Gfx::Texture &texture);
+    virtual void DestroyAllTextures();
+
+    virtual int GetMaxTextureCount();
+    virtual void SetTexture(int index, const Gfx::Texture &texture);
+    virtual Gfx::Texture GetTexture(int index);
+    virtual void SetTextureEnabled(int index, bool enabled);
+    virtual bool GetTextureEnabled(int index);
+
+    virtual void SetTextureStageParams(int index, const Gfx::TextureStageParams &params);
+    virtual Gfx::TextureStageParams GetTextureStageParams(int index);
+
+    virtual void SetTextureFactor(const Gfx::Color &color);
+    virtual Gfx::Color GetTextureFactor();
+
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::Vertex     *vertices, int vertexCount);
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexCol  *vertices, int vertexCount);
+    virtual void DrawPrimitive(Gfx::PrimitiveType type, const Gfx::VertexTex2 *vertices, int vertexCount);
+
+    virtual int ComputeSphereVisibility(const Math::Vector &center, float radius);
+
+    virtual void SetRenderState(Gfx::RenderState state, bool enabled);
+    virtual bool GetRenderState(Gfx::RenderState state);
+
+    virtual void SetDepthTestFunc(Gfx::CompFunc func);
+    virtual Gfx::CompFunc GetDepthTestFunc();
+
+    virtual void SetDepthBias(float factor);
+    virtual float GetDepthBias();
+
+    virtual void SetAlphaTestFunc(Gfx::CompFunc func, float refValue);
+    virtual void GetAlphaTestFunc(Gfx::CompFunc &func, float &refValue);
+
+    virtual void SetBlendFunc(Gfx::BlendFunc srcBlend, Gfx::BlendFunc dstBlend);
+    virtual void GetBlendFunc(Gfx::BlendFunc &srcBlend, Gfx::BlendFunc &dstBlend);
+
+    virtual void SetClearColor(const Gfx::Color &color);
+    virtual Gfx::Color GetClearColor();
+
+    virtual void SetGlobalAmbient(const Gfx::Color &color);
+    virtual Gfx::Color GetGlobalAmbient();
+
+    virtual void SetFogParams(Gfx::FogMode mode, const Gfx::Color &color, float start, float end, float density);
+    virtual void GetFogParams(Gfx::FogMode &mode, Gfx::Color &color, float &start, float &end, float &density);
+
+    virtual void SetCullMode(Gfx::CullMode mode);
+    virtual Gfx::CullMode GetCullMode();
+
+    virtual void SetShadeModel(Gfx::ShadeModel model);
+    virtual Gfx::ShadeModel GetShadeModel();
+
+    virtual void SetFillMode(Gfx::FillMode mode) ;
+    virtual Gfx::FillMode GetFillMode();
+
+private:
+    //! Updates internal modelview matrix
+    void UpdateModelviewMatrix();
+    //! Updates position for given light based on transformation matrices
+    void UpdateLightPosition(int index);
+
+private:
+    //! Current config
+    Gfx::GLDeviceConfig m_config;
+    //! Was initialized?
+    bool m_wasInit;
+    //! Last encountered error
+    std::string m_error;
+
+    //! Current world matrix
+    Math::Matrix m_worldMat;
+    //! Current view matrix
+    Math::Matrix m_viewMat;
+    //! OpenGL modelview matrix = world matrix * view matrix
+    Math::Matrix m_modelviewMat;
+    //! Current projection matrix
+    Math::Matrix m_projectionMat;
+
+    //! The current material
+    Gfx::Material m_material;
+
+    //! Whether lighting is enabled
+    bool m_lighting;
+    //! Current lights
+    std::vector<Gfx::Light> m_lights;
+    //! Current lights enable status
+    std::vector<bool> m_lightsEnabled;
+
+    //! Whether texturing is enabled in general
+    bool m_texturing;
+    //! Current textures; \c NULL value means unassigned
+    std::vector<Gfx::Texture> m_currentTextures;
+    //! Current texture stages enable status
+    std::vector<bool> m_texturesEnabled;
+    //! Current texture params
+    std::vector<Gfx::TextureStageParams> m_textureStageParams;
+
+    //! Set of all created textures
+    std::set<Gfx::Texture> m_allTextures;
 };
 
 }; // namespace Gfx
diff --git a/src/graphics/opengl/glengine.cpp b/src/graphics/opengl/glengine.cpp
deleted file mode 100644
index 9aab348..0000000
--- a/src/graphics/opengl/glengine.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// glengine.h
-
-#include "graphics/opengl/glengine.h"
-
-// TODO
\ No newline at end of file
diff --git a/src/graphics/opengl/glengine.h b/src/graphics/opengl/glengine.h
deleted file mode 100644
index fa67bfe..0000000
--- a/src/graphics/opengl/glengine.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// * This file is part of the COLOBOT source code
-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
-// *
-// * 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  http://www.gnu.org/licenses/.
-
-// glengine.h
-
-#pragma once
-
-
-#include "graphics/common/engine.h"
-
-namespace Gfx
-{
-
-class CGLEngine : public Gfx::CEngine
-{
-  // TODO
-};
-
-};
diff --git a/src/graphics/opengl/test/CMakeLists.txt b/src/graphics/opengl/test/CMakeLists.txt
new file mode 100644
index 0000000..8ed7364
--- /dev/null
+++ b/src/graphics/opengl/test/CMakeLists.txt
@@ -0,0 +1,87 @@
+cmake_minimum_required(VERSION 2.8)
+
+find_package(OpenGL REQUIRED)
+find_package(SDL REQUIRED)
+find_package(SDL_image REQUIRED)
+find_package(PNG REQUIRED)
+
+set(CMAKE_BUILD_TYPE debug)
+set(CMAKE_CXX_FLAGS_DEBUG "-Wall -g -O0")
+
+set(ADD_LIBS "")
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+  set(PLATFORM_WINDOWS 1)
+  set(PLATFORM_LINUX   0)
+  set(PLATFORM_OTHER   0)
+elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  set(PLATFORM_WINDOWS 0)
+  set(PLATFORM_LINUX   1)
+  set(PLATFORM_OTHER   0)
+  set(ADD_LIBS "-lrt")
+else()
+  set(PLATFORM_WINDOWS 0)
+  set(PLATFORM_LINUX   0)
+  set(PLATFORM_OTHER   1)
+endif()
+
+configure_file(../../../common/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/common/config.h)
+
+
+set(TEXTURE_SOURCES
+../gldevice.cpp
+../../../common/logger.cpp
+../../../common/image.cpp
+texture_test.cpp
+)
+
+set(MODEL_SOURCES
+../gldevice.cpp
+../../engine/modelfile.cpp
+../../../common/logger.cpp
+../../../common/image.cpp
+../../../common/iman.cpp
+../../../common/stringutils.cpp
+../../../app/system.cpp
+model_test.cpp
+)
+
+set(TRANSFORM_SOURCES
+../gldevice.cpp
+../../../common/logger.cpp
+../../../common/image.cpp
+../../../common/iman.cpp
+../../../app/system.cpp
+transform_test.cpp
+)
+
+set(LIGHT_SOURCES
+../gldevice.cpp
+../../../common/logger.cpp
+../../../common/image.cpp
+../../../common/iman.cpp
+../../../app/system.cpp
+light_test.cpp
+)
+
+include_directories(../../../ ${CMAKE_CURRENT_BINARY_DIR})
+
+set(LIBS
+${SDL_LIBRARY}
+${SDLIMAGE_LIBRARY}
+${OPENGL_LIBRARY}
+${PNG_LIBRARIES}
+${ADD_LIBS}
+)
+
+add_executable(texture_test ${TEXTURE_SOURCES})
+target_link_libraries(texture_test ${LIBS})
+
+add_executable(model_test ${MODEL_SOURCES})
+target_link_libraries(model_test ${LIBS})
+
+add_executable(transform_test ${TRANSFORM_SOURCES})
+target_link_libraries(transform_test ${LIBS})
+
+add_executable(light_test ${LIGHT_SOURCES})
+target_link_libraries(light_test ${LIBS})
diff --git a/src/graphics/opengl/test/README.txt b/src/graphics/opengl/test/README.txt
new file mode 100644
index 0000000..c618415
--- /dev/null
+++ b/src/graphics/opengl/test/README.txt
@@ -0,0 +1,9 @@
+Test programs for OpenGL engine:
+  - texture_test -> multitexturing test with 2 textures (included as files: ./tex1.png, ./tex2.png)
+  - model_test -> simple model viewer to test model loading
+    usage: ./model_test {dxf|mod} model_file
+      second argument is the loaded format (DXF or Colobot .mod files)
+    requires ./tex folder (or symlink) with Colobot textures
+    viewer is controlled from keyboard - the bindings can be found in code
+  - transform_test -> simple "walk around" test for world & view transformations
+  - light test -> test for lighting
diff --git a/src/graphics/opengl/test/light_test.cpp b/src/graphics/opengl/test/light_test.cpp
new file mode 100644
index 0000000..80fa911
--- /dev/null
+++ b/src/graphics/opengl/test/light_test.cpp
@@ -0,0 +1,437 @@
+#include "app/system.h"
+#include "common/logger.h"
+#include "common/image.h"
+#include "common/iman.h"
+#include "graphics/opengl/gldevice.h"
+#include "math/geometry.h"
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <map>
+
+enum KeySlots
+{
+    K_Forward,
+    K_Back,
+    K_Left,
+    K_Right,
+    K_Up,
+    K_Down,
+    K_Count
+};
+bool KEYMAP[K_Count] = { false };
+
+Math::Point MOUSE_POS_BASE;
+
+Math::Vector TRANSLATION(0.0f, 2.0f, 0.0f);
+Math::Vector ROTATION, ROTATION_BASE;
+
+float CUBE_ORBIT = 0.0f;
+
+const int FRAME_DELAY = 5000;
+
+SystemTimeStamp *PREV_TIME = NULL, *CURR_TIME = NULL;
+
+void Init(Gfx::CGLDevice *device)
+{
+    device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, true);
+    device->SetShadeModel(Gfx::SHADE_SMOOTH);
+}
+
+void Render(Gfx::CGLDevice *device)
+{
+    device->BeginScene();
+
+    /* Unlit part of scene */
+
+    device->SetRenderState(Gfx::RENDER_STATE_LIGHTING, false);
+    device->SetRenderState(Gfx::RENDER_STATE_CULLING, false); // Double-sided drawing
+
+    Math::Matrix persp;
+    Math::LoadProjectionMatrix(persp, Math::PI / 4.0f, (800.0f) / (600.0f), 0.1f, 100.0f);
+    device->SetTransform(Gfx::TRANSFORM_PROJECTION, persp);
+
+
+    Math::Matrix viewMat;
+    Math::Matrix mat;
+
+    viewMat.LoadIdentity();
+
+    Math::LoadRotationXMatrix(mat, -ROTATION.x);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    Math::LoadRotationYMatrix(mat, -ROTATION.y);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    Math::LoadTranslationMatrix(mat, -TRANSLATION);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    device->SetTransform(Gfx::TRANSFORM_VIEW, viewMat);
+
+    Math::Matrix worldMat;
+    worldMat.LoadIdentity();
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    Gfx::VertexCol line[2] = { Gfx::VertexCol() };
+
+    for (int x = -40; x <= 40; ++x)
+    {
+        line[0].color = Gfx::Color(0.7f + x / 120.0f, 0.0f, 0.0f);
+        line[0].coord.z = -40;
+        line[0].coord.x = x;
+        line[1].color = Gfx::Color(0.7f + x / 120.0f, 0.0f, 0.0f);
+        line[1].coord.z =  40;
+        line[1].coord.x = x;
+        device->DrawPrimitive(Gfx::PRIMITIVE_LINES, line, 2);
+    }
+
+    for (int z = -40; z <= 40; ++z)
+    {
+        line[0].color = Gfx::Color(0.0f, 0.7f + z / 120.0f, 0.0f);
+        line[0].coord.z = z;
+        line[0].coord.x = -40;
+        line[1].color = Gfx::Color(0.0f, 0.7f + z / 120.0f, 0.0f);
+        line[1].coord.z = z;
+        line[1].coord.x =  40;
+        device->DrawPrimitive(Gfx::PRIMITIVE_LINES, line, 2);
+    }
+
+
+    Gfx::VertexCol quad[6] = { Gfx::VertexCol() };
+
+    quad[0].coord = Math::Vector(-1.0f, -1.0f, 0.0f);
+    quad[1].coord = Math::Vector( 1.0f, -1.0f, 0.0f);
+    quad[2].coord = Math::Vector(-1.0f,  1.0f, 0.0f);
+    quad[3].coord = Math::Vector( 1.0f,  1.0f, 0.0f);
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(1.0f, 1.0f, 0.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(40.0f, 2.0f, 40.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, quad, 4);
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(0.0f, 1.0f, 1.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(-40.0f, 2.0f, -40.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, quad, 4);
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(1.0f, 0.0f, 1.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(10.0f, 4.5f, 5.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, quad, 4);
+
+    /* Moving lit cube */
+    device->SetRenderState(Gfx::RENDER_STATE_LIGHTING, true);
+    device->SetRenderState(Gfx::RENDER_STATE_CULLING, true); // Culling (CCW faces)
+
+    device->SetGlobalAmbient(Gfx::Color(0.4f, 0.4f, 0.4f));
+
+    Gfx::Light light1;
+    light1.type = Gfx::LIGHT_POINT;
+    light1.position = Math::Vector(10.0f, 4.5f, 5.0f);
+    light1.ambient = Gfx::Color(0.2f, 0.2f, 0.2f);
+    light1.diffuse = Gfx::Color(1.0f, 0.1f, 0.1f);
+    light1.specular = Gfx::Color(0.0f, 0.0f, 0.0f);
+    device->SetLight(0, light1);
+    device->SetLightEnabled(0, true);
+
+    /*Gfx::Light light2;
+    device->SetLight(1, light2);
+    device->SetLightEnabled(1, true);*/
+
+    Gfx::Material material;
+    material.ambient = Gfx::Color(0.3f, 0.3f, 0.3f);
+    material.diffuse = Gfx::Color(0.8f, 0.7f, 0.6f);
+    material.specular = Gfx::Color(0.0f, 0.0f, 0.0f);
+    device->SetMaterial(material);
+
+    const Gfx::Vertex cube[6][4] =
+    {
+        {
+            // Front
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f, -1.0f), Math::Vector( 0.0f,  0.0f, -1.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f, -1.0f), Math::Vector( 0.0f,  0.0f, -1.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f, -1.0f), Math::Vector( 0.0f,  0.0f, -1.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f, -1.0f), Math::Vector( 0.0f,  0.0f, -1.0f))
+        },
+
+        {
+            // Back
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f,  1.0f), Math::Vector( 0.0f,  0.0f,  1.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f,  1.0f), Math::Vector( 0.0f,  0.0f,  1.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f,  1.0f), Math::Vector( 0.0f,  0.0f,  1.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f,  1.0f), Math::Vector( 0.0f,  0.0f,  1.0f))
+        },
+
+        {
+            // Top
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f, -1.0f), Math::Vector( 0.0f,  1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f, -1.0f), Math::Vector( 0.0f,  1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f,  1.0f), Math::Vector( 0.0f,  1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f,  1.0f), Math::Vector( 0.0f,  1.0f,  0.0f))
+        },
+
+        {
+            // Bottom
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f,  1.0f), Math::Vector( 0.0f, -1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f,  1.0f), Math::Vector( 0.0f, -1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f, -1.0f), Math::Vector( 0.0f, -1.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f, -1.0f), Math::Vector( 0.0f, -1.0f,  0.0f))
+        },
+
+        {
+            // Left
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f,  1.0f), Math::Vector(-1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f, -1.0f, -1.0f), Math::Vector(-1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f,  1.0f), Math::Vector(-1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector(-1.0f,  1.0f, -1.0f), Math::Vector(-1.0f,  0.0f,  0.0f))
+        },
+
+        {
+            // Right
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f, -1.0f), Math::Vector( 1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f, -1.0f,  1.0f), Math::Vector( 1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f, -1.0f), Math::Vector( 1.0f,  0.0f,  0.0f)),
+            Gfx::Vertex(Math::Vector( 1.0f,  1.0f,  1.0f), Math::Vector( 1.0f,  0.0f,  0.0f))
+        }
+    };
+
+    Math::Matrix cubeTrans;
+    Math::LoadTranslationMatrix(cubeTrans, Math::Vector(10.0f, 2.0f, 5.0f));
+    Math::Matrix cubeRot;
+    Math::LoadRotationMatrix(cubeRot, Math::Vector(0.0f, 1.0f, 0.0f), CUBE_ORBIT);
+    Math::Matrix cubeRotInv;
+    Math::LoadRotationMatrix(cubeRotInv, Math::Vector(0.0f, 1.0f, 0.0f), -CUBE_ORBIT);
+    Math::Matrix cubeTransRad;
+    Math::LoadTranslationMatrix(cubeTransRad, Math::Vector(0.0f, 0.0f, 6.0f));
+    worldMat = Math::MultiplyMatrices(cubeTransRad, cubeRotInv);
+    worldMat = Math::MultiplyMatrices(cubeRot, worldMat);
+    worldMat = Math::MultiplyMatrices(cubeTrans, worldMat);
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    for (int i = 0; i < 6; ++i)
+        device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, cube[i], 4);
+
+    device->EndScene();
+}
+
+void Update()
+{
+    const float TRANS_SPEED =  6.0f; // units / sec
+
+    GetCurrentTimeStamp(CURR_TIME);
+    float timeDiff = TimeStampDiff(PREV_TIME, CURR_TIME, STU_SEC);
+    CopyTimeStamp(PREV_TIME, CURR_TIME);
+
+    CUBE_ORBIT += timeDiff * (Math::PI / 4.0f);
+
+    Math::Vector incTrans;
+
+    if (KEYMAP[K_Forward])
+        incTrans.z = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Back])
+        incTrans.z = -TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Right])
+        incTrans.x = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Left])
+        incTrans.x = -TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Up])
+        incTrans.y = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Down])
+        incTrans.y = -TRANS_SPEED * timeDiff;
+
+    Math::Point rotTrans = Math::RotatePoint(-ROTATION.y, Math::Point(incTrans.x, incTrans.z));
+    incTrans.x = rotTrans.x;
+    incTrans.z = rotTrans.y;
+    TRANSLATION += incTrans;
+}
+
+void KeyboardDown(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_w:
+            KEYMAP[K_Forward] = true;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = true;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = true;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = true;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = true;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = true;
+            break;
+        default:
+            break;
+    }
+}
+
+void KeyboardUp(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_w:
+            KEYMAP[K_Forward] = false;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = false;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = false;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = false;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = false;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = false;
+            break;
+        default:
+            break;
+    }
+}
+
+void MouseMove(int x, int y)
+{
+    Math::Point currentPos((float)x, (float)y);
+
+    static bool first = true;
+    if (first || (x < 10) || (y < 10) || (x > 790) || (y > 590))
+    {
+        SDL_WarpMouse(400, 300);
+        MOUSE_POS_BASE.x = 400;
+        MOUSE_POS_BASE.y = 300;
+        ROTATION_BASE = ROTATION;
+        first = false;
+        return;
+    }
+
+    ROTATION.y = ROTATION_BASE.y + ((float) (x - MOUSE_POS_BASE.x) / 800.0f) * Math::PI;
+    ROTATION.x = ROTATION_BASE.x + ((float) (y - MOUSE_POS_BASE.y) / 600.0f) * Math::PI;
+}
+
+int main(int argc, char *argv[])
+{
+    CLogger logger;
+
+    PREV_TIME = CreateTimeStamp();
+    CURR_TIME = CreateTimeStamp();
+
+    GetCurrentTimeStamp(PREV_TIME);
+    GetCurrentTimeStamp(CURR_TIME);
+
+    CInstanceManager iMan;
+
+    // Without any error checking, for simplicity
+
+    SDL_Init(SDL_INIT_VIDEO);
+
+    IMG_Init(IMG_INIT_PNG);
+
+    const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+
+    Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
+
+    if (videoInfo->hw_available)
+        videoFlags |= SDL_HWSURFACE;
+    else
+        videoFlags |= SDL_SWSURFACE;
+
+    if (videoInfo->blit_hw)
+        videoFlags |= SDL_HWACCEL;
+
+
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags);
+
+
+    SDL_WM_SetCaption("Light Test", "Light Test");
+
+    //SDL_WM_GrabInput(SDL_GRAB_ON);
+    SDL_ShowCursor(SDL_DISABLE);
+
+    Gfx::CGLDevice *device = new Gfx::CGLDevice();
+    device->Create();
+
+    Init(device);
+
+    bool done = false;
+    while (! done)
+    {
+        Render(device);
+        Update();
+
+        SDL_GL_SwapBuffers();
+
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            if (event.type == SDL_QUIT)
+            {
+                break;
+                done = true;
+            }
+            else if (event.type == SDL_KEYDOWN)
+            {
+                if (event.key.keysym.sym == SDLK_q)
+                {
+                    done = true;
+                    break;
+                }
+                else
+                    KeyboardDown(event.key.keysym.sym);
+            }
+            else if (event.type == SDL_KEYUP)
+                KeyboardUp(event.key.keysym.sym);
+            else if (event.type == SDL_MOUSEMOTION)
+                MouseMove(event.motion.x, event.motion.y);
+        }
+
+        usleep(FRAME_DELAY);
+    }
+
+    //SDL_WM_GrabInput(SDL_GRAB_OFF);
+    SDL_ShowCursor(SDL_ENABLE);
+
+    device->Destroy();
+    delete device;
+
+    SDL_FreeSurface(surface);
+
+    IMG_Quit();
+
+    SDL_Quit();
+
+    DestroyTimeStamp(PREV_TIME);
+    DestroyTimeStamp(CURR_TIME);
+
+    return 0;
+}
diff --git a/src/graphics/opengl/test/model_test.cpp b/src/graphics/opengl/test/model_test.cpp
new file mode 100644
index 0000000..3e8efe6
--- /dev/null
+++ b/src/graphics/opengl/test/model_test.cpp
@@ -0,0 +1,377 @@
+#include "app/system.h"
+#include "common/logger.h"
+#include "common/image.h"
+#include "common/iman.h"
+#include "graphics/engine/modelfile.h"
+#include "graphics/opengl/gldevice.h"
+#include "math/geometry.h"
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <map>
+
+enum KeySlots
+{
+    K_RotXUp,
+    K_RotXDown,
+    K_RotYLeft,
+    K_RotYRight,
+    K_Forward,
+    K_Back,
+    K_Left,
+    K_Right,
+    K_Up,
+    K_Down,
+    K_Count
+};
+bool KEYMAP[K_Count] = { false };
+
+Math::Vector TRANSLATION(0.0f, 0.0f, 30.0f);
+Math::Vector ROTATION;
+
+const int FRAME_DELAY = 5000;
+
+std::map<std::string, Gfx::Texture> TEXS;
+
+SystemTimeStamp *PREV_TIME = NULL, *CURR_TIME = NULL;
+
+Gfx::Texture GetTexture(const std::string &name)
+{
+    std::map<std::string, Gfx::Texture>::iterator it = TEXS.find(name);
+    if (it == TEXS.end())
+        return Gfx::Texture();
+
+    return (*it).second;
+}
+
+void LoadTexture(Gfx::CGLDevice *device, const std::string &name)
+{
+    if (name.empty())
+        return;
+
+    Gfx::Texture tex = GetTexture(name);
+
+    if (tex.valid)
+        return;
+
+    CImage img;
+    if (! img.Load(std::string("tex/") + name))
+    {
+        std::string err = img.GetError();
+        GetLogger()->Error("Texture not loaded, error: %s!\n", err.c_str());
+    }
+    else
+    {
+        Gfx::TextureCreateParams texCreateParams;
+        texCreateParams.mipmap = true;
+        if (img.GetData()->surface->format->Amask == 0)
+            texCreateParams.format = Gfx::TEX_IMG_BGR;
+        else
+            texCreateParams.format = Gfx::TEX_IMG_BGRA;
+        texCreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR;
+        texCreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR;
+
+        tex = device->CreateTexture(&img, texCreateParams);
+    }
+
+    TEXS[name] = tex;
+}
+
+void Init(Gfx::CGLDevice *device, Gfx::CModelFile *model)
+{
+    std::vector<Gfx::ModelTriangle> &triangles = model->GetTriangles();
+
+    for (int i = 0; i < (int) triangles.size(); ++i)
+    {
+        LoadTexture(device, triangles[i].tex1Name);
+        LoadTexture(device, triangles[i].tex2Name);
+    }
+
+    device->SetRenderState(Gfx::RENDER_STATE_TEXTURING,  true);
+    device->SetRenderState(Gfx::RENDER_STATE_LIGHTING,   true);
+    device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, true);
+    device->SetShadeModel(Gfx::SHADE_SMOOTH);
+
+    Gfx::Light light;
+    light.type = Gfx::LIGHT_DIRECTIONAL;
+    light.ambient = Gfx::Color(0.4f, 0.4f, 0.4f, 0.0f);
+    light.diffuse = Gfx::Color(0.8f, 0.8f, 0.8f, 0.0f);
+    light.specular = Gfx::Color(0.2f, 0.2f, 0.2f, 0.0f);
+    light.position = Math::Vector(0.0f, 0.0f, -1.0f);
+    light.direction = Math::Vector(0.0f, 0.0f, 1.0f);
+
+    device->SetGlobalAmbient(Gfx::Color(0.5f, 0.5f, 0.5f, 0.0f));
+    device->SetLight(0, light);
+    device->SetLightEnabled(0, true);
+}
+
+void Render(Gfx::CGLDevice *device, Gfx::CModelFile *modelFile)
+{
+    device->BeginScene();
+
+    Math::Matrix persp;
+    Math::LoadProjectionMatrix(persp, Math::PI / 4.0f, (800.0f) / (600.0f), 0.1f, 100.0f);
+    device->SetTransform(Gfx::TRANSFORM_PROJECTION, persp);
+
+    Math::Matrix id;
+    id.LoadIdentity();
+    device->SetTransform(Gfx::TRANSFORM_WORLD, id);
+
+    Math::Matrix viewMat;
+    Math::LoadTranslationMatrix(viewMat, TRANSLATION);
+    Math::Matrix rot;
+    Math::LoadRotationXZYMatrix(rot, ROTATION);
+    viewMat = Math::MultiplyMatrices(viewMat, rot);
+    device->SetTransform(Gfx::TRANSFORM_VIEW, viewMat);
+
+    std::vector<Gfx::ModelTriangle> &triangles = modelFile->GetTriangles();
+
+    Gfx::VertexTex2 tri[3];
+
+    for (int i = 0; i < (int) triangles.size(); ++i)
+    {
+        device->SetTexture(0, GetTexture(triangles[i].tex1Name));
+        device->SetTexture(1, GetTexture(triangles[i].tex2Name));
+        device->SetTextureEnabled(0, true);
+        device->SetTextureEnabled(1, true);
+
+        device->SetMaterial(triangles[i].material);
+
+        tri[0] = triangles[i].p1;
+        tri[1] = triangles[i].p2;
+        tri[2] = triangles[i].p3;
+
+        device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, tri, 3);
+    }
+
+    device->EndScene();
+}
+
+void Update()
+{
+    const float ROT_SPEED = 80.0f * Math::DEG_TO_RAD; // rad / sec
+    const float TRANS_SPEED =  3.0f; // units / sec
+
+    GetCurrentTimeStamp(CURR_TIME);
+    float timeDiff = TimeStampDiff(PREV_TIME, CURR_TIME, STU_SEC);
+    CopyTimeStamp(PREV_TIME, CURR_TIME);
+
+    if (KEYMAP[K_RotYLeft])
+        ROTATION.y -= ROT_SPEED * timeDiff;
+    if (KEYMAP[K_RotYRight])
+        ROTATION.y += ROT_SPEED * timeDiff;
+    if (KEYMAP[K_RotXDown])
+        ROTATION.x -= ROT_SPEED * timeDiff;
+    if (KEYMAP[K_RotXUp])
+        ROTATION.x += ROT_SPEED * timeDiff;
+
+    if (KEYMAP[K_Forward])
+        TRANSLATION.z -= TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Back])
+        TRANSLATION.z += TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Left])
+        TRANSLATION.x += TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Right])
+        TRANSLATION.x -= TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Up])
+        TRANSLATION.y += TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Down])
+        TRANSLATION.y -= TRANS_SPEED * timeDiff;
+}
+
+void KeyboardDown(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_LEFT:
+            KEYMAP[K_RotYLeft] = true;
+            break;
+        case SDLK_RIGHT:
+            KEYMAP[K_RotYRight] = true;
+            break;
+        case SDLK_UP:
+            KEYMAP[K_RotXUp] = true;
+            break;
+        case SDLK_DOWN:
+            KEYMAP[K_RotXDown] = true;
+            break;
+        case SDLK_w:
+            KEYMAP[K_Forward] = true;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = true;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = true;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = true;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = true;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = true;
+            break;
+        default:
+            break;
+    }
+}
+
+void KeyboardUp(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_LEFT:
+            KEYMAP[K_RotYLeft] = false;
+            break;
+        case SDLK_RIGHT:
+            KEYMAP[K_RotYRight] = false;
+            break;
+        case SDLK_UP:
+            KEYMAP[K_RotXUp] = false;
+            break;
+        case SDLK_DOWN:
+            KEYMAP[K_RotXDown] = false;
+            break;
+        case SDLK_w:
+            KEYMAP[K_Forward] = false;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = false;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = false;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = false;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = false;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = false;
+            break;
+        default:
+            break;
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    CLogger logger;
+
+    PREV_TIME = CreateTimeStamp();
+    CURR_TIME = CreateTimeStamp();
+
+    GetCurrentTimeStamp(PREV_TIME);
+    GetCurrentTimeStamp(CURR_TIME);
+
+    if (argc != 3)
+    {
+        std::cerr << "Usage: " << argv[0] << "{mod|dxf} model_file" << std::endl;
+        return 1;
+    }
+
+    CInstanceManager iMan;
+
+    Gfx::CModelFile *modelFile = new Gfx::CModelFile(&iMan);
+    if (std::string(argv[1]) == "mod")
+    {
+        if (! modelFile->ReadModel(argv[2], false, false))
+        {
+            std::cerr << "Error reading MOD: " << modelFile->GetError() << std::endl;
+            return 1;
+        }
+    }
+    else if (std::string(argv[1]) == "dxf")
+    {
+        if (! modelFile->ReadDXF(argv[2], 0.0f, 0.0f))
+        {
+            std::cerr << "Error reading DXF: " << modelFile->GetError() << std::endl;
+            return 1;
+        }
+    }
+    else
+    {
+        std::cerr << "Usage: " << argv[0] << "{mod|dxf} model_file" << std::endl;
+        return 1;
+    }
+
+    // Without any error checking, for simplicity
+
+    SDL_Init(SDL_INIT_VIDEO);
+
+    IMG_Init(IMG_INIT_PNG);
+
+    const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+
+    Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
+
+    if (videoInfo->hw_available)
+        videoFlags |= SDL_HWSURFACE;
+    else
+        videoFlags |= SDL_SWSURFACE;
+
+    if (videoInfo->blit_hw)
+        videoFlags |= SDL_HWACCEL;
+
+
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags);
+
+
+    SDL_WM_SetCaption("Model Test", "Model Test");
+
+    Gfx::CGLDevice *device = new Gfx::CGLDevice();
+    device->Create();
+
+    Init(device, modelFile);
+
+    bool done = false;
+    while (! done)
+    {
+        Render(device, modelFile);
+        Update();
+
+        SDL_GL_SwapBuffers();
+
+        SDL_Event event;
+        SDL_PollEvent(&event);
+        if (event.type == SDL_QUIT)
+            done = true;
+        else if (event.type == SDL_KEYDOWN)
+            KeyboardDown(event.key.keysym.sym);
+        else if (event.type == SDL_KEYUP)
+            KeyboardUp(event.key.keysym.sym);
+
+        usleep(FRAME_DELAY);
+    }
+
+    delete modelFile;
+
+    device->Destroy();
+    delete device;
+
+    SDL_FreeSurface(surface);
+
+    IMG_Quit();
+
+    SDL_Quit();
+
+    DestroyTimeStamp(PREV_TIME);
+    DestroyTimeStamp(CURR_TIME);
+
+    return 0;
+}
diff --git a/src/graphics/opengl/test/tex1.png b/src/graphics/opengl/test/tex1.png
new file mode 100644
index 0000000..46c68a0
--- /dev/null
+++ b/src/graphics/opengl/test/tex1.png
diff --git a/src/graphics/opengl/test/tex2.png b/src/graphics/opengl/test/tex2.png
new file mode 100644
index 0000000..ebdae0d
--- /dev/null
+++ b/src/graphics/opengl/test/tex2.png
diff --git a/src/graphics/opengl/test/texture_test.cpp b/src/graphics/opengl/test/texture_test.cpp
new file mode 100644
index 0000000..c3c568b
--- /dev/null
+++ b/src/graphics/opengl/test/texture_test.cpp
@@ -0,0 +1,193 @@
+#include "common/logger.h"
+#include "common/image.h"
+#include "graphics/opengl/gldevice.h"
+#include "math/geometry.h"
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <unistd.h>
+
+
+void Init(Gfx::CGLDevice *device)
+{
+    device->SetShadeModel(Gfx::SHADE_SMOOTH);
+
+    device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, false);
+    device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
+
+    device->SetTextureEnabled(0, true);
+    device->SetTextureEnabled(1, true);
+
+    CImage img1;
+    if (! img1.Load("tex1.png"))
+    {
+        std::string err = img1.GetError();
+        GetLogger()->Error("texture 1 not loaded, error: %d!\n", err.c_str());
+    }
+    CImage img2;
+    if (! img2.Load("tex2.png"))
+    {
+        std::string err = img2.GetError();
+        GetLogger()->Error("texture 2 not loaded, error: %d!\n", err.c_str());
+    }
+
+    Gfx::TextureCreateParams tex1CreateParams;
+    tex1CreateParams.mipmap = true;
+    tex1CreateParams.format = Gfx::TEX_IMG_RGBA;
+    tex1CreateParams.minFilter = Gfx::TEX_MIN_FILTER_LINEAR_MIPMAP_LINEAR;
+    tex1CreateParams.magFilter = Gfx::TEX_MAG_FILTER_LINEAR;
+
+    Gfx::TextureCreateParams tex2CreateParams;
+    tex2CreateParams.mipmap = true;
+    tex2CreateParams.format = Gfx::TEX_IMG_RGBA;
+    tex2CreateParams.minFilter = Gfx::TEX_MIN_FILTER_NEAREST_MIPMAP_NEAREST;
+    tex2CreateParams.magFilter = Gfx::TEX_MAG_FILTER_NEAREST;
+
+    Gfx::Texture tex1 = device->CreateTexture(&img1, tex1CreateParams);
+    Gfx::Texture tex2 = device->CreateTexture(&img2, tex2CreateParams);
+
+    device->SetTexture(0, tex1);
+    device->SetTexture(1, tex2);
+}
+
+void Render(Gfx::CGLDevice *device)
+{
+    device->BeginScene();
+
+    Math::Matrix ortho;
+    Math::LoadOrthoProjectionMatrix(ortho, -10, 10, -10, 10);
+    device->SetTransform(Gfx::TRANSFORM_PROJECTION, ortho);
+
+    Math::Matrix id;
+    id.LoadIdentity();
+
+    device->SetTransform(Gfx::TRANSFORM_WORLD, id);
+    device->SetTransform(Gfx::TRANSFORM_VIEW, id);
+
+    static Gfx::VertexTex2 quad[] =
+    {
+        Gfx::VertexTex2(Math::Vector(-2.0f,  2.0f, 0.0f), Math::Vector(), Math::Point(0.0f, 0.0f), Math::Point(0.0f, 0.0f)),
+        Gfx::VertexTex2(Math::Vector( 2.0f,  2.0f, 0.0f), Math::Vector(), Math::Point(1.0f, 0.0f), Math::Point(1.0f, 0.0f)),
+        Gfx::VertexTex2(Math::Vector( 2.0f, -2.0f, 0.0f), Math::Vector(), Math::Point(1.0f, 1.0f), Math::Point(1.0f, 1.0f)),
+
+        Gfx::VertexTex2(Math::Vector( 2.0f, -2.0f, 0.0f), Math::Vector(), Math::Point(1.0f, 1.0f), Math::Point(1.0f, 1.0f)),
+        Gfx::VertexTex2(Math::Vector(-2.0f, -2.0f, 0.0f), Math::Vector(), Math::Point(0.0f, 1.0f), Math::Point(0.0f, 1.0f)),
+        Gfx::VertexTex2(Math::Vector(-2.0f,  2.0f, 0.0f), Math::Vector(), Math::Point(0.0f, 0.0f), Math::Point(0.0f, 0.0f)),
+    };
+
+    Gfx::TextureStageParams tex1StageParams;
+    tex1StageParams.colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    tex1StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    device->SetTextureStageParams(0, tex1StageParams);
+
+    Gfx::TextureStageParams tex2StageParams;
+    tex2StageParams.colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    tex2StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    device->SetTextureStageParams(1, tex2StageParams);
+
+    Math::Matrix t;
+    Math::LoadTranslationMatrix(t, Math::Vector(-4.0f, 4.0f, 0.0f));
+    device->SetTransform(Gfx::TRANSFORM_VIEW, t);
+
+    device->SetTextureEnabled(0, true);
+    device->SetTextureEnabled(1, false);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    Math::LoadTranslationMatrix(t, Math::Vector( 4.0f, 4.0f, 0.0f));
+    device->SetTransform(Gfx::TRANSFORM_VIEW, t);
+
+    device->SetTextureEnabled(0, false);
+    device->SetTextureEnabled(1, true);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    Math::LoadTranslationMatrix(t, Math::Vector( 0.0f, -4.0f, 0.0f));
+    device->SetTransform(Gfx::TRANSFORM_VIEW, t);
+
+    device->SetTextureEnabled(0, true);
+    device->SetTextureEnabled(1, true);
+
+    tex1StageParams.colorOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    tex1StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    device->SetTextureStageParams(0, tex1StageParams);
+
+    tex2StageParams.colorOperation = Gfx::TEX_MIX_OPER_ADD;
+    tex2StageParams.colorArg1 = Gfx::TEX_MIX_ARG_COMPUTED_COLOR;
+    tex2StageParams.colorArg2 = Gfx::TEX_MIX_ARG_TEXTURE;
+    tex2StageParams.alphaOperation = Gfx::TEX_MIX_OPER_DEFAULT;
+    device->SetTextureStageParams(1, tex2StageParams);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    device->EndScene();
+}
+
+int main()
+{
+    CLogger();
+
+    // Without any error checking, for simplicity
+
+    SDL_Init(SDL_INIT_VIDEO);
+
+    IMG_Init(IMG_INIT_PNG);
+
+    const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+
+    Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
+
+    if (videoInfo->hw_available)
+        videoFlags |= SDL_HWSURFACE;
+    else
+        videoFlags |= SDL_SWSURFACE;
+
+    if (videoInfo->blit_hw)
+        videoFlags |= SDL_HWACCEL;
+
+
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags);
+
+
+    SDL_WM_SetCaption("Texture Test", "Texture Test");
+
+    Gfx::CGLDevice *device = new Gfx::CGLDevice();
+    device->Create();
+
+    Init(device);
+
+    bool done = false;
+    while (! done)
+    {
+        Render(device);
+
+        SDL_GL_SwapBuffers();
+
+        SDL_Event event;
+        SDL_PollEvent(&event);
+        if (event.type == SDL_QUIT)
+            done = true;
+
+        usleep(10000);
+    }
+
+    device->Destroy();
+    delete device;
+
+    SDL_FreeSurface(surface);
+
+    IMG_Quit();
+
+    SDL_Quit();
+
+    return 0;
+}
diff --git a/src/graphics/opengl/test/transform_test.cpp b/src/graphics/opengl/test/transform_test.cpp
new file mode 100644
index 0000000..83819b8
--- /dev/null
+++ b/src/graphics/opengl/test/transform_test.cpp
@@ -0,0 +1,339 @@
+#include "app/system.h"
+#include "common/logger.h"
+#include "common/image.h"
+#include "common/iman.h"
+#include "graphics/opengl/gldevice.h"
+#include "math/geometry.h"
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_image.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <map>
+
+enum KeySlots
+{
+    K_Forward,
+    K_Back,
+    K_Left,
+    K_Right,
+    K_Up,
+    K_Down,
+    K_Count
+};
+bool KEYMAP[K_Count] = { false };
+
+Math::Point MOUSE_POS_BASE;
+
+Math::Vector TRANSLATION(0.0f, 2.0f, 0.0f);
+Math::Vector ROTATION, ROTATION_BASE;
+
+const int FRAME_DELAY = 5000;
+
+SystemTimeStamp *PREV_TIME = NULL, *CURR_TIME = NULL;
+
+void Init(Gfx::CGLDevice *device)
+{
+    device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, true);
+    device->SetShadeModel(Gfx::SHADE_SMOOTH);
+}
+
+void Render(Gfx::CGLDevice *device)
+{
+    device->BeginScene();
+
+    Math::Matrix persp;
+    Math::LoadProjectionMatrix(persp, Math::PI / 4.0f, (800.0f) / (600.0f), 0.1f, 100.0f);
+    device->SetTransform(Gfx::TRANSFORM_PROJECTION, persp);
+
+
+    Math::Matrix viewMat;
+    Math::Matrix mat;
+
+    viewMat.LoadIdentity();
+
+    Math::LoadRotationXMatrix(mat, -ROTATION.x);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    Math::LoadRotationYMatrix(mat, -ROTATION.y);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    Math::LoadTranslationMatrix(mat, -TRANSLATION);
+    viewMat = Math::MultiplyMatrices(viewMat, mat);
+
+    device->SetTransform(Gfx::TRANSFORM_VIEW, viewMat);
+
+
+    Math::Matrix worldMat;
+    worldMat.LoadIdentity();
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    Gfx::VertexCol line[2] = { Gfx::VertexCol() };
+
+    for (int x = -40; x <= 40; ++x)
+    {
+        line[0].color = Gfx::Color(0.7f + x / 120.0f, 0.0f, 0.0f);
+        line[0].coord.z = -40;
+        line[0].coord.x = x;
+        line[1].color = Gfx::Color(0.7f + x / 120.0f, 0.0f, 0.0f);
+        line[1].coord.z =  40;
+        line[1].coord.x = x;
+        device->DrawPrimitive(Gfx::PRIMITIVE_LINES, line, 2);
+    }
+
+    for (int z = -40; z <= 40; ++z)
+    {
+        line[0].color = Gfx::Color(0.0f, 0.7f + z / 120.0f, 0.0f);
+        line[0].coord.z = z;
+        line[0].coord.x = -40;
+        line[1].color = Gfx::Color(0.0f, 0.7f + z / 120.0f, 0.0f);
+        line[1].coord.z = z;
+        line[1].coord.x =  40;
+        device->DrawPrimitive(Gfx::PRIMITIVE_LINES, line, 2);
+    }
+
+
+    Gfx::VertexCol quad[6] = { Gfx::VertexCol() };
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(1.0f, 1.0f, 0.0f);
+
+    quad[0].coord = Math::Vector(-1.0f, -1.0f, 0.0f);
+    quad[1].coord = Math::Vector( 1.0f, -1.0f, 0.0f);
+    quad[2].coord = Math::Vector( 1.0f,  1.0f, 0.0f);
+    quad[3].coord = Math::Vector( 1.0f,  1.0f, 0.0f);
+    quad[4].coord = Math::Vector(-1.0f,  1.0f, 0.0f);
+    quad[5].coord = Math::Vector(-1.0f, -1.0f, 0.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(40.0f, 2.0f, 40.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(0.0f, 1.0f, 1.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(-40.0f, 2.0f, -40.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    for (int i = 0; i < 6; ++i)
+        quad[i].color = Gfx::Color(1.0f, 0.0f, 1.0f);
+
+    Math::LoadTranslationMatrix(worldMat, Math::Vector(0.0f, 10.0f, 0.0f));
+    device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+
+    device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLES, quad, 6);
+
+    device->EndScene();
+}
+
+void Update()
+{
+    const float TRANS_SPEED =  6.0f; // units / sec
+
+    GetCurrentTimeStamp(CURR_TIME);
+    float timeDiff = TimeStampDiff(PREV_TIME, CURR_TIME, STU_SEC);
+    CopyTimeStamp(PREV_TIME, CURR_TIME);
+
+    Math::Vector incTrans;
+
+    if (KEYMAP[K_Forward])
+        incTrans.z = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Back])
+        incTrans.z = -TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Right])
+        incTrans.x = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Left])
+        incTrans.x = -TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Up])
+        incTrans.y = +TRANS_SPEED * timeDiff;
+    if (KEYMAP[K_Down])
+        incTrans.y = -TRANS_SPEED * timeDiff;
+
+    Math::Point rotTrans = Math::RotatePoint(-ROTATION.y, Math::Point(incTrans.x, incTrans.z));
+    incTrans.x = rotTrans.x;
+    incTrans.z = rotTrans.y;
+    TRANSLATION += incTrans;
+}
+
+void KeyboardDown(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_w:
+            KEYMAP[K_Forward] = true;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = true;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = true;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = true;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = true;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = true;
+            break;
+        default:
+            break;
+    }
+}
+
+void KeyboardUp(SDLKey key)
+{
+    switch (key)
+    {
+        case SDLK_w:
+            KEYMAP[K_Forward] = false;
+            break;
+        case SDLK_s:
+            KEYMAP[K_Back] = false;
+            break;
+        case SDLK_d:
+            KEYMAP[K_Right] = false;
+            break;
+        case SDLK_a:
+            KEYMAP[K_Left] = false;
+            break;
+        case SDLK_z:
+            KEYMAP[K_Down] = false;
+            break;
+        case SDLK_x:
+            KEYMAP[K_Up] = false;
+            break;
+        default:
+            break;
+    }
+}
+
+void MouseMove(int x, int y)
+{
+    Math::Point currentPos((float)x, (float)y);
+
+    static bool first = true;
+    if (first || (x < 10) || (y < 10) || (x > 790) || (y > 590))
+    {
+        SDL_WarpMouse(400, 300);
+        MOUSE_POS_BASE.x = 400;
+        MOUSE_POS_BASE.y = 300;
+        ROTATION_BASE = ROTATION;
+        first = false;
+        return;
+    }
+
+    ROTATION.y = ROTATION_BASE.y + ((float) (x - MOUSE_POS_BASE.x) / 800.0f) * Math::PI;
+    ROTATION.x = ROTATION_BASE.x + ((float) (y - MOUSE_POS_BASE.y) / 600.0f) * Math::PI;
+}
+
+int main(int argc, char *argv[])
+{
+    CLogger logger;
+
+    PREV_TIME = CreateTimeStamp();
+    CURR_TIME = CreateTimeStamp();
+
+    GetCurrentTimeStamp(PREV_TIME);
+    GetCurrentTimeStamp(CURR_TIME);
+
+    CInstanceManager iMan;
+
+    // Without any error checking, for simplicity
+
+    SDL_Init(SDL_INIT_VIDEO);
+
+    IMG_Init(IMG_INIT_PNG);
+
+    const SDL_VideoInfo *videoInfo = SDL_GetVideoInfo();
+
+    Uint32 videoFlags = SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_HWPALETTE;
+
+    if (videoInfo->hw_available)
+        videoFlags |= SDL_HWSURFACE;
+    else
+        videoFlags |= SDL_SWSURFACE;
+
+    if (videoInfo->blit_hw)
+        videoFlags |= SDL_HWACCEL;
+
+
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 8);
+
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+    SDL_Surface *surface = SDL_SetVideoMode(800, 600, 32, videoFlags);
+
+
+    SDL_WM_SetCaption("Transform Test", "Transform Test");
+
+    //SDL_WM_GrabInput(SDL_GRAB_ON);
+    SDL_ShowCursor(SDL_DISABLE);
+
+    Gfx::CGLDevice *device = new Gfx::CGLDevice();
+    device->Create();
+
+    Init(device);
+
+    bool done = false;
+    while (! done)
+    {
+        Render(device);
+        Update();
+
+        SDL_GL_SwapBuffers();
+
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            if (event.type == SDL_QUIT)
+            {
+                break;
+                done = true;
+            }
+            else if (event.type == SDL_KEYDOWN)
+            {
+                if (event.key.keysym.sym == SDLK_q)
+                {
+                    done = true;
+                    break;
+                }
+                else
+                    KeyboardDown(event.key.keysym.sym);
+            }
+            else if (event.type == SDL_KEYUP)
+                KeyboardUp(event.key.keysym.sym);
+            else if (event.type == SDL_MOUSEMOTION)
+                MouseMove(event.motion.x, event.motion.y);
+        }
+
+        usleep(FRAME_DELAY);
+    }
+
+    //SDL_WM_GrabInput(SDL_GRAB_OFF);
+    SDL_ShowCursor(SDL_ENABLE);
+
+    device->Destroy();
+    delete device;
+
+    SDL_FreeSurface(surface);
+
+    IMG_Quit();
+
+    SDL_Quit();
+
+    DestroyTimeStamp(PREV_TIME);
+    DestroyTimeStamp(CURR_TIME);
+
+    return 0;
+}
diff --git a/src/math/func.h b/src/math/func.h
index 8f0e4ab..2127d1a 100644
--- a/src/math/func.h
+++ b/src/math/func.h
@@ -34,15 +34,15 @@ namespace Math
 /* @{ */ // start of group
 
 //! Compares \a a and \a b within \a tolerance
-inline bool IsEqual(float a, float b, float tolerance = TOLERANCE)
+inline bool IsEqual(float a, float b, float tolerance = Math::TOLERANCE)
 {
     return fabs(a - b) < tolerance;
 }
 
 //! Compares \a a to zero within \a tolerance
-inline bool IsZero(float a, float tolerance = TOLERANCE)
+inline bool IsZero(float a, float tolerance = Math::TOLERANCE)
 {
-    return IsEqual(a, 0.0f, tolerance);
+    return Math::IsEqual(a, 0.0f, tolerance);
 }
 
 //! Minimum
@@ -59,12 +59,12 @@ inline float Min(float a, float b, float c)
 
 inline float Min(float a, float b, float c, float d)
 {
-    return Min( Min(a, b), Min(c, d) );
+    return Math::Min( Math::Min(a, b), Math::Min(c, d) );
 }
 
 inline float Min(float a, float b, float c, float d, float e)
 {
-    return Min( Min(a, b), Min(c, d), e );
+    return Math::Min( Math::Min(a, b), Math::Min(c, d), e );
 }
 
 //! Maximum
@@ -76,17 +76,17 @@ inline float Max(float a, float b)
 
 inline float Max(float a, float b, float c)
 {
-    return Max( Max(a, b), c );
+    return Math::Max( Math::Max(a, b), c );
 }
 
 inline float Max(float a, float b, float c, float d)
 {
-    return Max( Max(a, b), Max(c, d) );
+    return Math::Max( Math::Max(a, b), Math::Max(c, d) );
 }
 
 inline float Max(float a, float b, float c, float d, float e)
 {
-    return Max( Max(a, b), Max(c, d), e );
+    return Math::Max( Math::Max(a, b), Math::Max(c, d), e );
 }
 
 //! Returns the normalized value (0 .. 1)
@@ -118,19 +118,19 @@ inline void Swap(float &a, float &b)
         Mod(n, 1) = fractional part of n */
 inline float Mod(float a, float m)
 {
-    return a - ((int)(a/m))*m;
+    return a - ( static_cast<int>(a / m) ) * m;
 }
 
 //! Returns a random value between 0 and 1.
 inline float Rand()
 {
-    return (float)rand()/RAND_MAX;
+    return static_cast<float>(rand()) / static_cast<float>(RAND_MAX);
 }
 
 //! Returns a normalized angle, that is in other words between 0 and 2 * PI
 inline float NormAngle(float angle)
 {
-    angle = Mod(angle, PI*2.0f);
+    angle = Math::Mod(angle, PI*2.0f);
     if ( angle < 0.0f )
         return PI*2.0f + angle;
 
@@ -140,9 +140,9 @@ inline float NormAngle(float angle)
 //! Test if a angle is between two terminals
 inline bool TestAngle(float angle, float min, float max)
 {
-    angle = NormAngle(angle);
-    min   = NormAngle(min);
-    max   = NormAngle(max);
+    angle = Math::NormAngle(angle);
+    min   = Math::NormAngle(min);
+    max   = Math::NormAngle(max);
 
     if ( min > max )
         return ( angle <= max || angle >= min );
@@ -153,18 +153,18 @@ inline bool TestAngle(float angle, float min, float max)
 //! Calculates a value (radians) proportional between a and b (degrees)
 inline float PropAngle(int a, int b, float p)
 {
-    float aa = (float)a * DEG_TO_RAD;
-    float bb = (float)b * DEG_TO_RAD;
+    float aa = static_cast<float>(a) * DEG_TO_RAD;
+    float bb = static_cast<float>(b) * DEG_TO_RAD;
 
-    return aa+p*(bb-aa);
+    return aa + p * (bb - aa);
 }
 
 //! Calculates the angle to rotate the angle \a a to the angle \a g
 /** A positive angle is counterclockwise (CCW). */
 inline float Direction(float a, float g)
 {
-    a = NormAngle(a);
-    g = NormAngle(g);
+    a = Math::NormAngle(a);
+    g = Math::NormAngle(g);
 
     if ( a < g )
     {
diff --git a/src/math/geometry.h b/src/math/geometry.h
index 2f937e5..61d1868 100644
--- a/src/math/geometry.h
+++ b/src/math/geometry.h
@@ -40,7 +40,7 @@ namespace Math
 
 
 //! Returns py up on the line \a a - \a b
-inline float MidPoint(const Point &a, const Point &b, float px)
+inline float MidPoint(const Math::Point &a, const Math::Point &b, float px)
 {
     if (IsEqual(a.x, b.x))
     {
@@ -53,7 +53,7 @@ inline float MidPoint(const Point &a, const Point &b, float px)
 }
 
 //! Tests whether the point \a p is inside the triangle (\a a,\a b,\a c)
-inline bool IsInsideTriangle(Point a, Point b, Point c, Point p)
+inline bool IsInsideTriangle(Math::Point a, Math::Point b, Math::Point c, Math::Point p)
 {
     float n, m;
 
@@ -82,13 +82,13 @@ inline bool IsInsideTriangle(Point a, Point b, Point c, Point p)
 /** \a center center of rotation
     \a angle angle is in radians (positive is counterclockwise (CCW) )
     \a p the point */
-inline Point RotatePoint(const Point &center, float angle, const Point &p)
+inline Math::Point RotatePoint(const Math::Point &center, float angle, const Math::Point &p)
 {
-    Point a;
+    Math::Point a;
     a.x = p.x-center.x;
     a.y = p.y-center.y;
 
-    Point b;
+    Math::Point b;
     b.x = a.x*cosf(angle) - a.y*sinf(angle);
     b.y = a.x*sinf(angle) + a.y*cosf(angle);
 
@@ -101,23 +101,23 @@ inline Point RotatePoint(const Point &center, float angle, const Point &p)
 //! Rotates a point around the origin (0,0)
 /** \a angle angle in radians (positive is counterclockwise (CCW) )
     \a p the point */
-inline Point RotatePoint(float angle, const Point &p)
+inline Math::Point RotatePoint(float angle, const Math::Point &p)
 {
     float x = p.x*cosf(angle) - p.y*sinf(angle);
     float y = p.x*sinf(angle) + p.y*cosf(angle);
 
-    return Point(x, y);
+    return Math::Point(x, y);
 }
 
 //! Rotates a vector (dist, 0).
 /** \a angle angle is in radians (positive is counterclockwise (CCW) )
     \a dist distance to origin */
-inline Point RotatePoint(float angle, float dist)
+inline Math::Point RotatePoint(float angle, float dist)
 {
     float x = dist*cosf(angle);
     float y = dist*sinf(angle);
 
-    return Point(x, y);
+    return Math::Point(x, y);
 }
 
 //! TODO documentation
@@ -140,13 +140,13 @@ inline void RotatePoint(float cx, float cy, float angle, float &px, float &py)
     \a angleH,angleV rotation angles in radians (positive is counterclockwise (CCW) ) )
     \a p the point
     \returns the rotated point */
-inline void RotatePoint(const Vector &center, float angleH, float angleV, Vector &p)
+inline void RotatePoint(const Math::Vector &center, float angleH, float angleV, Math::Vector &p)
 {
     p.x -= center.x;
     p.y -= center.y;
     p.z -= center.z;
 
-    Vector b;
+    Math::Vector b;
     b.x = p.x*cosf(angleH) - p.z*sinf(angleH);
     b.y = p.z*sinf(angleV) + p.y*cosf(angleV);
     b.z = p.x*sinf(angleH) + p.z*cosf(angleH);
@@ -159,18 +159,18 @@ inline void RotatePoint(const Vector &center, float angleH, float angleV, Vector
     \a angleH,angleV rotation angles in radians (positive is counterclockwise (CCW) ) )
     \a p the point
     \returns the rotated point */
-inline void RotatePoint2(const Vector center, float angleH, float angleV, Vector &p)
+inline void RotatePoint2(const Math::Vector center, float angleH, float angleV, Math::Vector &p)
 {
     p.x -= center.x;
     p.y -= center.y;
     p.z -= center.z;
 
-    Vector a;
+    Math::Vector a;
     a.x = p.x*cosf(angleH) - p.z*sinf(angleH);
     a.y = p.y;
     a.z = p.x*sinf(angleH) + p.z*cosf(angleH);
 
-    Vector b;
+    Math::Vector b;
     b.x = a.x;
     b.y = a.z*sinf(angleV) + a.y*cosf(angleV);
     b.z = a.z*cosf(angleV) - a.y*sinf(angleV);
@@ -196,7 +196,7 @@ inline float RotateAngle(float x, float y)
 /** \a center the center point
     \a p1,p2 the two points
     \returns The angle in radians (positive is counterclockwise (CCW) ) */
-inline float RotateAngle(const Point &center, const Point &p1, const Point &p2)
+inline float RotateAngle(const Math::Point &center, const Math::Point &p1, const Math::Point &p2)
 {
     if (PointsEqual(p1, center))
         return 0;
@@ -221,11 +221,12 @@ inline float RotateAngle(const Point &center, const Point &p1, const Point &p2)
 /** \a from origin
     \a at view direction
     \a worldUp up vector */
-inline void LoadViewMatrix(Matrix &mat, const Vector &from, const Vector &at, const Vector &worldUp)
+inline void LoadViewMatrix(Math::Matrix &mat, const Math::Vector &from,
+                           const Math::Vector &at, const Math::Vector &worldUp)
 {
     // Get the z basis vector, which points straight ahead. This is the
     // difference from the eyepoint to the lookat point.
-    Vector view = at - from;
+    Math::Vector view = at - from;
 
     float length = view.Length();
     assert(! IsZero(length) );
@@ -237,18 +238,18 @@ inline void LoadViewMatrix(Matrix &mat, const Vector &from, const Vector &at, co
     // vector onto the up vector. The projection is the y basis vector.
     float dotProduct = DotProduct(worldUp, view);
 
-    Vector up = worldUp - dotProduct * view;
+    Math::Vector up = worldUp - dotProduct * view;
 
     // If this vector has near-zero length because the input specified a
     // bogus up vector, let's try a default up vector
     if ( IsZero(length = up.Length()) )
     {
-        up = Vector(0.0f, 1.0f, 0.0f) - view.y * view;
+        up = Math::Vector(0.0f, 1.0f, 0.0f) - view.y * view;
 
         // If we still have near-zero length, resort to a different axis.
         if ( IsZero(length = up.Length()) )
         {
-            up = Vector(0.0f, 0.0f, 1.0f) - view.z * view;
+            up = Math::Vector(0.0f, 0.0f, 1.0f) - view.z * view;
 
             assert(! IsZero(up.Length()) );
         }
@@ -259,7 +260,7 @@ inline void LoadViewMatrix(Matrix &mat, const Vector &from, const Vector &at, co
 
     // The x basis vector is found simply with the cross product of the y
     // and z basis vectors
-    Vector right = CrossProduct(up, view);
+    Math::Vector right = CrossProduct(up, view);
 
     // Start building the matrix. The first three rows contains the basis
     // vectors used to rotate the view to point at the lookat point
@@ -286,28 +287,44 @@ inline void LoadViewMatrix(Matrix &mat, const Vector &from, const Vector &at, co
     \a aspect aspect ratio (width / height)
     \a nearPlane distance to near cut plane
     \a farPlane distance to far cut plane */
-inline void LoadProjectionMatrix(Matrix &mat, float fov = 1.570795f, float aspect = 1.0f,
+inline void LoadProjectionMatrix(Math::Matrix &mat, float fov = Math::PI / 2.0f, float aspect = 1.0f,
                                  float nearPlane = 1.0f, float farPlane = 1000.0f)
 {
     assert(fabs(farPlane - nearPlane) >= 0.01f);
     assert(fabs(sin(fov / 2)) >= 0.01f);
 
-    float w = aspect * (cosf(fov / 2) / sinf(fov / 2));
-    float h = 1.0f   * (cosf(fov / 2) / sinf(fov / 2));
-    float q = farPlane / (farPlane - nearPlane);
+    float f = cosf(fov / 2.0f) / sinf(fov / 2.0f);
 
     mat.LoadZero();
 
-    /* (1,1) */ mat.m[0 ] = w;
-    /* (2,2) */ mat.m[5 ] = h;
-    /* (3,3) */ mat.m[10] = q;
-    /* (4,3) */ mat.m[11] = 1.0f;
-    /* (3,4) */ mat.m[14] = -q * nearPlane;
+    /* (1,1) */ mat.m[0 ] = f / aspect;
+    /* (2,2) */ mat.m[5 ] = f;
+    /* (3,3) */ mat.m[10] = (nearPlane + farPlane) / (nearPlane - farPlane);
+    /* (4,3) */ mat.m[11] = -1.0f;
+    /* (3,4) */ mat.m[14] = (2.0f * farPlane * nearPlane) / (nearPlane - farPlane);
+}
+
+//! Loads an othogonal projection matrix
+/** \a left,right coordinates for left and right vertical clipping planes
+    \a bottom,top coordinates for bottom and top horizontal clipping planes
+    \a zNear,zFar distance to nearer and farther depth clipping planes */
+inline void LoadOrthoProjectionMatrix(Math::Matrix &mat, float left, float right, float bottom, float top,
+                                      float zNear = -1.0f, float zFar = 1.0f)
+{
+    mat.LoadIdentity();
+
+    /* (1,1) */ mat.m[0 ] =  2.0f / (right - left);
+    /* (2,2) */ mat.m[5 ] =  2.0f / (top - bottom);
+    /* (3,3) */ mat.m[10] = -2.0f / (zFar - zNear);
+
+    /* (1,4) */ mat.m[12] =  - (right + left) / (right - left);
+    /* (2,4) */ mat.m[13] =  - (top + bottom) / (top - bottom);
+    /* (3,4) */ mat.m[14] =  - (zFar + zNear) / (zFar - zNear);
 }
 
 //! Loads a translation matrix from given vector
 /** \a trans vector of translation*/
-inline void LoadTranslationMatrix(Matrix &mat, const Vector &trans)
+inline void LoadTranslationMatrix(Math::Matrix &mat, const Math::Vector &trans)
 {
     mat.LoadIdentity();
     /* (1,4) */ mat.m[12] = trans.x;
@@ -317,7 +334,7 @@ inline void LoadTranslationMatrix(Matrix &mat, const Vector &trans)
 
 //! Loads a scaling matrix fom given vector
 /** \a scale vector with scaling factors for X, Y, Z */
-inline void LoadScaleMatrix(Matrix &mat, const Vector &scale)
+inline void LoadScaleMatrix(Math::Matrix &mat, const Math::Vector &scale)
 {
     mat.LoadIdentity();
     /* (1,1) */ mat.m[0 ] = scale.x;
@@ -327,7 +344,7 @@ inline void LoadScaleMatrix(Matrix &mat, const Vector &scale)
 
 //! Loads a rotation matrix along the X axis
 /** \a angle angle in radians */
-inline void LoadRotationXMatrix(Matrix &mat, float angle)
+inline void LoadRotationXMatrix(Math::Matrix &mat, float angle)
 {
     mat.LoadIdentity();
     /* (2,2) */ mat.m[5 ] =  cosf(angle);
@@ -338,7 +355,7 @@ inline void LoadRotationXMatrix(Matrix &mat, float angle)
 
 //! Loads a rotation matrix along the Y axis
 /** \a angle angle in radians */
-inline void LoadRotationYMatrix(Matrix &mat, float angle)
+inline void LoadRotationYMatrix(Math::Matrix &mat, float angle)
 {
     mat.LoadIdentity();
     /* (1,1) */ mat.m[0 ] =  cosf(angle);
@@ -349,7 +366,7 @@ inline void LoadRotationYMatrix(Matrix &mat, float angle)
 
 //! Loads a rotation matrix along the Z axis
 /** \a angle angle in radians */
-inline void LoadRotationZMatrix(Matrix &mat, float angle)
+inline void LoadRotationZMatrix(Math::Matrix &mat, float angle)
 {
     mat.LoadIdentity();
     /* (1,1) */ mat.m[0 ] =  cosf(angle);
@@ -361,11 +378,11 @@ inline void LoadRotationZMatrix(Matrix &mat, float angle)
 //! Loads a rotation matrix along the given axis
 /** \a dir axis of rotation
     \a angle angle in radians */
-inline void LoadRotationMatrix(Matrix &mat, const Vector &dir, float angle)
+inline void LoadRotationMatrix(Math::Matrix &mat, const Math::Vector &dir, float angle)
 {
     float cos = cosf(angle);
     float sin = sinf(angle);
-    Vector v = Normalize(dir);
+    Math::Vector v = Normalize(dir);
 
     mat.LoadIdentity();
 
@@ -383,9 +400,9 @@ inline void LoadRotationMatrix(Matrix &mat, const Vector &dir, float angle)
 }
 
 //! Calculates the matrix to make three rotations in the order X, Z and Y
-inline void LoadRotationXZYMatrix(Matrix &mat, const Vector &angle)
+inline void LoadRotationXZYMatrix(Math::Matrix &mat, const Math::Vector &angle)
 {
-    Matrix temp;
+    Math::Matrix temp;
     LoadRotationXMatrix(temp, angle.x);
 
     LoadRotationZMatrix(mat, angle.z);
@@ -396,9 +413,9 @@ inline void LoadRotationXZYMatrix(Matrix &mat, const Vector &angle)
 }
 
 //! Calculates the matrix to make three rotations in the order Z, X and Y
-inline void LoadRotationZXYMatrix(Matrix &mat, const Vector &angle)
+inline void LoadRotationZXYMatrix(Math::Matrix &mat, const Math::Vector &angle)
 {
-    Matrix temp;
+    Math::Matrix temp;
     LoadRotationZMatrix(temp, angle.z);
 
     LoadRotationXMatrix(mat, angle.x);
@@ -409,7 +426,7 @@ inline void LoadRotationZXYMatrix(Matrix &mat, const Vector &angle)
 }
 
 //! Returns the distance between projections on XZ plane of two vectors
-inline float DistanceProjected(const Vector &a, const Vector &b)
+inline float DistanceProjected(const Math::Vector &a, const Math::Vector &b)
 {
     return sqrtf( (a.x-b.x)*(a.x-b.x) +
                   (a.z-b.z)*(a.z-b.z) );
@@ -417,10 +434,10 @@ inline float DistanceProjected(const Vector &a, const Vector &b)
 
 //! Returns the normal vector to a plane
 /** \param p1,p2,p3 points defining the plane */
-inline Vector NormalToPlane(const Vector &p1, const Vector &p2, const Vector &p3)
+inline Math::Vector NormalToPlane(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3)
 {
-    Vector u = p3 - p1;
-    Vector v = p2 - p1;
+    Math::Vector u = p3 - p1;
+    Math::Vector v = p2 - p1;
 
     return Normalize(CrossProduct(u, v));
 }
@@ -428,7 +445,7 @@ inline Vector NormalToPlane(const Vector &p1, const Vector &p2, const Vector &p3
 //! Returns a point on the line \a p1 - \a p2, in \a dist distance from \a p1
 /** \a p1,p2 line start and end
     \a dist scaling factor from \a p1, relative to distance between \a p1 and \a p2 */
-inline Vector SegmentPoint(const Vector &p1, const Vector &p2, float dist)
+inline Math::Vector SegmentPoint(const Math::Vector &p1, const Math::Vector &p2, float dist)
 {
     return p1 + (p2 - p1) * dist;
 }
@@ -436,9 +453,10 @@ inline Vector SegmentPoint(const Vector &p1, const Vector &p2, float dist)
 //! Returns the distance between given point and a plane
 /** \param p the point
     \param a,b,c points defining the plane */
-inline float DistanceToPlane(const Vector &a, const Vector &b, const Vector &c, const Vector &p)
+inline float DistanceToPlane(const Math::Vector &a, const Math::Vector &b,
+                             const Math::Vector &c, const Math::Vector &p)
 {
-    Vector n = NormalToPlane(a, b, c);
+    Math::Vector n = NormalToPlane(a, b, c);
     float d = -(n.x*a.x + n.y*a.y + n.z*a.z);
 
     return fabs(n.x*p.x + n.y*p.y + n.z*p.z + d);
@@ -447,10 +465,10 @@ inline float DistanceToPlane(const Vector &a, const Vector &b, const Vector &c,
 //! Checks if two planes defined by three points are the same
 /** \a plane1 array of three vectors defining the first plane
     \a plane2 array of three vectors defining the second plane */
-inline bool IsSamePlane(const Vector (&plane1)[3], const Vector (&plane2)[3])
+inline bool IsSamePlane(const Math::Vector (&plane1)[3], const Math::Vector (&plane2)[3])
 {
-    Vector n1 = NormalToPlane(plane1[0], plane1[1], plane1[2]);
-    Vector n2 = NormalToPlane(plane2[0], plane2[1], plane2[2]);
+    Math::Vector n1 = NormalToPlane(plane1[0], plane1[1], plane1[2]);
+    Math::Vector n2 = NormalToPlane(plane2[0], plane2[1], plane2[2]);
 
     if ( fabs(n1.x-n2.x) > 0.1f ||
          fabs(n1.y-n2.y) > 0.1f ||
@@ -465,7 +483,8 @@ inline bool IsSamePlane(const Vector (&plane1)[3], const Vector (&plane2)[3])
 }
 
 //! Calculates the intersection "i" right "of" the plane "abc".
-inline bool Intersect(const Vector &a, const Vector &b, const Vector &c, const Vector &d, const Vector &e, Vector &i)
+inline bool Intersect(const Math::Vector &a, const Math::Vector &b, const Math::Vector &c,
+                      const Math::Vector &d, const Math::Vector &e, Math::Vector &i)
 {
     float d1 = (d.x-a.x)*((b.y-a.y)*(c.z-a.z)-(c.y-a.y)*(b.z-a.z)) -
                (d.y-a.y)*((b.x-a.x)*(c.z-a.z)-(c.x-a.x)*(b.z-a.z)) +
@@ -487,7 +506,7 @@ inline bool Intersect(const Vector &a, const Vector &b, const Vector &c, const V
 
 //! Calculates the intersection of the straight line passing through p (x, z)
 /** Line is parallel to the y axis, with the plane abc. Returns p.y. */
-inline bool IntersectY(const Vector &a, const Vector &b, const Vector &c, Vector &p)
+inline bool IntersectY(const Math::Vector &a, const Math::Vector &b, const Math::Vector &c, Math::Vector &p)
 {
     float d  = (b.x-a.x)*(c.z-a.z) - (c.x-a.x)*(b.z-a.z);
     float d1 = (p.x-a.x)*(c.z-a.z) - (c.x-a.x)*(p.z-a.z);
@@ -502,9 +521,9 @@ inline bool IntersectY(const Vector &a, const Vector &b, const Vector &c, Vector
 }
 
 //! Calculates the end point
-inline Vector LookatPoint(const Vector &eye, float angleH, float angleV, float length)
+inline Math::Vector LookatPoint(const Math::Vector &eye, float angleH, float angleV, float length)
 {
-    Vector lookat = eye;
+    Math::Vector lookat = eye;
     lookat.z += length;
 
     RotatePoint(eye, angleH, angleV, lookat);
@@ -513,7 +532,7 @@ inline Vector LookatPoint(const Vector &eye, float angleH, float angleV, float l
 }
 
 //! TODO documentation
-inline Vector Transform(const Matrix &m, const Vector &p)
+inline Math::Vector Transform(const Math::Matrix &m, const Math::Vector &p)
 {
     return MatrixVectorMultiply(m, p);
 }
@@ -521,7 +540,7 @@ inline Vector Transform(const Matrix &m, const Vector &p)
 //! Calculates the projection of the point \a p on a straight line \a a to \a b.
 /** \a p point to project
     \a a,b two ends of the line */
-inline Vector Projection(const Vector &a, const Vector &b, const Vector &p)
+inline Math::Vector Projection(const Math::Vector &a, const Math::Vector &b, const Math::Vector &p)
 {
     float k = DotProduct(b - a, p - a);
     k /= DotProduct(b - a, b - a);
@@ -530,15 +549,15 @@ inline Vector Projection(const Vector &a, const Vector &b, const Vector &p)
 }
 
 //! Calculates point of view to look at a center two angles and a distance
-inline Vector RotateView(Vector center, float angleH, float angleV, float dist)
+inline Math::Vector RotateView(Math::Vector center, float angleH, float angleV, float dist)
 {
-    Matrix mat1, mat2;
+    Math::Matrix mat1, mat2;
     LoadRotationZMatrix(mat1, -angleV);
     LoadRotationYMatrix(mat2, -angleH);
 
-    Matrix mat = MultiplyMatrices(mat2, mat1);
+    Math::Matrix mat = MultiplyMatrices(mat2, mat1);
 
-    Vector eye;
+    Math::Vector eye;
     eye.x = 0.0f+dist;
     eye.y = 0.0f;
     eye.z = 0.0f;
diff --git a/src/math/intsize.h b/src/math/intsize.h
new file mode 100644
index 0000000..f4b2431
--- /dev/null
+++ b/src/math/intsize.h
@@ -0,0 +1,61 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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    http://www.gnu.org/licenses/.
+
+/** @defgroup MathIntSizeModule math/intsize.h
+     Contains the IntSize struct.
+ */
+
+#pragma once
+
+// Math module namespace
+namespace Math
+{
+
+/* @{ */ // start of group
+
+/** \struct IntSize math/size.h
+    \brief 2D size with integer dimensions */
+struct IntSize
+{
+    //! Width
+    int w;
+    //! Height
+    int h;
+
+    //! Constructs a zero size: (0,0)
+    inline IntSize()
+    {
+        LoadZero();
+    }
+
+    //! Constructs a size from given dimensions: (w,h)
+    inline explicit IntSize(int w, int h)
+    {
+        this->w = w;
+        this->h = h;
+    }
+
+    //! Sets the zero size: (0,0)
+    inline void LoadZero()
+    {
+        w = h = 0;
+    }
+}; // struct Size
+
+
+/* @} */ // end of group
+
+}; // namespace Math
diff --git a/src/math/matrix.h b/src/math/matrix.h
index 9b29f46..45a7d75 100644
--- a/src/math/matrix.h
+++ b/src/math/matrix.h
@@ -118,6 +118,12 @@ struct Matrix
         /* (4,4) */ m[15] = 1.0f;
     }
 
+    //! Returns the struct cast to \c float* array; use with care!
+    inline float* Array()
+    {
+        return reinterpret_cast<float*>(this);
+    }
+
     //! Transposes the matrix
     inline void Transpose()
     {
@@ -382,9 +388,9 @@ inline bool MatricesEqual(const Matrix &m1, const Matrix &m2,
 }
 
 //! Convenience function for getting transposed matrix
-inline Matrix Transpose(const Matrix &m)
+inline Math::Matrix Transpose(const Math::Matrix &m)
 {
-    Matrix result = m;
+    Math::Matrix result = m;
     result.Transpose();
     return result;
 }
@@ -393,7 +399,7 @@ inline Matrix Transpose(const Matrix &m)
 /** \a left left-hand matrix
     \a right right-hand matrix
     \returns multiplied matrices */
-inline Matrix MultiplyMatrices(const Matrix &left, const Matrix &right)
+inline Math::Matrix MultiplyMatrices(const Math::Matrix &left, const Math::Matrix &right)
 {
     return left.Multiply(right);
 }
@@ -407,25 +413,25 @@ inline Matrix MultiplyMatrices(const Matrix &left, const Matrix &right)
 
    The result, a 4x1 vector is then converted to 3x1 by dividing
    x,y,z coords by the fourth coord (w). */
-inline Vector MatrixVectorMultiply(const Matrix &m, const Vector &v, bool wDivide = false)
+inline Math::Vector MatrixVectorMultiply(const Math::Matrix &m, const Math::Vector &v, bool wDivide = false)
 {
     float x = v.x * m.m[0 ] + v.y * m.m[4 ] + v.z * m.m[8 ] + m.m[12];
     float y = v.x * m.m[1 ] + v.y * m.m[5 ] + v.z * m.m[9 ] + m.m[13];
     float z = v.x * m.m[2 ] + v.y * m.m[6 ] + v.z * m.m[10] + m.m[14];
 
     if (!wDivide)
-        return Vector(x, y, z);
+        return Math::Vector(x, y, z);
 
     float w = v.x * m.m[3 ] + v.y * m.m[7 ] + v.z * m.m[11] + m.m[15];
 
     if (IsZero(w))
-        return Vector(x, y, z);
+        return Math::Vector(x, y, z);
 
     x /= w;
     y /= w;
     z /= w;
 
-    return Vector(x, y, z);
+    return Math::Vector(x, y, z);
 }
 
 /* @} */ // end of group
diff --git a/src/math/point.h b/src/math/point.h
index 84be190..ea20db9 100644
--- a/src/math/point.h
+++ b/src/math/point.h
@@ -24,6 +24,7 @@
 #include "func.h"
 
 #include <cmath>
+#include <sstream>
 
 
 // Math module namespace
@@ -67,6 +68,18 @@ struct Point
         x = y = 0.0f;
     }
 
+    //! Returns the struct cast to \c float* array; use with care!
+    inline float* Array()
+    {
+        return reinterpret_cast<float*>(this);
+    }
+
+    //! Returns the struct cast to <tt>const float*</tt> array; use with care!
+    inline const float* Array() const
+    {
+        return reinterpret_cast<const float*>(this);
+    }
+
     //! Returns the distance from (0,0) to the point (x,y)
     inline float Length()
     {
@@ -141,6 +154,15 @@ struct Point
         return Point(left.x / right, left.y / right);
     }
 
+
+    //! Returns a string "[x, y]"
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "[" << x << ", " << y << "]";
+        return s.str();
+    }
 }; // struct Point
 
 
diff --git a/src/math/size.h b/src/math/size.h
new file mode 100644
index 0000000..781b9a4
--- /dev/null
+++ b/src/math/size.h
@@ -0,0 +1,66 @@
+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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    http://www.gnu.org/licenses/.
+
+/** @defgroup MathSizeModule math/size.h
+     Contains the Size struct.
+ */
+
+#pragma once
+
+// Math module namespace
+namespace Math
+{
+
+/* @{ */ // start of group
+
+/** \struct Size math/size.h
+    \brief 2D size
+
+    Represents a 2D size (w, h).
+    Is separate from Math::Point to avoid confusion.
+
+ */
+struct Size
+{
+    //! Width
+    float w;
+    //! Height
+    float h;
+
+    //! Constructs a zero size: (0,0)
+    inline Size()
+    {
+        LoadZero();
+    }
+
+    //! Constructs a size from given dimensions: (w,h)
+    inline explicit Size(float w, float h)
+    {
+        this->w = w;
+        this->h = h;
+    }
+
+    //! Sets the zero size: (0,0)
+    inline void LoadZero()
+    {
+        w = h = 0.0f;
+    }
+}; // struct Size
+
+
+/* @} */ // end of group
+
+}; // namespace Math
diff --git a/src/math/vector.h b/src/math/vector.h
index 3c756f2..147869f 100644
--- a/src/math/vector.h
+++ b/src/math/vector.h
@@ -24,6 +24,7 @@
 #include "func.h"
 
 #include <cmath>
+#include <sstream>
 
 
 // Math module namespace
@@ -72,6 +73,18 @@ struct Vector
         x = y = z = 0.0f;
     }
 
+    //! Returns the struct cast to \c float* array; use with care!
+    inline float* Array()
+    {
+        return reinterpret_cast<float*>(this);
+    }
+
+    //! Returns the struct cast to <tt>const float*</tt> array; use with care!
+    inline const float* Array() const
+    {
+        return reinterpret_cast<const float*>(this);
+    }
+
     //! Returns the vector length
     inline float Length() const
     {
@@ -196,10 +209,20 @@ struct Vector
         return Vector(left.x / right, left.y / right, left.z / right);
     }
 
+
+    //! Returns a string "[x, y, z]"
+    inline std::string ToString() const
+    {
+        std::stringstream s;
+        s.precision(3);
+        s << "[" << x << ", " << y << ", " << z << "]";
+        return s.str();
+    }
+
 }; // struct Point
 
 //! Checks if two vectors are equal within given \a tolerance
-inline bool VectorsEqual(const Vector &a, const Vector &b, float tolerance = TOLERANCE)
+inline bool VectorsEqual(const Math::Vector &a, const Math::Vector &b, float tolerance = TOLERANCE)
 {
     return IsEqual(a.x, b.x, tolerance)
             && IsEqual(a.y, b.y, tolerance)
@@ -207,7 +230,7 @@ inline bool VectorsEqual(const Vector &a, const Vector &b, float tolerance = TOL
 }
 
 //! Convenience function for getting normalized vector
-inline Vector Normalize(const Vector &v)
+inline Vector Normalize(const Math::Vector &v)
 {
     Vector result = v;
     result.Normalize();
@@ -215,25 +238,25 @@ inline Vector Normalize(const Vector &v)
 }
 
 //! Convenience function for calculating dot product
-inline float DotProduct(const Vector &left, const Vector &right)
+inline float DotProduct(const Math::Vector &left, const Math::Vector &right)
 {
     return left.DotMultiply(right);
 }
 
 //! Convenience function for calculating cross product
-inline Vector CrossProduct(const Vector &left, const Vector &right)
+inline Vector CrossProduct(const Math::Vector &left, const Math::Vector &right)
 {
     return left.CrossMultiply(right);
 }
 
 //! Convenience function for calculating angle (in radians) between two vectors
-inline float Angle(const Vector &a, const Vector &b)
+inline float Angle(const Math::Vector &a, const Math::Vector &b)
 {
     return a.Angle(b);
 }
 
 //! Returns the distance between the ends of two vectors
-inline float Distance(const Vector &a, const Vector &b)
+inline float Distance(const Math::Vector &a, const Math::Vector &b)
 {
     return sqrtf( (a.x-b.x)*(a.x-b.x) +
                   (a.y-b.y)*(a.y-b.y) +
diff --git a/src/sound/sound.h b/src/sound/sound.h
index 1bf9ae5..d323918 100644
--- a/src/sound/sound.h
+++ b/src/sound/sound.h
@@ -1,315 +1,322 @@
-// * This file is part of the COLOBOT source code

-// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch

-// * Copyright (C) 2012, Polish Portal of Colobot (PPC)

-// *

-// * 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  http://www.gnu.org/licenses/.

-

-// soundinterface.h

-

-/**

- *  @file sound/soundinterface.h

- *  @brief Sound plugin interface

- */

-

-#pragma once

-

-#include <math/vector.h>

-

-#include <plugins/plugininterface.h>

-

-/*!

- * Maximum possible audio volume

- */

-#define MAXVOLUME 100

-

-

-/**

- * \public

- * \enum    Sound   sound/soundinterface.h

- * \brief   Sound enum representing sound file

-**/

-enum Sound

-{

-  SOUND_CLICK  = 0, 

-  SOUND_BOUM  = 1,

-  SOUND_EXPLO  = 2,

-  SOUND_FLYh  = 3, /*!< human */

-  SOUND_FLY  = 4,

-  SOUND_STEPs  = 5, /*!< smooth */

-  SOUND_MOTORw  = 6, /*!< wheel */

-  SOUND_MOTORt  = 7, /*!< tank */

-  SOUND_MOTORr  = 8, /*!< roller */

-  SOUND_ERROR  = 9,

-  SOUND_CONVERT  = 10,

-  SOUND_ENERGY  = 11,

-  SOUND_PLOUF  = 12,

-  SOUND_BLUP  = 13,

-  SOUND_WARNING  = 14,

-  SOUND_DERRICK  = 15,

-  SOUND_LABO  = 16,

-  SOUND_STATION  = 17,

-  SOUND_REPAIR  = 18,

-  SOUND_RESEARCH  = 19,

-  SOUND_INSECTs  = 20, /*!< spider */

-  SOUND_BURN  = 21,

-  SOUND_TZOING  = 22,

-  SOUND_GGG  = 23,

-  SOUND_MANIP  = 24,

-  SOUND_FIRE  = 25, /*!< shooting with fireball */

-  SOUND_HUMAN1  = 26, /*!< breathing */

-  SOUND_STEPw  = 27, /*!< water */

-  SOUND_SWIM  = 28,

-  SOUND_RADAR  = 29,

-  SOUND_BUILD  = 30,

-  SOUND_ALARM  = 31, /*!< energy alarm */

-  SOUND_SLIDE  = 32,

-  SOUND_EXPLOi  = 33, /*!< insect */

-  SOUND_INSECTa  = 34, /*!< ant */

-  SOUND_INSECTb  = 35, /*!< bee */

-  SOUND_INSECTw  = 36, /*!< worm */

-  SOUND_INSECTm  = 37, /*!< mother */

-  SOUND_TREMBLE  = 38,

-  SOUND_PSHHH  = 39,

-  SOUND_NUCLEAR  = 40,

-  SOUND_INFO  = 41,

-  SOUND_OPEN  = 42,

-  SOUND_CLOSE  = 43,

-  SOUND_FACTORY  = 44,

-  SOUND_EGG  = 45,

-  SOUND_MOTORs  = 46, /*!< submarine */

-  SOUND_MOTORi  = 47, /*!< insect (legs) */

-  SOUND_SHIELD  = 48,

-  SOUND_FIREi  = 49, /*!< shooting with orgaball (insect) */

-  SOUND_GUNDEL  = 50,

-  SOUND_PSHHH2  = 51, /*!< shield */

-  SOUND_MESSAGE  = 52,

-  SOUND_BOUMm  = 53, /*!< metal */

-  SOUND_BOUMv  = 54, /*!< plant */

-  SOUND_BOUMs  = 55, /*!< smooth */

-  SOUND_EXPLOl  = 56, /*!< little */

-  SOUND_EXPLOlp  = 57, /*!< little power */

-  SOUND_EXPLOp  = 58, /*!< power */

-  SOUND_STEPh  = 59, /*!< hard */

-  SOUND_STEPm  = 60, /*!< metal */

-  SOUND_POWERON  = 61,

-  SOUND_POWEROFF  = 62,

-  SOUND_AIE  = 63,

-  SOUND_WAYPOINT  = 64,

-  SOUND_RECOVER  = 65,

-  SOUND_DEADi  = 66,

-  SOUND_JOSTLE  = 67,

-  SOUND_GFLAT  = 68,

-  SOUND_DEADg  = 69, /*!< shooting death */

-  SOUND_DEADw  = 70, /*!< drowning */

-  SOUND_FLYf  = 71, /*!< reactor fail */

-  SOUND_ALARMt  = 72, /*!< temperature alarm */

-  SOUND_FINDING  = 73, /*!< finds a cache object */

-  SOUND_THUMP  = 74,

-  SOUND_TOUCH  = 75,

-  SOUND_BLITZ  = 76,

-  SOUND_MUSHROOM  = 77,

-  SOUND_FIREp  = 78, /*!< shooting with phazer */

-  SOUND_EXPLOg1  = 79, /*!< impact gun 1 */

-  SOUND_EXPLOg2  = 80, /*!< impact gun 2 */

-  SOUND_MOTORd  = 81, /*!< engine friction */

-};

-

-

-/**

- * \public

- * \enum    SoundNext   sound/soundinterface.h

- * \brief   Enum representing operation that will be performend on a sound at given time

-**/

-enum SoundNext

-{

-  SOPER_CONTINUE = 1, /*!< continue playing */

-  SOPER_STOP = 2, /*!< stop playing */

-  SOPER_LOOP = 3, /*!< start over */

-};

-

-

-/**

-* @class CSoundInterface

-*

-* @brief Sound plugin interface

-*

-*/ 

-class CSoundInterface : public CPluginInterface

-{

-  public:

-    CSoundInterface() {};

-    virtual ~CSoundInterface() = 0;

-

-    /** Function to initialize sound device

-     *  @param bool b3D - enable support for 3D sound

-     */

-    virtual bool Create(bool b3D) = 0;

-

-    /** Function called to cache all sound effect files.

-     *  Function calls \link CSoundInterface::Cache() \endlink for each file

-     */

-    virtual void CacheAll() = 0;

-

-    /** Function called to cache sound effect file.

-     *  This function is called by plugin interface for each file.

-     * @param Sound bSound - id of a file, will be used to identify sound files

-     * @param std::string bFile - file to load

-     * @return return true on success

-     */

-    virtual bool Cache(Sound bSound, std::string bFile) = 0;

-

-    /** Return if plugin is enabled

-     *  @return return true if plugin is enabled

-     */

-    virtual bool RetEnable() = 0;

-

-    /** Change sound mode to 2D/3D

-     * @param bool bMode - true to enable 3D sound

-     */

-    virtual void SetSound3D(bool bMode) = 0;

-

-    /** Return if we use 3D sound

-     * @return true if we have 3D sound enabled

-     */

-    virtual bool RetSound3D() = 0;

-

-    /** Return if we have 3D sound capable card

-     * @return true for 3D sound support

-     */

-    virtual bool RetSound3DCap() = 0;

-

-    /** Change global sound volume

-     * @param int volume - range from 0 to MAXVOLUME

-     */

-    virtual void SetAudioVolume(int volume) = 0;

-

-    /** Return global sound volume

-     * @return global volume as int in range from 0 to MAXVOLUME

-     */

-    virtual int RetAudioVolume() = 0;

-

-    /** Set music volume

-     * @param int volume - range from 0 to MAXVOLUME

-     */

-    virtual void SetMusicVolume(int volume) = 0;

-

-    /** Return music volume

-     * @return music volume as int in range from 0 to MAXVOLUME

-     */

-    virtual int RetMusicVolume() = 0;

-

-    /** Set listener position

-     * @param Math::Vector eye - position of listener

-     * @param Math::Vector lookat - direction listener is looking at

-     */

-    virtual void SetListener(Math::Vector eye, Math::Vector lookat) = 0;

-

-    /** Update data each frame

-     * @param float rTime - time since last update

-     */

-    virtual void FrameMove(float rTime) = 0;

-

-    /** Play specific sound

-     * @param Sound sound - sound to play

-     * @param float amplitude - change amplitude of sound before playing

-     * @param float frequency - change sound frequency before playing (0.5 octave down, 2.0 octave up)

-     * @param bool bLoop - loop sound

-     * @return identifier of channel that sound will be played on 

-     */

-    virtual int Play(Sound sound, float amplitude=1.0f, float frequency=1.0f, bool bLoop = false) = 0;

-

-    /** Play specific sound

-     * @param Sound sound - sound to play

-     * @param Math:Vector pos - position of sound in space

-     * @param float amplitude - change amplitude of sound before playing

-     * @param float frequency - change sound frequency before playing (0.5 octave down, 2.0 octave up)

-     * @param bool bLoop - loop sound

-     * @return identifier of channel that sound will be played on

-     */

-    virtual int Play(Sound sound, Math::Vector pos, float amplitude=1.0f, float frequency=1.0f, bool bLoop = false) = 0;

-

-    /** Remove all operations that would be made on sound in channel.

-     * @param int channel - channel to work on

-     * @return return true on success

-     */

-    virtual bool FlushEnvelope(int channel) = 0;

-

-    /** Add envelope to sound. Envelope is a operatino that will be performend on sound in future like changing frequency

-     * @param int channel - channel to work on

-     * @param float amplitude - change amplitude

-     * @param float frequency - change frequency

-     * @param float time - when to change (sample time)

-     * @param SoundNext oper - operation to perform

-     * @return return true on success

-     */

-    virtual bool AddEnvelope(int channel, float amplitude, float frequency, float time, SoundNext oper) = 0;

-

-    /** Set sound position in space

-     * @param int channel - channel to work on

-     * @param Math::Vector pos - new positino of a sound

-     * @return return true on success

-     */

-    virtual bool Position(int channel, Math::Vector pos) = 0;

-

-    /** Set sound frequency

-     * @param int channel - channel to work on

-     * @param float frequency - change sound frequency

-     * @return return true on success

-     */

-    virtual bool Frequency(int channel, float frequency) = 0;

-

-    /** Stop playing sound

-     * @param int channel - channel to work on

-     * @return return true on success

-     */

-    virtual bool Stop(int channel) = 0;

-

-    /** Stop playing all sounds

-     * @return return true on success

-     */

-    virtual bool StopAll() = 0;

-

-    /** Mute/unmute all sounds

-     * @param bool bMute

-     * @return return true on success

-     */

-    virtual bool MuteAll(bool bMute) = 0;

-

-    /** Start playing music

-     * @param int rank - track number

-     * @param bool bRepeat - repeat playing

-     * @return return true on success

-     */

-    virtual bool PlayMusic(int rank, bool bRepeat) = 0;

-

-    /** Restart music

-     * @return return true on success

-     */

-    virtual bool RestartMusic() = 0;

-

-    /** Susspend paying music

-     * @return return true on success

-     */

-    virtual void SuspendMusic() = 0;

-

-    /** Stop playing music

-     * @return return true on success

-     */

-    virtual void StopMusic() = 0;

-

-    /** Check if music if playing

-     * @return return true if music is playing

-     */

-    virtual bool IsPlayingMusic() = 0;

-};

+// * This file is part of the COLOBOT source code
+// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
+// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
+// *
+// * 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  http://www.gnu.org/licenses/.
+
+// soundinterface.h
+
+/**
+ *  @file sound/soundinterface.h
+ *  @brief Sound plugin interface
+ */
+
+#pragma once
+
+#include <math/vector.h>
+
+#include <plugins/plugin.h>
+
+#include <string>
+
+
+/*!
+ * Maximum possible audio volume
+ */
+#define MAXVOLUME 100
+
+
+/**
+ * \public
+ * \enum    Sound   sound/soundinterface.h
+ * \brief   Sound enum representing sound file
+**/
+enum Sound
+{
+  SOUND_CLICK  = 0,
+  SOUND_BOUM  = 1,
+  SOUND_EXPLO  = 2,
+  SOUND_FLYh  = 3, /*!< human */
+  SOUND_FLY  = 4,
+  SOUND_STEPs  = 5, /*!< smooth */
+  SOUND_MOTORw  = 6, /*!< wheel */
+  SOUND_MOTORt  = 7, /*!< tank */
+  SOUND_MOTORr  = 8, /*!< roller */
+  SOUND_ERROR  = 9,
+  SOUND_CONVERT  = 10,
+  SOUND_ENERGY  = 11,
+  SOUND_PLOUF  = 12,
+  SOUND_BLUP  = 13,
+  SOUND_WARNING  = 14,
+  SOUND_DERRICK  = 15,
+  SOUND_LABO  = 16,
+  SOUND_STATION  = 17,
+  SOUND_REPAIR  = 18,
+  SOUND_RESEARCH  = 19,
+  SOUND_INSECTs  = 20, /*!< spider */
+  SOUND_BURN  = 21,
+  SOUND_TZOING  = 22,
+  SOUND_GGG  = 23,
+  SOUND_MANIP  = 24,
+  SOUND_FIRE  = 25, /*!< shooting with fireball */
+  SOUND_HUMAN1  = 26, /*!< breathing */
+  SOUND_STEPw  = 27, /*!< water */
+  SOUND_SWIM  = 28,
+  SOUND_RADAR  = 29,
+  SOUND_BUILD  = 30,
+  SOUND_ALARM  = 31, /*!< energy alarm */
+  SOUND_SLIDE  = 32,
+  SOUND_EXPLOi  = 33, /*!< insect */
+  SOUND_INSECTa  = 34, /*!< ant */
+  SOUND_INSECTb  = 35, /*!< bee */
+  SOUND_INSECTw  = 36, /*!< worm */
+  SOUND_INSECTm  = 37, /*!< mother */
+  SOUND_TREMBLE  = 38,
+  SOUND_PSHHH  = 39,
+  SOUND_NUCLEAR  = 40,
+  SOUND_INFO  = 41,
+  SOUND_OPEN  = 42,
+  SOUND_CLOSE  = 43,
+  SOUND_FACTORY  = 44,
+  SOUND_EGG  = 45,
+  SOUND_MOTORs  = 46, /*!< submarine */
+  SOUND_MOTORi  = 47, /*!< insect (legs) */
+  SOUND_SHIELD  = 48,
+  SOUND_FIREi  = 49, /*!< shooting with orgaball (insect) */
+  SOUND_GUNDEL  = 50,
+  SOUND_PSHHH2  = 51, /*!< shield */
+  SOUND_MESSAGE  = 52,
+  SOUND_BOUMm  = 53, /*!< metal */
+  SOUND_BOUMv  = 54, /*!< plant */
+  SOUND_BOUMs  = 55, /*!< smooth */
+  SOUND_EXPLOl  = 56, /*!< little */
+  SOUND_EXPLOlp  = 57, /*!< little power */
+  SOUND_EXPLOp  = 58, /*!< power */
+  SOUND_STEPh  = 59, /*!< hard */
+  SOUND_STEPm  = 60, /*!< metal */
+  SOUND_POWERON  = 61,
+  SOUND_POWEROFF  = 62,
+  SOUND_AIE  = 63,
+  SOUND_WAYPOINT  = 64,
+  SOUND_RECOVER  = 65,
+  SOUND_DEADi  = 66,
+  SOUND_JOSTLE  = 67,
+  SOUND_GFLAT  = 68,
+  SOUND_DEADg  = 69, /*!< shooting death */
+  SOUND_DEADw  = 70, /*!< drowning */
+  SOUND_FLYf  = 71, /*!< reactor fail */
+  SOUND_ALARMt  = 72, /*!< temperature alarm */
+  SOUND_FINDING  = 73, /*!< finds a cache object */
+  SOUND_THUMP  = 74,
+  SOUND_TOUCH  = 75,
+  SOUND_BLITZ  = 76,
+  SOUND_MUSHROOM  = 77,
+  SOUND_FIREp  = 78, /*!< shooting with phazer */
+  SOUND_EXPLOg1  = 79, /*!< impact gun 1 */
+  SOUND_EXPLOg2  = 80, /*!< impact gun 2 */
+  SOUND_MOTORd  = 81, /*!< engine friction */
+};
+
+
+/**
+ * \public
+ * \enum    SoundNext   sound/soundinterface.h
+ * \brief   Enum representing operation that will be performend on a sound at given time
+**/
+enum SoundNext
+{
+  SOPER_CONTINUE = 1, /*!< continue playing */
+  SOPER_STOP = 2, /*!< stop playing */
+  SOPER_LOOP = 3, /*!< start over */
+};
+
+
+/**
+* @class CSoundInterface
+*
+* @brief Sound plugin interface
+*
+*/
+class CSoundInterface : public CPlugin
+{
+  public:
+    CSoundInterface() {
+      //CInstanceManager::getInstance().AddInstance(CLASS_SOUND, this);
+      //m_iMan->AddInstance(CLASS_SOUND, this);
+    };
+    virtual ~CSoundInterface() = 0;
+
+    /** Function to initialize sound device
+     *  @param bool b3D - enable support for 3D sound
+     */
+    virtual bool Create(bool b3D) = 0;
+
+    /** Function called to cache all sound effect files.
+     *  Function calls \link CSoundInterface::Cache() \endlink for each file
+     */
+    virtual void CacheAll() = 0;
+
+    /** Function called to cache sound effect file.
+     *  This function is called by plugin interface for each file.
+     * @param Sound bSound - id of a file, will be used to identify sound files
+     * @param std::string bFile - file to load
+     * @return return true on success
+     */
+    virtual bool Cache(Sound bSound, std::string bFile) = 0;
+
+    /** Return if plugin is enabled
+     *  @return return true if plugin is enabled
+     */
+    virtual bool RetEnable() = 0;
+
+    /** Change sound mode to 2D/3D
+     * @param bool bMode - true to enable 3D sound
+     */
+    virtual void SetSound3D(bool bMode) = 0;
+
+    /** Return if we use 3D sound
+     * @return true if we have 3D sound enabled
+     */
+    virtual bool RetSound3D() = 0;
+
+    /** Return if we have 3D sound capable card
+     * @return true for 3D sound support
+     */
+    virtual bool RetSound3DCap() = 0;
+
+    /** Change global sound volume
+     * @param int volume - range from 0 to MAXVOLUME
+     */
+    virtual void SetAudioVolume(int volume) = 0;
+
+    /** Return global sound volume
+     * @return global volume as int in range from 0 to MAXVOLUME
+     */
+    virtual int RetAudioVolume() = 0;
+
+    /** Set music volume
+     * @param int volume - range from 0 to MAXVOLUME
+     */
+    virtual void SetMusicVolume(int volume) = 0;
+
+    /** Return music volume
+     * @return music volume as int in range from 0 to MAXVOLUME
+     */
+    virtual int RetMusicVolume() = 0;
+
+    /** Set listener position
+     * @param Math::Vector eye - position of listener
+     * @param Math::Vector lookat - direction listener is looking at
+     */
+    virtual void SetListener(Math::Vector eye, Math::Vector lookat) = 0;
+
+    /** Update data each frame
+     * @param float rTime - time since last update
+     */
+    virtual void FrameMove(float rTime) = 0;
+
+    /** Play specific sound
+     * @param Sound sound - sound to play
+     * @param float amplitude - change amplitude of sound before playing
+     * @param float frequency - change sound frequency before playing (0.5 octave down, 2.0 octave up)
+     * @param bool bLoop - loop sound
+     * @return identifier of channel that sound will be played on
+     */
+    virtual int Play(Sound sound, float amplitude=1.0f, float frequency=1.0f, bool bLoop = false) = 0;
+
+    /** Play specific sound
+     * @param Sound sound - sound to play
+     * @param Math:Vector pos - position of sound in space
+     * @param float amplitude - change amplitude of sound before playing
+     * @param float frequency - change sound frequency before playing (0.5 octave down, 2.0 octave up)
+     * @param bool bLoop - loop sound
+     * @return identifier of channel that sound will be played on
+     */
+    virtual int Play(Sound sound, Math::Vector pos, float amplitude=1.0f, float frequency=1.0f, bool bLoop = false) = 0;
+
+    /** Remove all operations that would be made on sound in channel.
+     * @param int channel - channel to work on
+     * @return return true on success
+     */
+    virtual bool FlushEnvelope(int channel) = 0;
+
+    /** Add envelope to sound. Envelope is a operatino that will be performend on sound in future like changing frequency
+     * @param int channel - channel to work on
+     * @param float amplitude - change amplitude
+     * @param float frequency - change frequency
+     * @param float time - when to change (sample time)
+     * @param SoundNext oper - operation to perform
+     * @return return true on success
+     */
+    virtual bool AddEnvelope(int channel, float amplitude, float frequency, float time, SoundNext oper) = 0;
+
+    /** Set sound position in space
+     * @param int channel - channel to work on
+     * @param Math::Vector pos - new positino of a sound
+     * @return return true on success
+     */
+    virtual bool Position(int channel, Math::Vector pos) = 0;
+
+    /** Set sound frequency
+     * @param int channel - channel to work on
+     * @param float frequency - change sound frequency
+     * @return return true on success
+     */
+    virtual bool Frequency(int channel, float frequency) = 0;
+
+    /** Stop playing sound
+     * @param int channel - channel to work on
+     * @return return true on success
+     */
+    virtual bool Stop(int channel) = 0;
+
+    /** Stop playing all sounds
+     * @return return true on success
+     */
+    virtual bool StopAll() = 0;
+
+    /** Mute/unmute all sounds
+     * @param bool bMute
+     * @return return true on success
+     */
+    virtual bool MuteAll(bool bMute) = 0;
+
+    /** Start playing music
+     * @param int rank - track number
+     * @param bool bRepeat - repeat playing
+     * @return return true on success
+     */
+    virtual bool PlayMusic(int rank, bool bRepeat) = 0;
+
+    /** Restart music
+     * @return return true on success
+     */
+    virtual bool RestartMusic() = 0;
+
+    /** Susspend paying music
+     * @return return true on success
+     */
+    virtual void SuspendMusic() = 0;
+
+    /** Stop playing music
+     * @return return true on success
+     */
+    virtual void StopMusic() = 0;
+
+    /** Check if music if playing
+     * @return return true if music is playing
+     */
+    virtual bool IsPlayingMusic() = 0;
+};
+