CompilingWesnoth/fr

Other languages:

• English
• Español
• Français

[edit]Compiling Wesnoth

Platforms Linux or Unix macOS [1.14, master] Windows [1.14 (VS2019), master (VS2015/VS2017), master (VS2019)]

Compiler Wesnoth

Cette page présente comment compiler le jeu dans un environnement UNIX. Les moteurs de productions utilisés sont scons et cmake.

Voir aussi:

• Compiler Wesnoth sur Windows (en)
• Compiler Wesnoth sur FreeBSD (en)
• Compiler Wesnoth sur macOS (en)
• Compiler Wesnoth sur Syllable (en)
• Compiler Wesnoth sur SuSE (en) -Pour installer sur SuSE 10.0

Pour plus de détails, voir le fichier INSTALL dans le code source.

Pré-requis

Avant tout, assurez-vous d'avoir un compilateur C++ tel que gcc .

Pour compiler Wesnoth 1.14, les bibliothèques suivantes doivent être installé sur votre système. Beaucoup de distributions Linux séparent les paquets de développement des bibliothèques. Si c'est le cas pour votre distribution, vous devez choisir le paquet development (ce dernier comprend les fichiers d'entêtes "headers" requis pour compiler). Vous aurez aussi besoin des paquets runtime pour lancer Wesnoth.

