Import documentation from old dev wiki

I also updated all outdated information I could find, please tell me if I missed something

Model format documentation needs an update

CONTRIBUTING.md

@@ -3,24 +3,81 @@
 So you want to contribute to Colobot: Gold Edition? That's awesome! Before you start, read this page, it contains a lot of useful information on how to do so.
 
 ## General information
-Before you start, read more about technical details of the project. They can be found in our [Game Design Document](http://compiled.colobot.info/jenkins/job/colobot-gold-gdd/lastSuccessfulBuild/artifact/Colobot_Gold_Edition-Game_Design_Document.pdf) ([live editor](http://krzysh.pl:3000/project/545e90d99e8bceed2284797e)).
+Before you start, read more about technical details of the project. They can be found in:
 
-You may also find some useful information on the our (outdated) [dev wiki](http://colobot.info/wiki/dev).
+* [Developer README](README-dev.md)
+* [Doxygen documentation](http://compiled.colobot.info/job/colobot/job/colobot/job/dev/Doxygen/)
+* [Game Design Document](http://compiled.colobot.info/job/colobot/job/colobot-misc/job/master/lastSuccessfulBuild/artifact/Colobot_Gold_Edition-Game_Design_Document.pdf)
 
 ## Before you start coding
 * If you want to fix a bug, please first check the related [issue on GitHub's bug tracker](https://github.com/colobot/colobot/issues). If there isn't one, make it.
 * If you want to add a new feature or make any change to gameplay, please first discuss it either [on the forums](http://colobot.info/forum) or in the related issue on GitHub. When your issue gets *accepted* label, that means that your suggestion got accepted and is waiting for somebody to work on it. Always wait for your suggestion to be accepted before you start writing any code.
 * Before you start, check *"Assignee"* field in the issue and read the comments to see if nobody else is working on the same issue. If somebody is assigned to it, but there was no activity for a long time, you can take it over. Also, please post a comment on the issue that you want to help us, so other people don't waste time working at that issue in the same time.
 
 ## Coding style
-See the [related page on dev wiki](http://colobot.info/wiki/dev/Coding_rules) for general guidelines, or [this file](https://github.com/colobot/colobot-lint/blob/master/RULES.md) for detailed description.
+When writing code, please adhere to the following rules:
 
-See [colobot-lint repository](https://github.com/colobot/colobot-lint) for automated tool that checks the coding style.
+* Indent with spaces, 1 indentation level = 4 spaces. Unix line endings. And don't leave whitespace at the end of lines. Thank you.
+* Put braces in new lines.
+
+Like that:
+```c++
+   if (a == b)
+   {
+      // ...
+   }
+   else
+   {
+      // ...
+   }
+```
+NOT like that:
+```c++
+   if (a == b) {
+      // ...
+   } else {
+      // ...
+   }
+```
+You may omit braces if there is only one line in block:
+```c++
+    if (a == b)
+      doStuff();
+```
+* Name functions beginning with upper case, e.g. `FooBar()`
+* Name classes beginning with C, e.g. `class CSomeClass`
+* Name accessors like so: `SetValue()` and `GetValue()`
+* Name structs and enums beginning with uppercase letter, e.g. `struct SomeStruct`
+* Enum values should begin with a prefix and underscore and should be all uppercase, e.g. `SOME_ENUM_VALUE`
+* Use constant values instead of #define's, e.g. `const int MAX_SPACE = 1000;` instead of `#define MAX_SPACE 1000` (names should be all uppercase as in example)
+* Don't use C-style casts, e.g. `(type)(foo)`. Use new C++-style casts, e.g. `static_cast<type>(foo)`.
+* Don't use global variables - use static class members whenever possible.
+* Provide full namespace qualifier wherever possible, e.g. Math::MultiplyMatrices to avoid confusion.
+* Document the new code in Doxygen. Even a short description is better than nothing at all. Also, if you are changing/rewriting old code, please do the same.
+* Put comments in your code but not explaining its structure or what it does (Doxygen is for that), but **why** it does so.
+* Whenever possible, please write unit tests for your code. Tests should go into `test/` subdirectory in each of the code directories.
+* You can use STL classes where needed.
+* Throwing exceptions is allowed, with the exception of CBot code (which has no automated memory management yet, so memory leaks could possibly occur)
+
+Also, when writing `#include`s:
+
+* first - in `.cpp` modules - associated `.h` header, e.g. `#include "app/app.h"` in `app.cpp`
+* then - local includes, e.g. `#include "common/logger.h"` (listed in alphabetical order for clarity)
+* and last - global includes, e.g. `#include <SDL/SDL.h>`, `#include <vector>`
+
+We also have an automated tool for checking the code style. See [colobot-lint repository](https://github.com/colobot/colobot-lint) for details.
 
 If your pull request breaks the coding style, you will have to fix it before it gets merged.
 
+## Commiting rules
+Please adhere to the following rules:
+* Commits should have meaningful descriptions.
+* Commits should not break the build nor tests.
+* Changes in one commit should not be too extensive, unless necessary.
+* Merges to *master* branch must be discussed beforehand and should include fully finished features if possible.
+
 ## Submitting pull requests
-After you finish working on your issue and want your code to be merged into the main repository, you should submit a **pull request**. Go to [this page](https://github.com/colobot/colobot/pulls) and select "New pull request". All pull request should ALWAYS be submitted to the *dev* branch. After your PR gets reviewed by our development team, it will be merged to *dev* branch, and on the next release - to the *master* branch.
+After you finish working on your issue and want your code to be merged into the main repository, you should submit a **pull request**. Go to [this page](https://github.com/colobot/colobot/pulls) and select "New pull request". All pull requests should ALWAYS be submitted to the *dev* branch. After your PR gets reviewed by our development team, it will be merged to *dev* branch, and on the next release - to the *master* branch.
 
 If you need more help, see [GitHub's help page on Pull Requests](https://help.github.com/articles/using-pull-requests/).
 

Doxyfile.in

@@ -859,7 +859,7 @@ EXAMPLE_RECURSIVE      = NO
 # that contain images that are to be included in the documentation (see the
 # \image command).
 
-IMAGE_PATH             =
+IMAGE_PATH             = "@CMAKE_CURRENT_SOURCE_DIR@/docimg"
 
 # The INPUT_FILTER tag can be used to specify a program that doxygen should
 # invoke to filter for each input file. Doxygen will invoke the filter program

INSTALL-MSYS2.md

@@ -0,0 +1,161 @@
+This guide is written to help you with a process of compilation (the newest version of) Colobot: Gold Edition in a Windows environment. [MSYS2](http://sourceforge.net/projects/msys2/) will be used.
+
+Why MSYS2?
+----------
+
+You might ask, why you would use this method instead of the other one? Firstly, let's answer a question "why not just use MSYS?".
+
+The biggest problem with the compilation is **3rd party dependencies**. Installing compiler and tools like Git or Cmake is really nothing compared to trying to install endless number of libraries. Why is it that hard, you ask? Well, we, as the developers, would willingly help with this process for example by providing a package with all the needed stuff. Actually, there was a package once, but IT develops fast and new versions of software are released, including not only compiler, but also the libraries. This means that our package might work for compiler v.XX.1, but for v.XX.2 it might not. One of the programmers may use a new feature and Colobot may not compile with lib v.YY. Let's be honest -- it's too hard to provide new packages every time a new version of *something* comes up, at least for us, developers. You can check for yourself if current package works, it probably not.
+
+Here comes MSYS2. It provides everything that MSYS has and much more. It is basically a whole Linux-style development environment for Windows. Most importantly, it gives you a package manager, which makes not only installation of all the needed stuff easy, but also can take care of updating it with little human effort.
+
+Also, with the broken package, if you don't want to manually compile and install all the libraries, MSYS2 might be the only way to go.
+
+Guide
+-----
+
+Compiling in Windows is harder than in most Linux distributions, but with MSYS2 it isn't impossible.
+
+### Setting Up an Environment
+
+Steps in this section needs to be done only once. After this, you can basically develop Colobot the same way you would do it normally (well, there might be a problem with integrating Windows-only IDEs).
+
+#### Installation of MSYS2
+
+Read this page really carefully: <http://sourceforge.net/p/msys2/wiki/MSYS2%20installation/> . By following it, you should install and configure MSYS2 without major problems.
+
+#### TIP
+When you face any problems during this guide or anywhere in the future, the first thing you should do is to close all MSYS2 processes and run `autorebase.bat` script (it's in the main MSYS2 folder), especially after installation and updating. If you don't do it, odd problems might appear, like CMake not detecting GCC.
+
+#### Running
+
+Now you need to install `MinGW-w64 toolchain`. Open `MSYS2 Shell` and enter the following command:
+
+```sh
+pacman -S mingw-w64-i686-toolchain
+```
+
+**Warning:** Commands shown in this guide are for 32-bit operating system. If you have 64-bit OS, you must replace all `i686` occurrences with `x86_64`.
+
+MSYS2 creates a new environment (with all the "system" variables set properly) during this installation. You have done that from default `MSYS2 Shell`. To work with GOLD, you need to switch. There are two ways of "opening" an environment you can work in:
+
+1. Open MSYS2 Shell and enter
+
+```sh
+export PATH=/mingw32/bin:$PATH
+```
+
+or
+
+```sh
+export PATH=/mingw64/bin:$PATH
+```
+
+2. Open `MinGW-w64 Win32 Shell` (or `MinGW-w64 Win64 Shell`)
+
+You must do one of these two steps every time you want to compile GOLD.
+
+#### TIP
+You can add "Open MSYS2 Shell here" to the context menu using registry. Save the following code as `.reg` file and run it.
+
+```
+Windows Registry Editor Version 5.00
+[HKEY_CLASSES_ROOT\Directory\Background\shell\open_msys2]
+@="Open MSYS2 here"
+[HKEY_CLASSES_ROOT\Directory\Background\shell\open_msys2\command]
+@="c:\\msys32\\usr\\bin\\mintty.exe /bin/sh -lc 'cd \"$(cygpath \"%V\")\"; export PATH=\"/mingw32/bin:$PATH\"; exec bash'"
+[HKEY_CLASSES_ROOT\Folder\shell\open_msys2]
+@="Open MSYS2 here"
+[HKEY_CLASSES_ROOT\Folder\shell\open_msys2\command]
+@="c:\\msys32\\usr\\bin\\mintty.exe /bin/sh -lc 'cd \"$(cygpath \"%V\")\"; export PATH=\"/mingw32/bin:$PATH\"; exec bash'"
+```
+
+Remember to modify the paths before you use it so they fit in your installation.
+
+#### Installation of Tools and Dependencies
+
+To compile Colobot you need:
+
+- cmake
+- git
+- make
+- gcc
+
+Install them:
+
+```sh
+pacman -S msys2-devel git make mingw-w64-i686-cmake mingw-w64-i686-gcc
+```
+
+It's a good time to configure git or even ssh if you plan to push to the remote repository.
+
+When you are done, you can finally get the greatest benefit of using MSYS2. You are going to install required 3rd party libraries. This is how you do it:
+
+1. Find names of all required dependencies. They are listed in the [main INSTALL.md file](INSTALL.md#compiling-on-linux)
+
+2. Find each library using
+
+```sh
+pacman -Ss dependency-name
+```
+
+3. Install each library using
+
+```sh
+pacman -S package-name
+```
+
+Easy, isn't it?
+
+If you are lazy, you can just use this one-line command, although there is no guarantee it will work or install everything (might be out of date):
+
+```sh
+pacman -S mingw-w64-i686-boost mingw-w64-i686-glew mingw-w64-i686-libpng gettext mingw-w64-i686-gettext mingw-w64-i686-libpng mingw-w64-i686-libsndfile mingw-w64-i686-libvorbis mingw-w64-i686-libogg mingw-w64-i686-openal mingw-w64-i686-SDL2 mingw-w64-i686-SDL2_image mingw-w64-i686-SDL2_ttf
+```
+
+You should now have everything set up and working. You can close all instances of MSYS2 and autorebase to ensure everything installed properly.
+
+### Compilation of GOLD
+
+You could say that you have a small Linux inside of your Windows right now. To compile GOLD just follow the instructions for Linux that are available in the repository (https://github.com/colobot/colobot/blob/dev/INSTALL.md\#compiling-on-linux).
+
+**Warning:** You must add `-G"MSYS Makefiles"` argument to `cmake`. For example, when you want to build a developer version:
+
+```sh
+cmake -DCMAKE_BUILD_TYPE=Debug -DDEV_BUILD=1 -G"MSYS Makefiles" ..
+```
+
+### Dlls
+
+Your executable should run fine if you run it from the shell (like `./colobot` in a folder with a compiled binary). However, it will rather not run if you run it "from Windows", like by double clicking the shortcut. You will get error telling you that some dlls are missing. It's normal on Windows, so don't panic. Linker do dynamic linking by default, so binary must be distributed with the libraries stored in binary dll files. You can provide them in a few ways.
+
+#### PATH
+
+Add `C:\msys32\mingw32\bin` to your environment variable `PATH`.
+
+RMB on Computer -&gt; Click Properties -&gt; Advanced system settings -&gt; Environment Variables -&gt; Edit Path
+
+Be careful though. If you have any other installation of MinGW or other tools like FPC, git and so on, this might result in conflicts (for example two `gcc.exe` files) and the effects are unpredictable.
+
+You can use `PATH` also in other way: just copy all the dlls from `C:\msys32\mingw32\bin` to a place that's already in the `PATH`. This might result in a mess though, because you will mix files for GOLD with something else.
+
+#### Copy
+
+It's the way how it's done in most applications distributed for Windows. Just copy all the needed dlls to a folder with the game. All of them are in `C:\msys32\mingw32\bin`.
+
+You can simply try to run a game and each time it gives you an error copy a missing dll to folder with an executable (like `C:\Program Files\colobot`). Or, you can use this smart command (thanks @krzys-h!):
+
+```sh
+ldd colobot.exe | grep -v /c/WINDOWS/ | cut -d ' ' -f 3 | while read -r line; do cp $line /c/path/to/the/game; done
+```
+
+#### Static Linking
+
+You can try to compile GOLD with static linking. Nobody have done that (at least in Windows) yet, but it's possible in theory. If you did it, please, let us know!
+
+The End
+-------
+
+Hope, this guide helped you with using Windows as a development environment especially for Colobot.
+
+This method was first used and described by @MrSimbax. Script for gaining all the needed dlls was written by @krzys-h.

INSTALL.md

@@ -40,7 +40,7 @@ statically linked Win32 binaries. More information is available in
 
 #### Compiling with MSYS2/MinGW-w64
 
-See [this wiki page](http://colobot.info/wiki/dev/Compiling_GOLD_on_Windows_with_MSYS2) for details.
+See the [INSTALL-MSYS2.md](INSTALL-MSYS2.md) file for details.
 
 #### Compiling with MSVC
 
@@ -125,7 +125,7 @@ So if you provided prefix "/some/prefix", you can run:
 
 ### Compiling on MacOS X
 
-As of 0.1.2-alpha, we have added MacOS X support. See [INSTALL-MacOSX.md](https://github.com/colobot/colobot/blob/master/INSTALL-MacOSX.md)
+As of 0.1.2-alpha, we have added MacOS X support. See [INSTALL-MacOSX.md](INSTALL-MacOSX.md)
 file for details.