Development:Compiling

After having installed all of Adonthell's Dependencies and obtained the source code from Git you can finally compile it. Please follow the build instructions and see the known issues and hints specific to your OS if you get stuck. For further details, refer to the instructions included with the source code.

Engine Build Instructions

For all Systems, we assume a POSIX-like environment with GNU compiler and make and a shell. Where supported, you should use the CMake based build system, but we'll probably keep the GNU autotools around for some while too. In both cases, an out-of-source build is recommended.

CMake

Inside the adonthell directory type:

 mkdir ../adonthell-build && cd ../adonthell-build
 cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DDEVBUILD=1 ../adonthell
 make
 sudo make install

Including the optional -DDEVBUILD=1 parameter will enable a developer build, which gives you unit tests and debug symbols but requires additional dependencies; if you are compiling Adonthell as an end user, you probably won't want to turn this on.

GNU Autotools

Inside the adonthell directory type:

 ./autogen.sh
 mkdir ../adonthell-build && cd ../adonthell-build
 ../adonthell/configure --enable-dev-build --prefix=/usr/local
 make
 * $ sudo DESTDIR=$PATH make install

• Note :- There is an issue/bug/regression in automake 1.11 due to which automake does not honor the 'sudo make install' command and you have to explicitly state the same as shown above. This has been discussed in the mailing list as well. As and when the bug is fixed and automake gets the older behavior back this note will disappear.

Including the optional --enable-devbuild parameter will enable a developer build, which gives you unit tests and debug symbols but requires additional dependencies; if you are compiling Adonthell as an end user, you probably won't want to turn this on.

Customizing the Installation

Due to the modular structure of the Adonthell Engine, it needs to be properly installed on the system before it is ready to use. The recommended location for that is /usr/local, but if you don't want to pollute your system or don't have root privileges, you can chose any other location. Below you will find the steps required to make it work:

CMake

There two commandline options that control the installation path are:

1. -DCMAKE_INSTALL_PREFIX=/path/to/adonthell: controls where the adonthell libraries and headers are installed.
2. -DPYTHON_SITE_PACKAGE_DIR=/path/to/py-modules: controls where python bindings for adonthell are installed.

GNU Autotools

The installation path is defined using the --prefix=/path/to/adonthell option.

Preparing the Environment

After installing to a custom location, the environment needs to be prepared in order to use the Adonthell engine. This is done by updating the following environment variables

1. PATH: controls where the system looks for executables
2. PYTHONPATH: controls where Python looks for additional modules
3. PKG_CONFIG_PATH: controls where pkg-config looks for package information (only if you intend to compile the Adonthell tools as well).

Assuming that you specified $HOME/local/adonthell as prefix (and $HOME/local/py-modules for python packages) you would set the variables as follows:

   $ export PATH=$PATH:$HOME/local/adonthell/bin
   $ export PYTHONPATH=$PYTHONPATH:$HOME/local/py-modules
   $ export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:$HOME/local/adonthell/lib/pkgconfig

You can add those lines to the end of your $HOME/.bashrc file if you don't want to type them in everytime you open a new shell (assuming that you are indeed using a bash-like shell).

Testing the Installation

After Adonthell has been compiled and installed successfully, you can verify that everything works as expected by running one of the test programs found in the test directory within adonthell-build:

 adonthell-build$ cd test/
 adonthell-build/test/$ ./worldtest -g ../../adonthell/test data

This should bring up a small map with some structures to climb and jump and a NPC to talk to.

Tools Build Instructions

Now that you have a working Adonthell installation on your system, you are ready to build the Adonthell Tools, if you so desire, by following these instructions.

OS Specifc Notes

GNU/Linux or *BSD

Most, if not all, dependencies should come with your distribution. Just make sure to install the corresponding development packages. In case that you require a newer version of a library or tool than comes with the distribution, you should be able to compile and install it yourself without much trouble.

In general, you should be able to use any IDE of your choice as long as it is not messing with the Makefiles. If you have a particular good setup, feel free to share the instructions.

MacOS X

Like on Linux, you can get most of the dependencies in the form of precompiled binaries, e.g. from the Fink Project. If you need an IDE, use XCode.

Windows

Since Adonthell requires the GNU Compiler Collection (GCC), your best choices are either Cygwin or MinGW. In order to produce "true" Windows binaries that do not depend on the Cygwin POSIX layer (cygwin1.dll), setting up a development environment with MSYS/MinGW is recommended. A good IDE to use would be Eclipse, which is becoming supported directly by CMake.

Other OS

Sorry, right now you are on your own. But if your system has a recent port of GCC and is supported by SDL, chances are pretty good that you will get Adonthell working. Please update this space if you did :-).

Known Problems

ImportError: No module named adonthell.world

In case you have multiple versions of Python installed, CMake can get confused. If, during the initial run of cmake you get a mix of versions like seen below, Adonthell will not work correctly.

 Found PythonLibs: /usr/lib/python2.4/config/libpython2.4.so
 -- Python has been found:
 -- CFLAGS : /usr/include/python2.4
 -- LDFLAGS: /usr/lib/python2.4/config/libpython2.4.so
 -- Found PythonInterp: /usr/bin/python2.5
 -- VERSION: python2.5
 -- LDEXTRA: -lm;-lpthread -ldl  -lutil
 -- SITEPKG: /usr/lib/python2.5/site-packages

The only workaround for that is removing any superfluous Python installations, then running cmake again.