• libsdl >= 2.0.4 (https://www.libsdl.org/)
• sdl-image >= 2.0.0 (avec PNG and JPEG support) (https://www.libsdl.org/projects/SDL_image/)
• sdl-mixer >= 2.0.0 (avec Vorbis support) (https://www.libsdl.org/projects/SDL_mixer/)
• sdl-ttf >= 2.0.12 (https://www.libsdl.org/projects/SDL_ttf)
• libboost >= 1.50.0 (https://www.boost.org/)
  • Si votre distribution décompose boost en plusieurs logiciels, prennez boost_filesystem, boost_iostreams, boost_locale, boost_random, boost_regex, boost_asio, boost_program_options, boost_system, boost_thread.
  • Vous aurez besoin de gzip et de bzip2 pour boost_iostreams
  • Vous devez utiliser l'icu de boost_locale
• libcrypto (https://wiki.openssl.org/index.php/Libcrypto_API)
• bzip2 (http://www.bzip.org/)
• zlib (en théorie déjà requis pour libsdl-image, http://www.zlib.org/)
• libvorbisfile (https://xiph.org/vorbis/)
• pangocairo >= 1.22.0 (http://www.pango.org/)
• cairo >= 1.10.0 (https://www.cairographics.org/)
• libfontconfig >= 2.4.1 (https://www.freedesktop.org/software/fontconfig/front.html)

Ces bibliothèques sont facultatives:

• libdbus-1 (only required desktop notifications, https://www.freedesktop.org/wiki/Software/dbus)
• libreadline (command history and history expansion in the built-in Lua console)
• fribidi >= 0.10.9 (only required for RTL languages)

Pré-requis supplémentaires pour version dev

À partir de Wesnoth 1.15, les pré-requis suivants ont été ajoutés:

• Compilateur pour C++14 (GCC 5.0/Clang 3.8 ou plus)
• libboost >= 1.56.0
• sdl-ttf n'est plus nécessaire

Moteurs de production

Pour pouvoir produire des fichiers binaires (exécutables), vous aurez besoin d'un moteur de production. Vous pouvez utiliser soit:

• scons >=1.0 (https://www.scons.org/)

ou soit:

• cmake >=2.8.5 (https://www.cmake.org/)

Récupérer facilement les dépendances sous Linux

Si votre distribution Linux est basée sous Debian (comme Ubuntu ou Linux Mint) et qu'elle fournit une version relativement récente de Wesnoth, il ne vous suffira peut-être que d'entrer les deux commandes ci-dessous pour récupérer toutes les dépendances nécessaires pour la dernière version stable de Wesnoth (pour la version en développement, entrer tout de même les commandes puis voir les pré-requis supplémentaires plus haut):

sudo apt build-dep wesnoth-1.12
sudo apt install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libboost-all-dev libvorbis-dev libcairo2-dev libpango1.0-dev libssl-dev libreadline-dev cmake make scons pkgconf

Pour tester le code, Wesnoth utilise des images Docker. Vous pouvez consulter les paquets installés au sein de ces images ici. (Notons que les versions des paquets dépendent aussi du système d'exploitation utilisé).

La commande suivante permet d'installer les dépendances pour Wesnoth 1.14 sur openSuSE. Toutes les dépendances sont dans un dépôt standard OSS:

sudo zypper install libSDL2-devel libSDL2_image-devel libSDL2_mixer-devel libSDL2_ttf-devel boost-devel libopenssl-devel libbz2-devel zlib-devel libvorbis-devel pango-devel cairo-devel fontconfig-devel dbus-1-devel readline-devel fribidi-devel gettext-runtime cmake make scons pkg-config

Pour installer les dépendances pour Wesnoth 1.14 pour CentOS, RedHat ou Fedora, utiliser cette commande. Toutes les dépendances sont dans un dépôt standard OSS. Vous pouvez aussi utiliser yum à la place de dnf:

sudo dnf install SDL2-devel SDL2_image-devel SDL2_mixer-devel SDL2_ttf-devel boost-devel openssl-devel bzip2-devel zlib-devel libvorbis-devel pango-devel cairo-devel fontconfig-devel dbus-devel readline-devel fribidi-devel gettext cmake make scons pkgconf-pkg-config

Cette commande installe les dépendances pour Wesnoth 1.14 sous Arch Linux:

sudo pacman -S sdl2 sdl2_image sdl2_mixer sdl2_ttf boost-libs openssl bzip2 zlib libvorbis pango cairo fontconfig dbus readline fribidi boost gettext cmake make scons pkgconf

Code source

Vous pouvez télécharger le code source:

• Download — Des versions publiques
• WesnothRepository — Des versions en cours de développement via le dépôt Git officiel.

Compiling

Nous n'avons pas encore de moteur de production officiel. SCons et Cmake semblent tous deux de bon choix et ils devraient pour le moment être bien supportés.

Cependant, SCons a l'avantage d'être facile à utiliser car il a moins besoin d'être configuré et il est très utilisé par la communauté actuellement. Cmake de son côté est utilisé pour certaines versions mais n'est pas systématiquement testé.

Si une configuration venait à échouer, vous pouvez essayer de regarder dans les fichiers log (par exemple build/config.log pour SCons) afin d'obtenir plus de détails. En utilisant SCons, une vérification peut échouer par erreur à cause du cache. Si cela vous arrive, utilisez l'option --config=force pour forcer le relancement.

Building with SCons

To build using SCons, simply type

$ scons 

in the Wesnoth top-level directory. This will perform the equivalent of "configure --enable-editor --enable-tools; make" under autotools, buiding all client-side tools. To find out more about build options, type

$ scons --help

Equivalents of many configure options will be available, and you can easily build individual targets such as wesnothd.

Because scons checks for out-of-dateness with MD5 checksums of a target's ancestors and its build environment (including compiler and linker flags), the "make clean" and "make uninstall" preliminaries that you need for safety under autotools won't be necessary.

Tips

Good options to use with scons are

• ctool=clang

This uses clang instead of gcc, which is empirically significantly faster (about 2x)

• ccache=true

Enables ccache.

If you have ccache available on your system, and you are using git, then this is highly recommended, it can enable you to switch branches and rebuild in minutes.

• build=release vs. build=debug

Determines whether you build with -O3 optimizations, or -O0 with debugging symbols.

Keep in mind this preference, like the others mentioned, are "sticky" and will be remembered in the future.

• -j 2, or --jobs 4, etc.

Build parallelism: This tells scons to run multiple compilation steps in parallel. The number of jobs you tell it to run at once should not be larger than the number of cores that you have.

Building with CMake

CMake supports so called "out of tree" builds. That is you compile in a place completely different from the folder where your checkout is in. To do so, simply create a folder to compile in and call cmake with the path to your checkout. Of course you can also just call cmake from the checkout folder with a plain cmake ., but this is boring, isn't it?

To have cmake build wesnoth in a new dir called cmake_build_dir, just use these commands (PATH/TO/WESNOTH/TOPLEVEL-DIR means the base of your repository checkout or the folder where you extracted the tarball to, not src/ in there!):

$ mkdir cmake_build_dir
$ cd cmake_build_dir
$ cmake PATH/TO/WESNOTH/TOPLEVEL-DIR

This will perform the equivalent of "configure --enable-editor --enable-server" under autotools. To get an interface for editing settings, just type

$ ccmake .

in the cmake_build_dir. When done with your changes hit 'c' to configure and 'g' to generate the files and exit. In general you can either add commands to your cmake PATH/TO/WESNOTH/TOPLEVEL-DIR call, or change the parameters later on via ccmake or a cmake gui. Equivalents of many configure options are be available.

In the 2nd step you just have to build the game. This is done as with autotools using

$ make

This by default builds all the targets you activated. If you want to you can also just build specific targets like wesnothd.

Because CMake checks for out-of-dateness, the "make clean" and "make uninstall" preliminaries that you need for safety under autotools won't be necessary.

Install / Uninstall

Become superuser, so that you have permission to install or uninstall.

$ su
  Password: /*doesn't show*/

Now that you have permission, proceed

Using SCons

If you are using SCons, install with:

# scons install

And uninstall with:

# scons uninstall

Using CMake

If you are using CMake, installing basically happens the same way as when using autotools. When authorized as admin (see above), just type this:

# make install

Running the game without installing

After compiling it is also possible to just run the game without installing it. All you have to do is execute the compiled binary and provide the path to the data location as argument. This looks e.g. like this:

$ ./wesnoth

or, if you compiled outside the place where you have your repository checkout or the extracted tarball (lets assume this content lies in ../wesnoth-1.14):

$ ./wesnoth ../wesnoth-1.14/

See also

• UsingSourceinstall