Liquid War 6

Up: (dir)   [Contents][Index]

Top

Liquid War 6, a unique multiplayer wargame.

Table of Contents


Next: , Up: Top   [Contents][Index]

1 Introduction

Read this chapter to discover Liquid War 6.


Next: , Up: Introduction   [Contents][Index]

1.1 In a nutshell

Liquid War 6 is a unique multiplayer wargame. Your army is a blob of liquid and you have to try and eat your opponents. Rules are very simple yet original, they have been invented by Thomas Colcombet. It is possible to play alone against the computer but the game is really designed to be played with friends, on a single computer, on a LAN, or on Internet.

An older version, Liquid War 5, is available, but is not part of the GNU Project. Only Liquid War 6 is part of the GNU Project, it is a complete rewrite.

The official page of Liquid War 6 is http://www.gnu.org/software/liquidwar6/. For more information, you can read the Wikipedia article about Liquid War.


Next: , Previous: , Up: Introduction   [Contents][Index]

1.2 Project status

1.2.1 What works, and what does not (yet)

As of today, the game is in beta state. It can be installed, and you can toy arround with. You can even play with. It is still far from being complete as some key features are still missing.

What works:

In the near future:

In the long run:

You might be interested in checking the following URLs, which give a view on opened tasks and bugs:

1.2.2 What has changed since Liquid War 5.x?

Liquid War 6 is a complete rewrite of Liquid War 5. The rewrite started in 2005. So a good question is “was the rewrite worth it?”...

Here’s a list of key improvements:

The most interesting change is still to come, and concerns network games.

Stay tuned.

1.2.3 Revision history

Liquid War 6 releases are “codenamed” after famous, historical, real or mythical characters. Here is a short revision history. For details, see the ChangeLog and NEWS files distributed with the game. Additionnally, there’s an ever-increasing “stamp” number which is incremented each time a build is done with a different source. Latest versions use the stamp as the revision number (the version 3rd number).

1.2.4 Road map

The game will probably be labelled “6.0.0” when network mode is up and running. Until then there will probably be other improvements concerning gameplay and appearance (“eye candy”). There’s a balance to keep between the major goals such as “make that network thingy work” and the very real fact that “hacking must be fun”.


Previous: , Up: Introduction   [Contents][Index]

1.3 How you can help

1.3.1 Help GNU

Please remember that development of Liquid War 6 is a volunteer effort, and you can also contribute to its development. For information about contributing to the GNU Project, please read How to help GNU.

1.3.2 Todo list

Here’s a short list of todo items. It is probably too early to start hacking the core engine itself, for it is still under heavy development, might undergo major rewrites, and it’s hard for documentation to keep up with the reality of the code. However, there are still many things to do.

Feel free to join the mailing-lists, this is clearly the best place to start with.

There’s also a list of opened tasks on Savannah at http://savannah.gnu.org/task/?group=liquidwar6 which you can browse online. Maybe there’s some task for you!

Alternatively, you can contact Christian Mauduit.


Next: , Previous: , Up: Top   [Contents][Index]

2 User’s manual

The Liquid War 6 user’s manual hopefully contains any usefull information to install the program and play the game. If you just want to enjoy Liquid War 6 without diving into map creation and programming, this is just for you.


Next: , Up: User's manual   [Contents][Index]

2.1 Mailing lists

2.1.1 General discussion

The main discussion list is <help-liquidwar6@gnu.org>, and is used to discuss all aspects of Liquid War 6, including installation, development, game strategies, and whatever subject players and hackers might want to talk about, provided it is Liquid War 6 related. If you don’t know on which list to subscribe, this is the one.

To subscribe to it, please send an empty mail with a Subject: header line of just "subscribe" to the -request list, that is <help-liquidwar6-request@gnu.org>.

You can also subscribe to the list using the Mailman web interface for help-liquidwar6 and consult help-liquidwar6 archives.

2.1.2 Announcements

Announcements about LiquidWar 6 are made on <info-liquidwar6@gnu.org>. Subscribe to it to be informed of major releases, and other significant news.

To subscribe to it, please send an empty mail with a Subject: header line of just "subscribe" to the -request list, that is <info-liquidwar6-request@gnu.org>.

You can also subscribe to the list using the Mailman web interface for info-liquidwar6 and consult info-liquidwar6 archives.

Please also consider reading the latest news on Savannah.

2.1.3 Bugs

There is also a special list used for reporting bugs, <bug-liquidwar6@gnu.org>. Please try and describe the bug as precisely as possible. The more accurate the description, the more chances it will get to be fixed.

While this is the standard GNU way of reporting bugs, modern SPAM standards make it very hard to filter real bug reports from junk on this list. It is more convenient to use a web interface, the URL is: http://savannah.gnu.org/bugs/?func=additem&group=liquidwar6 and you’re really encouraged to use it instead of sending emails.

Please take a look at the bug list before submitting new bugs.

2.1.4 IRC channel

IRC can be an interesting alternative to mailing-lists. There’s an open channel dedicated to Liquid War on freenode.net, you can access it on irc://irc.freenode.net/liquidwar that is, channel #liquidwar on irc.freenode.net.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.2 Getting the game

2.2.1 Download source

Liquid War 6 can be found on http://download.savannah.gnu.org/releases/liquidwar6/ and http://www.ufoot.org/download/liquidwar/v6/.

Downloading the latest file from this place, and compile it yourself on your computer with a classical ./configure && make && make install is the recommended way to install Liquid War 6.

2.2.2 Download binaries

Some binary packages might be available. Your mileage may vary.

GNU/Linux based systems are supported, through Debian .deb and Red Hat RPM packages. There is also a Microsoft Windows installer.

However these binaries are not necessarly available for every single version of the game.

2.2.3 GIT repository

Latest work in progress versions can be obtained with GIT. Here’s the typicall command which will fetch the latest version:

git clone git://git.sv.gnu.org/liquidwar6.git

If you are behing a firewall and can’t use the native GIT protocol, you can rely on the (slower) http protocol:

git clone http://git.sv.gnu.org/r/liquidwar6.git

You can browse the code online, consult log summary, and in a general manner “follow” the project on http://git.savannah.gnu.org/gitweb/?p=liquidwar6.git and http://git.savannah.gnu.org/cgit/liquidwar6.git.

Beware, git does not contain all the files included in the official source tarball. For instance, the ./configure script is not present. You need to run :

autoreconf
./configure
make
make install

The autoreconf call is really mandatory the first time, autoconf is not enough. You will also need all the prerequisites needed to build the docs, generally speaking, getting the source from git requires more tools to build the package than picking a ready-to-use tarball.

2.2.4 Daily snapshots

Alternatively, you can download daily snapshots on http://www.ufoot.org/liquidwar/v6/snapshots/ These files used to be built every day, now they are generated by Jenkins whenever there’s a source change (commit). A simple make is done before generating source tarballs however a make distcheck is performed before generating binaries, therefore sometimes you can have the source but no associated tarballs.

Beware of revision numbers, snapshots can make you believe version X.Y is out when it’s only a release candidate at best, and most of the time just a work-in-progress.

Still, if you want bleeding edge versions, this is the way to go.

Documentation is automatically updated as well, and available on http://www.ufoot.org/liquidwar/v6/doc/.

2.2.5 Check integrity

Most binary packages (at least .deb and RPM GNU/Linux binaries) should be signed using GnuPG. The following keys are used when generating upstream/vendor packages:


Next: , Previous: , Up: User's manual   [Contents][Index]

2.3 Installation

This section covers installation from source. Other ways of installing the program are not described here.

2.3.1 Requirements

All these libraries are mandatory to compile the game. Liquid War 6 won’t compile, let alone run, without them. Some of them could probably be replaced by equivalent tools, but this would certainly require a programming effort and some changes in Liquid War 6 source code.

2.3.2 Optional libraries

While all these libraries are theorically optional (the game will successfully compile without them), you’ll obviously need, for instance, one graphics backend. Otherwise, you’ll simply have no display. This is not acceptable. As of today, one can reasonnably consider all SDL-related libraries are required. The rest is truely optional.

2.3.3 Optional tools

Those tools are used upstream to maintain the game, you normally do not need them to build the game “as is” but if you modify the source code and hack the game, you might be interested in installing them.

2.3.4 Installing requirements using RPM/DEB packages

You might find it convenient not to install all the requirements from source, but use your favorite GNU/Linux distribution packages.

On an RPM based GNU/Linux system, a typical command (tested with Fedora 15 “Lovelock”) could be:

yum install \
make gcc glibc glibc-devel binutils \
libgomp \
guile guile-devel gmp gmp-devel libgc1c2 libgc-dev \
libtool libtool-ltdl libtool-ltdl-devel \
zlib zlib-devel expat expat-devel \
libpng libpng-devel libjpeg libjpeg-devel \
sqlite sqlite-devel \
ncurses ncurses-devel readline readline-devel \
libGL libGL-devel libGLU libGLU-devel \
SDL SDL-devel SDL_image SDL_image-devel \
SDL_mixer SDL_mixer-devel \
freetype freetype-devel SDL_ttf SDL_ttf-devel \
libcaca libcaca-devel \
libcurl libcurl-devel \
gtk2-devel \
perl lcov global valgrind graphviz gv \
texinfo-tex \
indent emacs doxygen libxml \
CUnit CUnit-devel \
rpm-build

On a DEB package based GNU/Linux system this command (tested with Debian 6.0 “squeeze”) would be:

apt-get install \
make autoconf automake \
gcc libc6 libc6-dev binutils \
libgomp1 \
guile-2.0 guile-2.0-dev guile-2.0-libs libgmp10 libgmp3-dev \
libtool libltdl7 libltdl-dev \
zlib1g zlib1g-dev libexpat1 libexpat1-dev \
libpng12-0 libpng12-dev libjpeg8 libjpeg-dev \
libsqlite3-0 libsqlite3-dev \
libncurses5 libncurses5-dev libreadline6 libreadline6-dev \
libgl1-mesa-glx libgl1-mesa-dri libgl1-mesa-dev libglu1-mesa libglu1-mesa-dev \
libgles2-mesa libgles2-mesa-dev \
libsdl1.2debian libsdl1.2-dev libsdl-image1.2 libsdl-image1.2-dev \
libsdl-mixer1.2 libsdl-mixer1.2-dev \
libfreetype6 libfreetype6-dev libsdl-ttf2.0-0 libsdl-ttf2.0-dev \
libcaca0 caca-utils libcaca-dev \
libcurl4-gnutls-dev \
libgtk2.0-dev \
perl lcov global valgrind graphviz gv \
texinfo texlive-base texlive-generic-extra \
texlive-fonts-recommended texlive-latex-extra \
indent emacs doxygen xsltproc pmccabe \
libcunit1-ncurses libcunit1-ncurses-dev \
google-perftools libgoogle-perftools-dev \
git git2cl \
zip nsis \
debhelper devscripts

Note that those requirements really depend on the exact distribution you have, package names may vary from one to another.

2.3.5 Compiling

Liquid War 6 uses GNU Automake, Autoconf and GNU Libtool.

Once all the requirements are installed, run:

./configure
make
make install

Liquid War 6 supports the standard ./configure --prefix=/my/path option (in fact, it supports much more than that) so you can install the game in any directory. You do not need to be root to install Liquid War 6.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.4 Extra maps

2.4.1 The extra maps package

The main package contains some maps so that you can try out the game. Still, an additionnal package, called extra-maps or liquidwar6-extra-maps is available, containing more maps. It really does contain many of them, including most Liquid War 3 and Liquid War 5 legacy maps, plus new Liquid War 6 maps.

2.4.2 Install extra maps on GNU/Linux and POSIX systems

On GNU/Linux systems (and possibly any POSIX unixish system) running:

./configure
make
make install

will install the extra maps on your system automatically, they will then be available in the extra/ sub-directory when browsing maps.

The ./configure script has a --enable-liquidwar6 switch which will try and find automatically if there’s an existing liquidwar6 binary in the path. If there’s such a binary, it will run it and ask for its map-path and use this value automatically.

2.4.3 Raw install of extra maps (all-platforms)

Another solution, which works on all platforms including Microsoft Windows and Mac OS X but also works on GNU/Linux, is to simply unpack the extra-maps package (unzip or untar) in your custom map directory, or in the system map directory. There’s nothing else to do to install these maps but simply put them on your hard drive in the right directory.

Typically on an Microsoft Windows system, you would unpack the extra maps in C:\Program Files\Liquid War 6\map\ (system directory) and on a Mac OS X system you would unpack the extra maps in Liquid War 6.app/Contents/Resources/map/ (system directory) or $HOME/Library/Application Support/Liquid War 6/map (user directory). On a GNU/Linux or POSIX system you would unpack them in $HOME/.liquidwar6/map/ (user directory).

Next time you run the game, the maps should be browsable.

If you can’t see them, run liquidwar6 --audit and check that the place where you unpacked the files is actually searched by the binary.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.5 Troubleshooting

2.5.1 Compilation problems

A quick survival guide:

If none of these help, consider reporting a bug, or search the mailing-lists for help.

2.5.2 Check installation

Here’s a check-list to ensure that your installation is correct:

2.5.3 Problems running the game

Now, game looks correctly installed, but you have problems running it.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.6 Quick start

2.6.1 Quick start

Once the game is installed, run it, click on Quick start with the mouse, and control the red 'a' cursor with the mouse, or keyboard, both work. Try and surround the green team, it’s a stupid bot, you should win ;)

You army is formed by all the red pixels on the screen, they should try and rejoin the cursor (the blinking 'a' letter) using the shortest path. When red and green meet, they fight. Try it, toy arround.

The Quick start button will always make you play red against a green stupid bot, whatever other options you have set up.

Todo...


Next: , Previous: , Up: User's manual   [Contents][Index]

2.7 Strategy tips


Next: , Previous: , Up: User's manual   [Contents][Index]

2.8 User interface

2.8.1 A reduced set of keys

Liquid War 6 can be controlled using a reduced set of keys. This is to make the game more portable and allow possible ports to platforms where a full keyboard is not available. Depending on the graphics backend, exact mapping might change, they should hopefully be obvious and intuitive.

Those keys are:

Basically,

2.8.2 Combining mouse, keyboard and joysticks

It’s also possible to control the game with the mouse only, or with a joystick. By default the interface will trap all events and respond on any of these possible devices.

KeyboardMouseJoystickMenu actionIn-game
upmouse pointerstickprevious menu itemmove cursor up
downmouse pointersticknext menu itemmove cursor down
leftmouse pointerstickchange menu item valuemove cursor left
rightmouse pointerstickchange menu item valuemove cursor right
enterleft-clickbutton Avalidate menuvalidate chat line
escright-clickbutton Bback to previous menuquit game
ctrlright-click or double-click on any buttonbutton CN/Afire
altmiddle-click or triple-click on any buttonbutton DN/Aalternate fire
pgupwheel upbutton Eprevious menu itemzoom in
pgdownwheel downbutton Fnext menu itemzoom out

A final word about joystick buttons: there’s no such thing as standard joystick buttons, some will come with A,B,C,D, others will have A,B,start,select,L,R, there’s no way to know. By default, the game will use the buttons with the lowest indexes (returned by your driver) for the most usefull functions. Validate menu entries is the most usefull action, zooming in and out the one you can live without.

2.8.3 Quit with F10

There’s also an (almost) hardcoded shortcut which will quit the game immediately, or at least as quickly as possible, without any prompt or warning.

It is the F10 key.

Think of this feature as the procastinator’s “whoops, here comes my boss!!!” emergency function.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.9 Solo game

2.9.1 Current state

As of today, Liquid War 6 is essentially a solo game since network is not working. It allows you to toy arround in arcade mode on any map you wish.

A real solo mode with campaign and goals to reach is planned, how it will be implemented is yet to be defined.

2.9.2 Team profiles

By default, teams behave differently, some of them move more rapidly, some are more aggressive but vulnerable, some are more defensive but do not attack as strong as others. This aspect of the game is under active tuning, things might be unfair by now, you can toy arround with the various team-profile-... options, any report is appreciated.

Note that this is very different from Liquid War 5, and can give very different gaming experiences, you can artificially set up arbitrary strong bots, for instance.

Here’s a description of the default color settings:

2.9.3 Weapons

Additionnally, when profiles are used, each team has two weapons, a primary weapon and an alternate one. Think of weapons as special (usually nasty) tricks you can play on your opponents.

Here’s a description of available weapons:

Note that this is in progress, some of them are NOT IMPLEMENTED YET.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.10 Network games

2.10.1 Choose your “public url”

Liquid War 6 needs to name your “node” (you can think as your server instance of the game) and have a unique URL (address) to publish and give to other nodes.

If only one network adapter is attached to your computer and your address IP is A.B.C.D then by default the game will pick automatically the address http://A.B.C.D:8056/ and it should work flawlessly.

Problems can arise if you have a peculiar network configuration, if you have multiple non-loopback network interfaces, if you use NAT to protect yourself from intruders and/or if your context forces you to do so. In that case, Liquid War won’t be able to guess a correct URL automatically. So you need to set it up manually either by editing the public-url entry in the config file, changing environment variable LW6_PUBLIC_URL or passing the --public-url=http://<host>:<port>/ argument when running the game. Typically, if you are behind a firewall which does NAT, use the firewall address. The right address is the address which, given to remote hosts, will allow them to connect on your game instance.

2.10.2 Starting a node

A node is started automatically when you run the game. Even if you don’t start to play, node starts in the background and exchanges data with other nodes, mostly to discover them and maintain its internal map of existing nodes and games.

So even without starting a network game, you should be able to point a web browser on your node and see a web page describing it. Your node address is displayed on stdout (console) when starting the game. If in doubt, try http://localhost:8056/ which should work unless you modified defaults settings.

When you start a network game, the program simply changes your node state from “idle” to “accepting connections”.

2.10.3 Connecting to a node

The interface should show you the list of available nodes, just pick one and try and connect to it.

Note that once you’re connected on a remote node, you’re still acting as an independant node, and other nodes might connect to your node as well as to the other nodes. In short, there’s no real server or client, everyone is a client for someone, and can act as a server.

Nodes connected together form a “community”, which can disband, accept new nodes, and in a general manner has its own immaterial life, the first node which created the game might disappear, game can continue without it.

This is why the main network module is called libp2p, this is a reference to the term “peer to peer”.

2.10.4 Communities

Once a node is connected to another one, they’ve started a “community”. Formally, a stand-alone node accepting for connection is already a community, even if it has only one member, but the only really interesting communities are those formed with several nodes.

A community can’t be reached through a given server, to connect to one you just need to connect on one of its member nodes. All nodes are equivalent, there’s no master, no root node, nodes collaborate to share the same real-time information and maintaine an up-to-date game state.

Of course, conflicts can arise, and in that case nodes need to agree on an acceptable solution. Normally, the program takes decisions automatically (for instance, it could decide to “kick” a node out of the community) so the player does not have to care about this, but this is expected to be one of the most tricky (and passionating) part of Liquid War 6 hacking.

2.10.5 Firewall settings

By default, Liquid War 6 will communicate on port 8056, in both TCP and UDP, and in both ways too (in/out). It’s possible to play with partial connectivity, in extreme case, you can even play without direct internet access, using only a mere web proxy.

However, things will go faster and be much easier if the program can use its default native protocol.

Here’s an example of a typicall iptables configuration which allows you to play the game full-featured. It’s assumed that by default all packets are dropped, this configuration will just open the necessary ports.

# outgoing TCP on port 8056 (liquidwar6)
iptables -A OUTPUT -p tcp --dport 8056 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A INPUT -p tcp --sport 8056 -m state --state ESTABLISHED -j ACCEPT
# incoming TCP on port 8056 (liquidwar6)
iptables -A INPUT -p tcp --dport 8056 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 8056 -m state --state ESTABLISHED -j ACCEPT
# outgoing UDP on port 8056 (liquidwar6)
iptables -A OUTPUT -p udp --dport 8056 --sport 1024:65535 -j ACCEPT
iptables -A INPUT -p udp --sport 8056 --dport 1024:65535 -j ACCEPT
# incoming UDP on port 8056 (liquidwar6)
iptables -A INPUT -p udp --dport 8056 --sport 1024:65535 -j ACCEPT
iptables -A OUTPUT -p udp --sport 8056 --dport 1024:65535 -j ACCEPT

If you can’t change firewall settings and only have access to the web through a web proxy, it can still be possible to play (with some restrictions such as your node not being seen by others) if mod-http is available. This in turn depends on wether libcurl support was activated when compiling the game. To use the proxy, you can set the http_proxy environment variable. For detailed informations, please refer to libcurl doccumentation.

2.10.6 Is the game secure?

As stated in the license, the program comes with NO WARRANTY. Period.

However, an important effort has been made so that it can reasonnably be used online, exposed to various “common” attacks.

As far as security is concerned, there are two different issues:

Here’s a list of various steps which have been taken to make the program more secure:

This being said, Liquid War 6 does not use any strong encryption library to protect the data it sends. All the checksum machinery might be vulnerable to a brute-force and/or strong cryptographic attack, so in theory it’s possible to fool the program.

In practise, if you want real privacy, play over a VPN (Virtual Private Network).


Next: , Previous: , Up: User's manual   [Contents][Index]

2.11 Graphics

2.11.1 Standard, high and low resolution

Liquid War 6 will try and pick up a default resolution when the game is launched the first time. It won’t use your maximum screen resolution but will instead list all available fullscreen modes, and pick up one which is usually something like two thirds of the highest mode. This is to allow switching back and forth between fullscreen and windowed mode using the same settings. This automatically picked-up resolution really depends on your hardware and driver. It is called “standard” in the graphics options menu.

Then it is possible to automatically select the minimum and maximum resolution your hardware allows in fullscreen mode. These are called “low” and “high” in the graphics options menu. Just click on the button that display the resolution, it will change and use the next setting. In windowed mode, the game won’t accept the highest available mode but will instead use a percentage of it, defined by the --windowed-mode-limit parameter.

You might still be in a case where this is not enough. For instance your maximum resolution is 1600x1200, Liquid War 6 picks a default mode of 1280x960 for you but for some reason you want to play in 800x600, fullscreen. In this case, simply switch to windowed mode, resize the window with the mouse (the resolution button will show you the current resolution) and just choose a resolution near 800x600. It does not even need to be exactly 800x600, 798x603 would probably fit. Then when switching back to fullscreen, you’ll be in 800x600, the game will automatically pick up the fullscreen mode which is closest to the current windowed mode resolution.

2.11.2 Display rate

By default the game will try and run at 60 frames per second. Given the nature of Liquid War 6, this is probably enough. Higher values will maybe give a slightly smoother display, but barely noticeable.

You can activate the display of frames per seconds (aka “fps”) through the menu (“options -> system”) or with the command line (“–display-fps”).

On a single processor system, reducing the number of frames per second might allow the rest of the game run faster. So if you notice the game is really slow, in terms of “fighters move slowly” then you might be happy reducing the display rate and therefore giving power back to the other parts of the program. On a dual-core (or more) or on a multi-processor system, this is probably useless since the game is threaded and has a dedicated thread for display purposes. The command line option to reduce the number of frames per second is --target-fps.

Additionnally, the parameter --gfx-cpu-usage allows you to force the display thread to “take a rest” and go idle for some time. This is advanced settings, most users won’t touch this.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.12 Sound & music

2.12.1 Current status

As of today, the game is capable of playing Ogg Vorbis audio files. That’s it.

2.12.2 The future

In the long run, what is planned is to support Csound which would allow very cool effects, such as dynamically changing the music while the game is running, typically following the action. If there’s a lot of fight, the music could reflect this.

For now this is only vaporware, just a nice idea among others, nothing implmented yet.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.13 Config file

The config file is a simple XML file. It uses XML only to benefit standard parsing tools, but it’s not a structured XML file, in the sense that the tree is so simple that all items are at the same level. It is just a simple key-value binding.

This file is in $HOME/.liquidwar6/config.xml on GNU/Linux and POSIX systems, in C:\Documents and Settings\<username>\Liquid War 6\config.xml on Microsoft Windows and in /Users/<username>/Library/Application Support/Liquid War 6/config.xml on Mac OS X.

You’re free to edit it manually, but all parameters are changeable with command line options. The program will overwrite this file each time it exits, so if you put comments in it, they will disappear. The advantage of this is that if you mispell something, or if for some reason the game does not understand a value, then when rewriting the file, it will show you it just did not get it.

The file embeds the documentation for all its entries, it is therefore rather verbose. The documentation is the same you will find online or by quering the game with the --about option, also the same you would get reading this manual.


Next: , Previous: , Up: User's manual   [Contents][Index]

2.14 Logs

Liquid War 6 uses stdout to output important messages, and stderr to log warnings and errors. It will also use syslog if available.

Additionnally, a verbose log is available in $HOME/.liquidwar6/log.csv on GNU/Linux and POSIX systems, in C:\Documents and Settings\<username>\Liquid War 6\log.csv on Microsoft Windows and in /Users/<username>/Library/Application Support/Liquid War 6/log.csv on Mac OS X.

You can read this using any spreadsheet software capable of reading csv file. It uses the tab (\t) character as a separator. It contains valuable informations including version and most default values for the game, and for each line logged, it says where in the code the log function was called. A must-have for debugging.


Previous: , Up: User's manual   [Contents][Index]

2.15 Report bugs

There are two ways to report bugs:

The latter (Savannah) is much preferred, because the mailing-list is bloated with spam... It also offers a list of bugs which you should read before submitting a new one.


Next: , Previous: , Up: Top   [Contents][Index]

3 Hacker’s guide

This hacker’s guide is for anyone who is curious about the game, and wants to know how it works. It covers many aspects from simple map creation to technical program internals. A great effort has been done in Liquid War 6 so that it should be much more hackable than previous versions. Any feedback is welcome.


Next: , Up: Hacker's guide   [Contents][Index]

3.1 Designing levels

3.1.1 Why is level design so important?

As of Liquid War 5, most levels have been contributed by players. While the maintainer of Liquid War 6 has technical knowledge to develop the game, artistic talent and taste might not be his domain of excellence 8-)

Therefore contribution are truely welcomed when they take the form of a new, original, fun and good looking level. It’s believed the levels often make the game much more than its engine. This is true for any type of game, and Liquid War is no exception.

So this section is here to help players understand how to hack existing levels, and create new ones, in the hope that 1) they can enjoy their own creations and 2) possibly share their work with others.

Note that this manual might refer to levels and maps: they are just two different names to describe the very same thing. It’s an alias.

3.1.2 Format overview

Liquid War 6 stores level information in a plain directory.

There is no such thing as an opaque .dat binary file. The name of the level is the name of the directory itself, and its elements are the files contained in it.

Files must follow a precise naming scheme. For instance Liquid War 6 expects a map.png file to be present in each map directory.

All image files in a level use the Portable Network Graphics or JPEG format. It is possible that in the long term, Liquid War 6 will be able to handle levels as .tar.gz or .zip files. In that case these files will only be a compressed image of the actual level directory.

See the ./map/ directory of the source Liquid War 6 distribution to see example of maps.

3.1.3 Resolution (map size)

Liquid War 6 does enforce a limit on map size. This is not to frustrate map designers and/or players, simply, it would be a lie to pretend the game can handle arbitrary big maps.

They might look great on your computer but will become unplayable soon on an older machine. And most of the time they don’t look that great, carefully crafted 1280×720 just looks awesome and can represent a great level complexity.

Here are the technical limits:

TypeMax widthMax heightMax surface
Texture3 0002 0006 000 000
Logical map1 5001 0001 000 000

The texture can be somewhat bigger than the logical map, this allows for pretty levels while limiting the horsepower needed to move the fighters and animate everything. Note that you could technically feed the game with a map.png that is bigger than the logical map limit, only it will be downscaled when being loaded.

The texture limits are generous enough to accept a full-HD 1920x1080 image, or a 4/3 1600x1200 image, while the “one million pixels” logical map limit is enough to store a 16/9 1280x720 map or a 4/3 1024x768.

Keep in mind that the logical map (map.png) will probably be scaled whatsoever, even if it’s within the absolute limits (the game adapts the resolution to your computer speed) and your texture will rarely appear in its native resolution, will probably be distorted, and so on.

3.1.4 Metadata

Older versions of Liquid War 6 used to load a plain README file and use this as metadata. Title was take from map directory name. This is still supported, but it now also supports the addition of a metadata.xml file in which you can describe your map.

The following files can be defined:

3.1.5 map.png

This is the only required file in a level.

In fact, the existence of map.png makes a directory a level. When checking wether a directory is a correct level, Liquid War 6 simply tests the existence and validity of map.png.

This image is a simple black & white area, where white zones are the background, the sea, the places where fighters can move, and black zones are the foreground, the walls, the places where fighters can’t go.

This informations can be stored in a 2-color indexed file, or in a grayscaled or even truecolor RGB file, but color information won’t be used. Internally, Liquid War 6 will read the color of every point. If it is over 127 on a 0 to 255 scale, it will be considered as background, if it is below 127, it will be considered as foreground.

3.1.6 layer2.png ... layer7.png

Liquid War 6 can handle mutiple layer maps. Think of a pile of maps, one being on top of the other. This allows you to create a volume, the game considers every layer has two axis x and y, and the z axis is to travel through layers. First layer corresponds to z=0, second layer to z=1, and so on.

Here are the files you can use to define layers:

A layerX.png file should be designed exactly like map.png. In fact, map.png could simply have been called layer1.png.

Up to 6 extra layers can be defined (from layer2.png to layer7.png). This is a hardcoded limit. It allows you to define 7 different layers, including the top map.png layer. Keep in mind this layer system is not real 3D, it’s more a “2D and a half” model. Adding layers can considerably slow down the game, so it’s wise to try and use as few layers as possible. Technically, 3 layers will allow you to build bridges and tunnels, which is probably the most usefull construction using layers. Fighters can also have difficulties navigating through layers so piling up layers in narrow “vertical” z-axis based tunnels is probably not a great idea.

The ufoot/concept/pass map of the liquidwar6-extra-maps demonstrates basic layer usage.

3.1.7 texture.png, texture.jpeg and texture-alpha.jpeg

It is possible to define a texture for the map by putting a texture.png or texture.jpeg file. It does not need to have the same dimensions as the map itself. Indeed, textures can be much more precise than the actual logical map.

There’s no theorical limit on how big a texture can be, more precisely, it can be much bigger than any hardware/driver maximum texture size. In practice, a too big texture will waste your video card RAM, and slow everything down. Sizes ranging from 640x480 to 1600x1200 are reasonable texture sizes.

If you don’t define this, the map.png file will be used as the texture, and also import colors from style.xml if defined.

Note that the shape of the texture defines the shape of the map, that is, the ratio with which it will appear on the screen.

The PNG alpha layer will be used for transparency. But to save disk space, it can be convienient to prefer the JPEG format, use texture.jpeg instead of texture.png and store the alpha layer in a separated file, called texture-alpha.jpeg. This avoids handling heavy PNG files, PNG compression not being performant on most textures.

In texture-alpha.jpeg, black is considered opaque, and white is transparent. Different levels of gray correspond to different levels of opacity. Previous versions of the game used the other way of doing things (black is transparent) because this is technically, the most obvious way to do things. Black is 0 and transparent is 0. But for a human “reader” of the map this does not make sense. One generally expects white to be the equivalent of “undrawn” or “blank”, well, if it’s undecided, void, transparent, whatever, it’s white. When the Gimp flattens an image, it becomes white, not black.

So white is transparent. Period.

3.1.8 glue.png and boost.png

If there’s a glue.png or boost.png file in the map directory (you can use one of them or both) then they will be interpreted as follow:

There can be, at the same place, some gray or black in both boost.png and glue.png. How this will behave exactly is not really clear at this stage, the recommendation is not to do this (it does not really make sense anyway) but if you do it, game won’t complain.

It’s also wise not to abuse of boost.png for obviously, a map filled with “boosted” zones at a X10 pace will require much more CPU than the same map with no such setting. This might fool the automatic resampling algorithm and lead to maps that are unplayable. The spirit of boost.png is just to make a few spots go faster.

It’s also important to note that behaving faster or slower means moving faster or slower but also attacking faster or slower, and, in a general manner doing any action with a different pace.

3.1.9 danger.png and medicine.png

If there’s a danger.png or medicine.png file in the map directory (you can use one of them or both) then they will be interpreted as follow:

There can be, at the same place, some gray or black in both medicine.png and danger.png. How this will behave exactly is not really clear at this stage, the recommendation is not to do this (it does not really make sense anyway) but if you do it, game won’t complain.

3.1.10 one-way-<direction>.png

The four files:

can be used to force the fighters to go in one given direction, on some parts of the map. If an area is black on one of this meta-layers, then fighters will go in the given direction. For instance, a black zone in one-way-north will make fighters go to the north (AKA “up” direction) regardless of the cursor position. The fact that this is a one-way path is understood by fighters and they will take this in account when choosing the shortest path to go somewhere. You can combine vertical and horizontal one-way informations, making diagonal one-way paths.

3.1.11 cursor.png and cursor-color.png

By default, a simple cursor will be displayed, but you can use a custom per-map cursor. Cursors are defined by two 64x64 bitmaps:

You can define only one of those bitmaps, if doing so, then the other layer will be empty, and won’t be filled with the default cursor data. Note that additionnally, a little letter (single character) will be displayed using the team color, so that’s yet another way to identify which teams the cursor belongs too. The PNG files really need to be PNG (JPEG won’t work) and need to be 64x64, any other size will be ignored.

3.1.12 rules.xml

Whereas style.xml is only about the appearance of the map, rules.xml allows the map designer to change pretty much any parameter.

Ultimately, the player can still ignore these settings and overide them with its own values, but the idea is: most game options are only pertinent in a given context. For instance, on some maps it’s interesting to move slowly, on some other it’s interesting to move fast. Some maps might be playable packed with fighters everywhere, some other might be much more fun with almost nobody on them.

The approach in Liquid War 5 was to make the options available, but let the player himself find the right settings for the right map. The consequence is that no one ever used all those cryptic options in the advanced options menu, and probably 99% of the players ended up playing with default settings. This is not that bad, but given the fact that changing a few parameters one can totally transform the gameplay, it has decided been that in Liquid War 6, the map designer suggests the right options that matches his map.

This does not prevent the player from toying with options himself, he can still do it.

There’s also one important point to note: all these options are technically implemented as integer parameters. We certainly do not want any float here, since, and it is a Liquid War specific behavior, the game must be 100,00% predictable and behave the same on every platform. As there is nothing like exactness when speaking of floats, those are forbidden here. As for strings, we are dealing here with low-level internals, and this section is not about telling a story. They are technical options only. Booleans are implemented with the usual false = 0 and true = 1 convention. Note that other config files in Liquid War 6 might rely on floats, strings, and booleans with conventionnal true and false values, but not this one. rules.xml is special.

This rules.xml file is a direct image of the internal “rules” structure, so it contains technical, sometimes not very user-friendly parameters. While hacking rules.xml directly is a good way to test things, most of the time, the other file hints.xml contains more high-level informations that do the job the right way. A typicall example is speed.

See rules.xml reference.

3.1.13 hints.xml

This parameter is only used by the map loader. The map itself contains none of these parameters, they are only clues (hints, in fact..) on “how to load the map” which are passed to the loader.

Let’s take an example : speed. This rules.xml file has a (rather) easy to use “speed” parameter, which will do all the job of finding the right resolution for your map, the right “rounds-per-sec” and “moves-per-round” parameters, in short, it will set many other parameters to fit your needs.

As far as the map designer is concerned, rules.xml and hints.xml could have been merged (but so would have style.xml) but internally they are very different: rules.xml contains the real parameters, the one used by the algorithm whereas hints.xml contains only instructions which are used once when loading the map and then disappear. The core algorithm has no idea of what was in hints.xml, once it’s loaded.

See hints.xml reference.

3.1.14 style.xml

This is a simple XML file defining various appearance parameters. It has absolutely no effect on gameplay. These settings can ultimately be overriden by the player, but the idea is that if the map designer thinks this level looks better with this or that option, let him say it in this file.

See style.xml reference.

3.1.15 teams.xml

In this file one can specify per-map team settings. In short, this is where you can say how many bots you want, which color, and so on. This can be on a per-map basis, so that each map has different customized settings, some maps might be fun with only one bot, some other maps might be fun packed with 8 opponents.

Technically, teams.xml will allow you to define up to 4 players and 9 bots. This is an awfull lot considering there are only 10 colors. Basically, it’s OK to simply define:

It might also be a clever idea to just set up player2 and bot1 being the same color, in case of a conflict the game will pick up another color, but in practice those two entries often correspond to “the second player, bot or human, coming on the battlefield”.

All in all, this represents 5 entries to set up (main player, other player or first bot which can be the same, then 3 more bots), it’s OK to have the rest undefined or set to defaults.

Note that this can also simply be unset, and in that case the game defaults will apply, and the user will be able to change them, whereas if you set these up, the player will somewhat force to used the map settings.

See teams.xml reference.

3.1.16 Resampling

This is a very important point. Liquid War almost *always* resamples maps, unless you ask it not to do it. This is not recommended, it is believed in the general case, letting the internal algorithm make its own decisions is better than trying to figure out oneself “which is the best resolution”.

The reason is, the right resolution (we’re talking here of the logical resolution, how many fighters wide is the battlefield) often depends on the speed and general ressources the of the computer the program is running on. The map designer does not have this information. The program does. It runs a bench at startup. So this way it can choose, at runtime, the resolution which fits best.

The recommended way of doing things is not to try to be too picky about rules.xml parameters related to speed and also let the default map size limits in hints.xml to their defaults. Do not use them unless debugging stuff. Then the program will resample the map so that the player can play on it at a reasonnable speed. If map is too big, and it’s often the case, then it will downsize it until there are sufficiently few fighters so that the CPU can handle the job. This, of course, is not rocket science. The bench calculation is a somewhat brute-force approach of doing things. Formally, we would have to run the map for good to figure out what is the right speed. Still, this bench gives good approximations.

Previous versions of the game relied heavily on ’fighter-scale’ to resample maps, but this is not the case anymore. The ’fighter-scale’ is now a minor parameter which is used to upsize maps if they are too small. In 99.9% of the cases, the map is first upsized by ’fighter-scale’ for this parameter is by default set low (1.0) then downsized by ’bench-value’ for real-life personnal computers can’t handle 1600x1200 maps in real-time. Not yet.

There are a bazillion options to control map size, including ’min-map-surface’. They are here because it’s important that, ultimately, people can do whatever they want with the game. But for map design, this is another story. Don’t use them. Rely on ’bench-value’ and just care about game speed. This is achieved by changing the “speed” parameter.

3.1.17 Music

It is possible to store your own custom music file within the map directory. You can call it whatever you want (you can keep its original name, which is something music authors usually appreciate, even if there’s no strong “attribution” clause on the license, it can be considered fair use not to fiddle to much with the name) you just have to place it in the same directory than the other files like map.png or texture.jpeg.

The following formats are known to work with the default SDL_mixer based mod_ogg backend:

To be more precise, here’s how things work:

3.1.18 Experience (“exp”)

In rules.xml you can set a special parameter which is exp and allows you to tell “a player can’t load this map if he doesn’t have at least N at his/her exp rating”. Gaining exp (stands for “experience”) isn’t hard, you just need to win a level with exp=N to gain exp=N+1.

By default, the player’s exp is 0 and levels default to 1, so this means only levels with exp set explicitely to 0 in rules.xml might be used. Then player wins that level and is given access to all maps by default, unless these are explicitely set with exp greater than 1.

In solo game, when a player wins a level, he’s automatically redirected to the map which is in the same directory and has exactly the exp he just gain. For instance, if you win a map with exp=5 then you’re chained to the first map (in alphabetical order) which has exp=6. By setting up the exp parameter the right way, with a map for each exp level one can transform a simple map directory in a scenario that player will automatically follow.

Last, but not least, the game, at startup, only allows you to play red, green, blue and yellow. Other colors are unlocked as you progress among levels. Same things with weapons, there are “liberated” continuously through the game.

This mechanics allows the following behavior:

As a final word, yes, it’s possible to cheat, fool the exp system, but it’s believed this is moot and lame.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.2 Translating

3.2.1 Using gettext

Liquid War 6 uses GNU gettext for all its messages. There’s an online manual about this tool. In practice, what you have to do as a translator is to edit the po/xx.po file with xx being your language / country code. For instance, to translate the game in French, one needs to edit po/fr.po.

3.2.2 Formatted strings

This is very important, you might already be aware of it if you are familiar with gettext, but still it’s worth mentionning : when a string contains special characters such as %d or %s (in a general manner, anything with a % it’s important that all translations contain exactly the same number of %ds and %ss than the original.

For instance:

"foo has %d bars (%s)"

can be translated to:

"ziblug zdonc %d zuc - %s - tac"

The number, order and type of % entries is preserved. To learn more about these formats, use info printf or man 3 printf. In a general manner, get informations about printf.

Additionnally, some strings are used by Scheme (Guile) code and not by C code. Thus, they don’t use the standard C/printf convention. In these strings, what you must preserve and be aware of is the tilde character ~. Very often you’ll see ~a in a string. As with the printf %, you must preserve the number, order and type of those. There is a complete online reference about this way of formatting strings.

3.2.3 Partial translation

Liquid War 6 has thousands and thousands of messages which could theorically be translated. In practise it’s counter-productive to spend time to translate those, as the game is still evolving constantly, and as most of these messages are technical messages which inform about rare bugs and strange conditions. All sort of informations which, while valuable, are not intented for end-users and are more destinated to be reported in bug reports. To select only the interesting messages to translate, the current gettext configuration only uses a reduced set of files.

As a side note, the file src/lib/hlp/hlp-reference.c contains all the entries for the various configuration options, anything that can be queried by liquidwar6 --about=<keyword>. This is several hundred messages. It might be interesting to translate them some day, but it’s obviously not a priority today.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.3 Architecture

3.3.1 C + Guile

Technically, Liquid War 6 is a collection of C functions which are exported to Guile. The main binary embeds a Guile interpreter, which will run a Guile script. This script calls the exported C functions, and glues them together.

It should be possible to implement the game without using Guile at all, using C code to make the various modules communicate together. This might seem an easier way to go, not involving several languages. However, using this script level is a good way to achieve several important goals:

Having Guile to implement high-level stuff also decreases, to some extent, the need for object-oriented features of C++. The big picture is : low level code that require speed, optimized data processing, is written in C. Code which is more high level and requires abstraction is written in scheme.

3.3.2 Threading and SMP

Liquid War 6 makes a heavy usage of threads. Early versions of the game did not have this feature but starting with 0.0.7beta, one can really consider the game is heavily threaded.

There’s basically:

So globally, if you have an SMP system, the game will be happy with it. It will also run on a single processor, as the program uses POSIX pthreads it’s capable to run on any computer which has pthreads implemented for it.

But, and this is a strong limitation, without pthreads, the game won’t run. At all. Or at least, not unless it’s almost completely rewritten.

3.3.3 Internal libraries

The C code is splitted into several internal libraries. This allow independant testing of various game modules.

The main module, the most important one, is libker, (stands for “kernel”). This is were the core algorithm is. To some extent, the rest of the code is just about how to provide this module with the right data and environment. Logically, if you profle the game, you should find out that a great part of the CPU time is spent here. Code here is about spreading gradients, moving fighters and cursors.

The libmap module is here to handle maps, it contains the code to manipulate maps in memory. But it does not know how to load them from disk. This is the responsability of another module, libldr, which is linked against libraries such as libpng or libjpeg and does the job of transforming those standard formats into a usable in-memory structure. The libgen module also works the same way, creating pseudo-random maps. There’s still a another moduled involved in map handling, it’s libtsk, whose job is to load a level in the background. It has a 2-steps asynchronous loading system which allows the game to load maps while the user interface is still responsive, and give a preview of the map as soon as possible, when loading continues in the background, building optimizing structures which are usefull when playing but not mandatory just to show the map.

At the other end of the algorithm-chain, the libpil module will “pilot” things. It’s this module which will translate text readable orders (typically adapted for network usage) into function calls. It has event lists, keeps them in the right order, and will also permanently maintain three different states of the game. A backup state which can be used any time to go back in time and get the game in a stable 100% sure state. A reference state which is correct but ever changing. Basically backup plus all the orders received between backup and reference gives reference. And finally a draft state which is as up to date as possible but might be wrong. This is typically interesting in network game, where we want to show something moving, something fast, even if there’s lag on the network and other computers fail to send information in time. In this case we display draft while still keeping reference and updating it when we finally receive valid informations. Backup would be used to send bootstrap information when people are joining a new game, or to check up if things are going right.

A special libbot module is here to handle bot algorithms. A bot is just a simple move function which takes a game state as an input, and returns an x,y position, just the way a mouse handler would. How complex a bot is “under the hood” depends on the type of bot. Current bots are really basic. Additionnally, libsim will run dummy fight simulations to find out wether some team has a real advantage on another one, speaking of team profiles depending on colors.

The libgfx module handles all the graphics stuff. It is itself splitted in several sub-modules, that is, it does not do anything but load a module such as mod-gl1 which will actually contain the implementation. In an object-oriented language, it would be an abstract class, an inteface. The implementation does not need to be thread-safe. It’s better if it is, for theorically it could be possible to fire Liquid War 6 with two display backends running at the same time on the same game instance, but this code has yet to be written, and it’s a rare dual headed configuration which probably has no real-life usage. If only one graphics backend is activated at a time, the rest of the implementation garantees there will never be two concurrent calls to a function is this module. It is the libdsp (“display”) which handles this. It fires a thread for rendering purposes, and sends information to this thread, detecting automatically if it’s necessary to acquire a mutex and update rendering informations. For the caller, this is transparent, one just has to call an update function from time to time. The module will even perform “dirty-reads” on a game state being calculated, to render things in real time, as soon as possible.

An experimental libvox module is under design/development and might, in the future, provide a real-time voxel renderer. Still pre-alpha stage.

To ease up the implementation of different graphics backends, a libgui module contains code which is meant to be used by any graphics backend. It’s just a factorisation module, containing common code and interfaces, related to displaying things. This is where, for instance, one can find a high level menu object. In the same spirit, libmat contains generic math, vector and matrix code, which is commonly used in 3D interfaces.

The libsnd module handles sound. It’s also an abstract class, an interface, which uses dynamic backends as implementations.

The libnet module is a wrapper over different network APIs, it handles Winsock and POSIX sockets in a uniform manner. The libcli and libsrv contain network client and server code, implementing the various protocols in dynamically loadable sub-modules. It’s the role of libp2p to glue this together, handle the list of available servers, the message queue, verifying nobody is cheating, and so on. All this modules share information about current game state using code & structures defined in libnod,use message utilities (format, parse) defined in libmsg and share code concerning connections in libcnx. Additionnally, libdat provides facilities to store old network messages and sort them.

The libsys module contains most system and convenience functions, it handles logs, type conversions, timer, memory allocation, it’s the fundamental module every other module depends on. It has a compation libglb module with all the Gnulib shared code.

The libhlp is used to handle keywords and internal self-documentation (this is what is used by --list and --about), libcfg knows how to read and save config files, libcns handles the console, and libdyn can load .so shared files dynamically.

To glue all this, there are some Guile bindings with helper functions available in libscm which fills two needs, one being an easy way to check if Guile linking is working correctly without requiring all other modules to be available, and also performing automatic checks on some actions such as registering or executing a function.

Finally there are small modules like libimg (to make screenshots of the game) which have been separated because they required special libraries to link with and/or did not really fit in existing modules for dependencies reasons.

So well, this is a lot of modules. The list might move a bit, but the big picture is here. Each module is testable separately.

Below is a Graphviz diagram, which shows the modules dependencies.

Diagram showing modules and libraries dependencies

3.4 Memory structures

The most important memory structures in Liquid War 6 are:

All these structures are defined in the ker/ker.h header.

3.5 100% predictable algorithm

The core Liquid War 6 algorithm is 100% predictable, that is to say, given the same input, it will produce the same results, on any computer. Previous versions of the game also had this property. This is very important for network games, since in a network only informations such as “cursor A is at position x,y” are transmitted. Every node maintains its own internal game state, so it’s very important that every node comes with the same output given the same input.

For this reason Liquid War 6 never uses floating point numbers for its core algorithm, it uses fixed point numbers instead. It also never relies on a real “random” function but fakes random behavior by using predictable pseudo-random sources, implementation independant, such as checksums, or modulos.

There are also some optimizations which are not possible because of the predictability requirement, for instance one can not spread a gradient and move the fighters in concurrent threads, or move fighters from different teams in different threads.

If you read the code, you’ll find lots of checksums here and there, a global checksum not being enough for you never know where the problem happened. The test suite uses those facilities to garantee that the game will run the same on any platform.

Not being able to rely on a predictable algorithm would require to send whole game states on the network, and this is certainly way too much data to transmit. A moderate 200x200 map has a memory footprint of possibly several megabytes, so serializing this and sending it to multiple computers at a fast-paced rate is very hard, if possible at all, even with a high bandwidth. We’re talking about Internet play here.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.6 Graphics backends

3.6.1 Modularity

Liquid War 6 has a modular architecture which allows the programmer (and the player) to plug pretty much any rendering/graphics backend, provided this one is... developped.

As of 2009 the only available backend was mod-gl1, it would display the game using 3D acceleration, if available, through the SDL library, using its GL bindings.

As of 2012, other backends are begin developped, the idea is that each backend can provide the user with enough visual feedback to play, and convey input informations to the core engine.

The rest of the game is exactly the same, this means playing with mod-gl1 you can do exactly the same things than with mod-caca.

3.6.2 List of backends

3.6.3 How to write a new backend

The starting point for any hack are the files src/lib/gfx/gfx.h. This is where the API is defined.

Basically, the type lw6gfx_backend_t contains all the required callbacks. You must provide an implementation for each function.

Let’s take an example, taken from mod-gl1. When calling lw6gfx_get_video_mode and passing it a first argument which is a valid mod-gl1 backend, the function mod_gl1_utils_get_video_mode will be called. How this is done is a little C casting wizardry.

To understand how this works, read the files:

All the functions should be defined, but some of them are obviously more important. The two most critical functions are:


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.7 Core algorithm

3.7.1 Introduction

Since Liquid War 3 the algorithm to power Liquid War is pretty much unchanged, at least, there has been no revolution, the basic principles remain the same. This has been explained in Liquid War 5 doc, but is repeated here, along with the specific Liquid War 6 stuff.

The very important things to remember are:

3.7.2 Level, game struct, game state and pilot

Most of the algorithm code has something to do with the following types (which are structs):

Most of the time, hacking on the algorithm, changing the gameplay, does not require to touch anything but the code in src/lib/ker.

See See libmap. See See libker. See See libpil.

3.7.3 Getting informations about where fighters are

One of the key functions is lw6ker_game_state_get_fighter_id, which will return the id of a fighter at a given position. Then its companion function lw6ker_game_state_get_fighter_by_id can be called, it will return a lw6ker_fighter_t, which contains the real data.

The type lw6ker_fighter_t is not opaque and can be freely accessed by the caller, which, typically, is a graphics backend trying to display informations. Try and grep for the string “lw6ker_game_state_get_fighter_id” withing the src/lib/gfx source tree for examples.

One thing that is very important when hacking on libker: you should always leave the lw6ker_game_state_t struct in a state that is compatible with a correct usage of public “getters” in src/lib/ker/ker.h. The reason is that this code can be executed by separate threads, more precisely, in “dirty read” mode, the rendering thread will try and display a “game state” while this very “game state” is being updated by another thread.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.8 Compilation tips

3.8.1 Advanced ./configure options

In addition to all the common Autoconf switches such as --prefix, Liquid War 6 has some custom switches:

3.8.2 Debian packages

Liquid War 6 does have a ./debian in both main and extra maps packages, so it’s “debianized”. To build the main .deb package, untar the main source tarball, then:

make dist
cd pkg
cp ../liquidwar6-X.Y.Z.tar.gz . # X.Y.Z is the version
make deb

Note that you have to copy the source tarball to ./pkg and move to this directory before typing make deb. This is, among other things, to simplify the main Makefile.

To build the extra maps .deb package, untar the extra maps tarball, then:

make deb

3.8.3 Red Hat packages

Liquid War 6 does have a .spec files in both main and extra maps packages. To build the main .rpm package, untar the main source tarball, then:

make dist
cd pkg
cp ../liquidwar6-X.Y.Z.tar.gz . # X.Y.Z is the version
make rpm

Note that you have to copy the source tarball to ./pkg and move to this directory before typing make rpm. This is, among other things, to simplify the main Makefile.

To build the extra maps .rpm package, untar the extra maps tarball, then:

make rpm

3.8.4 Microsoft Windows msys/mingw32 port

This section describes how to compile the game from source under Microsoft Windows. Note that players are encouraged to use a free system such as GNU/Linux, which is the platform Liquid War 6 is being hacked on by default. If you encounter problems with this port, you’ll probably save time by installing a double-boot with GNU/Linux coexisting with your previous Microsoft Windows install.

Basically, Liquid War 6 requires MinGW. More precisely, it requires MSYS. A standard Cygwin installation won’t work, because it is too UNIXish to allow third party libraries like SDL to compile natively. You might argue that SDL is available for Cygwin, but in reality, the Cygwin port of SDL is a MinGW port. Indeed, Cygwin brings all standard POSIX functions including the use of main instead of WinMain and I suspect this is a problem for graphical libraries like SDL which do require some sort of direct access to the OS low-level functions. Therefore, MinGW is more adapted for it does not define all these functions, and allows any library to hook on Microsoft Windows internals directly. Point is then, you also loose the cool effect of Cygwin which is to have a complete glibc available, including network functions like select defined the POSIX way, and not the WinSock way. If you ever ported code from POSIX sockets to WinSock 2, you know what I mean. Using MinGW is also embarassing for some libraries won’t compile easily, and for instance programs which heavily rely on a real TTY interface to work are usually hard to port. This includes ncurses and GNU readline. Liquid War 6 tries to have workarrounds for all this, and in some cases the workarround is simply that embarassing code is not compiled on Microsoft Windows. For this reason, some features are not available on this platform. Period.

Now the reason you need MSYS and not only MinGW is that MSYS will allow ./configure scripts to run, and this eases up the porting process a lot. MinGW and MSYS packages are downloadable on the SourceForge MinGW download page. Alternatively, there is a mirror on ufoot.org, but files might be outdated.

To compile Liquid War 6, first download and unzip all the following files in the same directory, for instance C:\MSYS. If you do not have any tool to handle .tar.gz and .tar.bz2 files under Microsoft Windows, which is likely to be the case when MSYS is not installed yet, you can untar these on any GNU/Linux box, then upload the whole directory to the target Windows host.

This file list might contain file which are not absolutely mandatory for Liquid War 6, for instance the Fortran 77 compiler is absolutely useless, but installing it won’t harm either. Some packages might unzip things the right way, but some do it in a subfolder. You might need to run commands like:

cp -r coreutils*/* .
rm -rf coreutils*

Get rid of useless files:

rm ._.DS_Store .DS_Store 

It’s also mandatory to move everything that has been installed in /usr or /usr/local to / since MSYS has some builtin wizardry which maps /usr on /. You need to do this if you don’t unzip files from a MinGW shell, which is obviously the case when you first install it. Usefull command can be:

mv usr/* .
rmdir usr

Next, libintl is not correctly handled/detected by LW6, and can raise an error like "gcc.exe: C:/msys/local/lib/.libs/libintl.dll.a: No such file or directory" so one needs to copy some libraries in /usr/local/lib/.libs/:

mkdir local/lib/.libs
cp local/lib/libintl.* local/lib/.libs/

Another step is to edit /etc/profile and add lines like:

export CFLAGS="-g -I/usr/local/include"
export LDFLAGS="-L/usr/local/lib"
export GUILE_LOAD_PATH="C:\\MSYS\\local\\share\\guile\\1.8\\"

Close and re-launch your msys shell (rxvt) so that these changes take effect. Check that those values are correctly set:

env | grep FLAGS
env | grep GUILE

Finally, your MSYS environment is (hopefully...) working.

Now you need to compile the following programs, from source. Files are mirrored on ufoot.org for your convenience, however these might be outdated. Still, there are known to work. Proceed like if you were under a POSIX system. Some packages use the --disable-rpath swith, there are various reasons for which rpath is an issue. In the same manner, --disable-nls when linking against libintl or libiconv was painful.

For your convenience, a zip file containing a complete MSYS "Liquid War 6 ready" environment is available. It is simply the result of all the operations described above. Simply unzip msys-for-liquidwar6-20080819.zip (about 240 megs) in C:\MSYS\. All dependencies compiled in /local have been generated using the command:

cd /usr/local/src
./msys-for-liquidwar6-build.sh > ./msys-for-liquidwar6-build.log 2>&1

Note that this script does’t do everything, you’ll still need to edit Guile source code and patch it manually.

It might even be possible to use this MSYS environment under Wine. Simply unzip it under $HOME/.wine/drive_c, and run wine "$HOME/.wine/drive_c/windows/system32/cmd.exe" /c "c:\\msys\\msys.bat" and with luck, you’ll get a working shell. Note that this might allow you to compile the game, but running it is another story. Consider this MSYS over Wine trick as a hack enabling the use of free software only when compiling for Microsoft proprietary platform. It is not a reasonnable way to run the game. If running under a UNIXish platform, or better, GNU, simply run native code. Use the Windows 32-bit port only if you are jailed on a Microsoft system.

Now, let’s come to the real meat, untar the Liquid War 6 source tarball, launch your MSYS shell, and:

./configure
make
make install

Now the binary is in src/.libs/liquidwar6.exe (beware, src/liquidwar6.exe is only a wrapper). This binary is an MSYS/MinGW binary, so it read paths “à la” Microsoft, that is, it has no knowledge of what /usr is, for instance. It requires paths starting by C:\.

3.8.5 Mac OS X port

This is still experimental. Basically, install MacPorts, and most dependencies with, except for SDL which you compile from source. The idea is to compile SDL using the native OS X bindings (and not some other GL files you could have in /opt/local installed by MacPorts), then compile the game and other SDL dependencies against this SDL.

The SDL_mixer library might need to be told to compile itself without dynamic ogg support. By default it seems that it tries to load libvorbisfile.dylib at runtime, and it can fail. To disable this dynamic loading, use for instance :

/configure --prefix=/opt/extra --enable-music-ogg --disable-music-ogg-shared 

Also, it might seem obvious for Mac OS X users, but there are some important issues related to compiling options and handling dynamic libraries at runtime.

It is very important to have the right SDL flags when linking the Liquid War 6 binaries. For instance it could be:

-I/opt/extra/include -I/opt/local/include -Wl,-framework -Wl,CoreFoundation -I/opt/local/include -D_THREAD_SAFE -Wl,-framework -Wl,Cocoa -Wl,-framework -Wl,OpenGL -Wl,-framework -Wl,Cocoa 

The point is to have Cocoa and OpenGL support. Depending on the way you installed SDL, you might also need to include an SDL framework support, this is mostly if you installed SDL from .dmg binary images, and not from source with the command line. A typical output of sdl-config --libs is:

-L/opt/extra/lib -lSDLmain -lSDL -Wl,-framework,Cocoa

Another important issue is to include SDL.h, which in turn includes SDLmain.h, in all the .c source files defining the standard main function. This is done in liquidwar6 but should you try to link yourself on liquidwar6 libraries and/or hack code, you must do this or you’ll get errors when running the game. Such errors look like:

*** _NSAutoreleaseNoPool(): Object 0x420c90 of class NSCFNumber autoreleased with no pool in place - just leaking

The reason is that SDL replaces your main with its own version of it. One strong implication is that all the dynamic loading of SDL, which works on sandard GNU/Linux boxes, won’t work under Mac OS X, since SDL hard codes itself by patching main with #define C-preprocessor commands.

A .dmg file (disk image) containing a Liquid War 6.app folder (OS X application) is available for your convenience. It might work or not. In doubt, compile from source. The complicated part about this package (a “bundle” is OS X language) is that it needs to embed various libraries which are typically installed in /opt by MacPorts on a developper’s machine. So to build this package a heavy use of the utilility install_name_tool is required, normally all libraries needed ship with the binary, remaining depedencies concern frameworks which should be present on any working Mac OS X install. Still, this is only theory. Needs to be widely tested.

The layout of the bundle follows:

Additionnally, the Mac OS X port uses /Users/<username>/Library/Application Support/Liquid War 6/ to store configuration file, logs, etc. It does not use $HOME/.liquidwar6 like the default UNIX port.

The Mac OS X port also has a special behavior, in order to load some libraries with dlopen (SDL_image does this with libpng and libjpeg) it needs to set DYLD_FALLBACK_LIBARY_PATH to a value that contains these libraries. This is typically in the bundle distributed on the disk image. On a developper’s computer this problem does not appear for those libs are often in places like:

So the program sets DYLD_FALLBACK_LIBARY_PATH (but not DYLD_LIBRARY_PATH else it breaks internal OS X stuff which relies, for instance, on libjpeg library that has the same name but different contents) but it needs to do it before it is even run, else the various dyld functions do not acknowledge the change. That is, calling the C function setenv(), even before dlopen(), has no effect. So the program calls exec() to re-run itself with the right environment variable. This is why, on Mac OS X, there are two lines (exactly the same ones) displaying the program description when it is started in a terminal.

3.8.6 GP2X port

This is not working yet, but there are good hopes that some day, Liquid War 6 can run on a GP2X console. This handled gaming device uses a Linux kernel on an ARM processor, does support most GNU packages through cross-compilation, and has basic SDL support.

To compile Liquid War 6 for GP2X, you first need to set up a working “toolchain”. It’s suggested you do this on a working GNU/Linux box. There are several solutions, the recommended one being Open2x. Read the online documentation on how to install Open2x.

Basically, the following should work:

mkdir /opt/open2x # check that you can write here
svn co https://open2x.svn.sourceforge.net/svnroot/open2x/trunk/toolchain-new open2x-toolchain 
./open2x-gp2x-apps.sh
cd open2x-toolchain

Then, for your environment to be complete, you need to set up some environment variables. For instance:

export OPEN2X_SYSTEM_PREFIX=/opt/open2x/gcc-4.1.1-glibc-2.3.6/arm-open2x-linux
export GP2X_USER_PREFIX=$HOME/gp2x

export CC=${OPEN2X_SYSTEM_PREFIX}/bin/arm-open2x-linux-gcc
export CPP=${OPEN2X_SYSTEM_PREFIX}/bin/arm-open2x-linux-cpp
export CXX=${OPEN2X_SYSTEM_PREFIX}/bin/arm-open2x-linux-g++
export AS=${OPEN2X_SYSTEM_PREFIX}/bin/arm-open2x-linux-as

export CFLAGS=''-I${OPEN2X_PREFIX}/include -I${GP2X_USER_PREFIX}/include''
export CPPFLAGS=''-I${OPEN2X_PREFIX}/include -I${GP2X_USER_PREFIX}/include''
export CXXFLAGS=''-I${OPEN2X_PREFIX}/include -I${GP2X_USER_PREFIX}/include''
export LDFLAGS=''-L${OPEN2X_PREFIX}/lib -L${GP2X_USER_PREFIX}/lib''

export PATH=''${GP2X_USER_PREFIX}/bin:${OPEN2X_SYSTEM_PREFIX}/bin:$PATH''

In this setting, there’s a user $HOME/gp2x directory which will contain all the Liquid War 6 related libraries while the /opt/open2x remains untouched.

Then you need to install the requirements. All these packages need to be cross-compiled. To make things clear and non-ambiguous, even if you have CC set up in your environment variables, pass --build and --host arguments to the ./configure script of all these packages. A typical command is:

./configure --build=i686-pc-linux-gnu --host=arm-open2x-linux --prefix=${GP2X_USER_PREFIX}

Here’s the list of the requirements:

Next, one needs to install a special version of SDL, which targets the GP2X specifically. This is not a generic SDL, and it does have limitations, which are related to the GP2X peculiar hardware. There are installation instructions about how to do this. The following should work:

cvs -d :pserver:anonymous@cvs.sourceforge.net:/cvsroot/open2x login # blank password
cvs -d :pserver:anonymous@cvs.sourceforge.net:/cvsroot/open2x co libs-gp2x 

Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.9 Coding guidelines

3.9.1 Project goals reminder

One of the purposes of Liquid War 6 is to make a cleaner implementation of Liquid War than the previous one, namely Liquid War 5. While the latter has achieved the practical goal of providing a playable implementation of the game, it failed at providing an evolutive platform. Network capabilities where finally added to Liquid War 5, but anyone who played on Internet with someone a few hundreds of milliseconds away would agree that it’s far from being perfect. The main reason for this is that it is really had to hack on Liquid War 5, especially when you are not the core developper. The core developper himself, even knowing all the various hacks in the game, is very quickly lost when trying to implement major changes.

To put it short, Liquid War 5 is a global variable hell, a pile of hacks on top of a quick and dirty implementation. Still, it works.

With Liquid War 6, the idea is to take the time to make something stable, something nice which will enable developpers to implement the cool features, and have fun along the way. Of course, this is only a dream, and in the (hopefully "very") long run, Liquid War 6 will also end up as a big unmaintainable mess, like any real-life program, until then, it should remain hackable.

3.9.2 Common sense

Here are a few guidelines which I think are common sense advice, but they are still worth mentionning:

3.9.3 Unitary tests

Each of the internal libraries in Liquid War has a “test” program associated with it. For instance liquidwar6sys-test is associated to libliquidwar6sys, and its purpose is to test the features of this library.

While it is fairly easy to test out unitary functions which require no peculiar context, testing high-level functions which requires files, graphical and possibly network contexts to exist is obviously harder to achieve. There’s no easy way to draw the line, but the idea is to put in these test executables as many features as possible, to be sure that what is tested in them is rock solid, bullet proof, and that one can safely rely on it and trust that code when running it in a more complex environnement.

These test executables are also very good places to see a library API in action, find code fragments, and make experiments.

3.9.4 Memory allocation

Liquid War 6 provides macros to allocate and free memory. One should use them systematically, except when trying to free something allocated by another library, and in very special cases, mostly concerning low-low level operations which are seldom hacked on.

Usage of macros LW6SYS_MALLOC, LW6SYS_CALLOC and LW6SYS_FREE is straightforward, read any random chunk of code, for instance ./src/lib/sys/sys-test.c to see them in action. They are defined in sys/sys.h.

Once used, these macros will track every single call to malloc and free, and if there’s a difference, it will report it. It will also help you by showing what’s in the non-freed memory area, at which line of code it has been allocated, and when. This is very usefull to track down memory leaks. Of course a debugger could tell you some of these informations, but experience shows than when you encounter a memory bug, it’s very often impossible to reproduce it. So you one wastes time trying to reproduce the bug, whereas with this tool you have the information reported just when the problem happens.

3.9.5 Private and public interfaces

Each library exports a public interface and hides its internal. Since Liquid War 6 uses standard C and no C++, there’s no real standard way to handle public/private features. The convention used in Liquid War 6 is to show internal structures as opaque pointers (void *) whenever some function needs to operate on a structure which has possibly private fields. This way the caller function has no way to access the internals, and we are sure that no reference to any internal implementation specific feature will appear.

Here’s a code excerpt from src/gfx/setup.c:

void _lw6gfx_quit(_LW6GFX_CONTEXT *context) {
  /*
   * Implementation here.
   */
[...]
}

void lw6gfx_quit(void *context) {
  _lw6gfx_quit((_LW6GFX_CONTEXT *) context);
}

The function _lw6gfx_quit (note the “_”) is internal, declared in internal.h whereas the function lw6gfx_quit is public, and is therefore exported in gfx.h.

This way, functions in the program using lw6gfx_quit do not know what is in the _LW6GFX_CONTEXT structure, and they need not know it.

This does not mean it is not possible to have public structures, only these structures must reflect some truely public, accessible and safe to access structures.

3.9.6 Commit policy

Basic rules :

To check that a commit does not break everything, a good practice is to run a make check before committing / submitting anything.

Then, once it’s within the main GIT repository, check the Jenkins builds to see if the program still builds correctly.

3.9.7 Audit the code

Liquid War 6 is regularly audited with automated tools. You might need to pass --enable-gcov to --configure if you want to use thes tools yourself. More precisely:

Those tools certainly don’t garantee the code is perfect, but they do help improving the quality of the program. If you hack, it’s recommended you give them a try.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.10 Using the console

The console can be activated by passing --display-console when starting the game or by using the system options menu.

When the console is activated, a lw6> prompt should appear in the terminal which launched the program. If you started Liquid War 6 by clicking on an icon, console probably won’t work at all since stdout and stdin won’t be attached to anything.

The console allows you to type arbitray Scheme/Guile code.

Try, for instance:

(+ 1 2)
(display "foo\n")

You can really break things with this console, it gives you a direct access to all the program internals. At least, all the values which are accessible through the script interface, that is, many of them.

You can call any internal C function which has been exported to Guile, here are some examples:

(c-lw6sys-timestamp)
(c-lw6bot-get-backends)
(c-lw6sys-sleep 2.0)
(lw6-config-get-number "zoom")
(lw6-config-set-number! "zoom" 0.9)
(lw6-config-get-number "zoom")

While syntax (and possibly other) errors will be trapped by the interpreter, note that if you break things inside the game by, say, changing some global value, or in a general manner cause an error elsewhere in the code, the game will really raise a fatal error and stop. That’s how you can “break things”.

Still, this console is a very powerfull tool, very usefull for debugging but also for tweaking the game without restarting it and/or navigating through the menu interface.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.11 Advanced tweaking

3.11.1 Hacking ressources

Liquid War 6 tries to have as few hardcoded data as possible. So many constants, and pretty much all the image files, are accessible in the data directory. You can know where it is by launching liquidwar6 --show-data-dir. If you look in this directory you’ll find different files, among them XML files.

Let’s take an example. Try and find the file gfx/gl/hud/floating/gl-floating-const.xml. Edit the line with the clock-y1 entry. Change the number after "value". Re-run the program. Play a game. What happens? Logically you should see that “something” is not displayed at the same place than before.

You could also modify the textures (JPEG and PNG files). In a general manner it’s more cautious to keep them the same size but it depends, sometimes other sizes will work as well.

Many of these parameters are really too technical and obscure to have their place in the main config file (which is already rather big). Use at your own risks, you can really break things touching this, but you can also find out lots of things can be tuned.

3.11.2 Optimize for speed

Todo...


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.12 Writing modules

Todo...


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.13 Use as a library

Todo...


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.14 Network protocol

This section describes how Liquid War 6 handles network messages. Note that for now this is purely theorical, more of a draft, a plan, it might change before being implemented.

3.14.1 No server, no client, only nodes

Liquid War 6 does not really have the notion of server or client, any instance of the program can act as both server and client, therefore we use the term node.

A node listens on a given port, in both TCP and UDP, and can connect to other nodes on the same port. The main identifier of a node is its public url, which is typically of the form http://<ip-address>:<port>/. This url is very important for it is (or at least should be) a unique identifier of the node over the network.

Liquid War has 3 ways to communicate:

On each of these channels, messages can be exchanged in two modes, an “out of band” mode (AKA “oob”), and a regular message oriented, here we speak of “connection”.

3.14.2 Out of band messages

There are only 3 out of band messages:

You can test out of band messages by simply connecting on your server with a command like:

telnet localhost 8056

At the telnet prompt, simply type:

INFO

and press return, and you should have a description of your node.

The complete syntax of OOB messages is:

<COMMAND> [password] [url]

The password and url parameters are optionnal. password can contain either the plain text password or a checksum calculated from the password which is, for security reasons, seeded with the public url of the node we’re connecting to, so that this password can’t be re-used on another node. url is simply a clue we give to the other node to help find us, the other node will automatically try to detect our IP address and use standard LW6 port 8056, but if for some reason we use a different setting, this is a good way to pass the hint.

Here are examples of valid messages:

LIST
PING http://myhost.mydomain:1234/
INFO secret http://myhost.mydomain:1234/
LIST 12ab34cd

If there’s only one argument, the parser will first try and interpret it as a URL. If it’s not parseable that way, it will consider it’s a password. The password, in turn, may be specified as clear text or as a 32-bit checksum.

As far as OOB is concerned, TCP and UDP work almost the same, HTTP is a bit different, the OOB commands are accessed through the following URLs:

OOB messages are usually sent many times in redundant mode on the network, as there’s no tracking of them, sending them through multiple channels ensures they make their way to the right place.

The parser for these messages is located in src/lib/msg/msg-oob.c.

3.14.3 Regular messages overview

All messages that are non-OOB share a common syntax. This is called the “envelope” of messages.

The general syntax is:

LW6 <VERSION> <PASSWORD_CHECKSUM> <PHYSICAL_TICKET_SIG> <LOGICAL_TICKET_SIG> <PHYSICAL_FROM_ID> <PHYSICAL_TO_ID> <LOGICAL_FROM_ID> <LOGICAL_TO_ID> <MSG>

Here’s an example:

LW6 0.1.3485 - 2d1dbed7 - 3003300330033003 2002200220022002 - - DATA 8 0 1 1000000035005 3003300330033003 SET 3001 11 1 1 0

In this example, the messages carried is DATA 8 0 1 1000000035005 3003300330033003 SET 3001 11 1 1 0, the rest is part of the envelope protocol.

Here’s what those fields mean:

It’s implemented in src/lib/msg/msg-envelope.c.

3.14.4 Regular control messages

To establish a connection, maintain it, and do the OOB job, a set of control message is used. Those messages carry a bunch of informations about who is sending them, in fact, they just contain the informations that would otherwise be handled by out-of-band messages, but it’s convenient to have the information first-hand rather than relying on the other protocol.

The syntax is:

LW6 <VERSION> <PASSWORD_CHECKSUM> <PHYSICAL_TICKET_SIG> <LOGICAL_TICKET_SIG> <PHYSICAL_FROM_ID> <PHYSICAL_TO_ID> <LOGICAL_FROM_ID> <LOGICAL_TO_ID> <COMMAND> <PROGRAM> <VERSION> <CODENAME> <STAMP> <ID> <URL> <TITLE> <DESCRIPTION> <HAS_PASSWORD> <BENCH> <OPEN_RELAY> <UPTIME> <COMMUNITY_ID> <ROUND> <LEVEL> <REQUIRED_BENCH> <NB_COLORS> <MAX_NB_COLORS> <NB_CURSORS> <MAX_NB_CURSORS> <NB_NODES> <MAX_NB_NODES> <PEER_LIST> <COMMAND_ARGS>

Example:

LW6 0.1.3485 - ffffffff - 1001100110011001 2002200220022002 - - HELLO liquidwar6 0.1.3485 "Davy Crockett" 3485 1001100110011001 http://localhost:8057/ cGF0 RHVtbXkgdGVzdCBub2RlIEE= 0 10 0 5 372057f45b3d2ba5 10005 "Default map" 5 4 10 4 26 1 12 ""

The fields, starting from LW6 up to (and including) <LOGICAL_TO_ID> are part of the envelope, described previously.

The message fields are:

Here are the different possibilities for the <COMMAND> field.

It’s implemented in src/lib/msg/msg-cmd.c.

3.14.5 Regular MISS messages

Todo...

3.14.6 Regular META messages

Todo...

3.14.7 Regular DATA messages

Todo...

3.14.8 Other raw technical stuff (WIP)

TCP messages:

LW6 [<passwd>] <version> <client-id>
<from-id> <to-id> <serial> <i> <n> <sig> MSG1
<from-id> <to-id> <serial> <i> <n> <sig> MSG2

TCP oobs:

<return> # only works anonymous, same as INFO
INFO [<passwd>] [<public-url>]
LIST [<passwd>] [<public-url>]
PING [<passwd>] [<public-url>]

UDP messages:

LW6 [<passwd>] <version> <client-id> <from-id> <to-id> <serial> <i> <n> <sig> MSG1
LW6 [<passwd>] <version> <client-id> <from-id> <to-id> <serial> <i> <n> <sig> MSG2

UDP oobs:

INFO [<passwd>] [<public-url>]
LIST [<passwd>] [<public-url>]
PING [<passwd>] [<public-url>]

HTTP messages:

client id & password passed in HTTP headers

/lw6/version/<from-id>/<to-id>/<serial>/<i>/<n>/sig/MSG1
/lw6/version/<from-id>/<to-id>/<serial>/<i>/<n>/sig/MSG2

HTTP public URLs:

/ -> index.html
/index.html
/favicon.ico
/screenshot.jpeg
/robots.txt
/gpl.txt
/info.txt
/list.txt
/ping.txt

MSG syntax:

<round> <server-id> <command> <arg1> ... <argN>

COMMAND examples:

2 1234abcd1234abcd REGISTER
3 1234abcd1234abcd ADD 5678 YELLOW
4 1234abcd1234abcd SET 5678 20 5
10 1234abcd1234abcd NOP
400 1234abcd1234abcd REMOVE 5678
1000 1234abcd1234abcd UNREGISTER

Sig is a checksum on string:

<from-id> <to-id> <serial> <i> <n> MSG

Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.15 Technical HOWTOs

3.15.1 Release check-list

Summary off all operations required for a release:

3.15.2 Add a new option

This describes how to add a new option to the game.

Unless this is done, program won’t accept the option.

Some options need more work, for instance:

3.15.3 Add a new internal library

This describes how to add a new libxyz internal library:

3.15.4 Add a new module

This describes how to add a new mod-ab module, for instance a new bot, but gfx, snd, cli or srv backends should work pretty much the same:


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.16 Using GNU Arch

3.16.1 About GNU Arch

Since March, 4th 2010, Liquid War 6 uses GIT to handle source code, track changes, branches, and the rest. It replaces the GNU Arch repository. This old repository contains all sources up to version 0.0.7beta, following versions, including 0.0.8beta, must be retrieved from GIT.

So the following informations only concern those who are interested in previous versions of the game. Anybody else - probably you - should use GIT instead.

See Using GIT.

Still, this quick Arch survival guide is kept in the documentation.

Read the GNU Arch tutorial to learn how Arch works. Note that there are many other source control managers available, some of which provide functionnalities similar to GNU Arch / tla. GNU Arch has been chosen for Liquid War 6 because:

3.16.2 Getting the latest version from the repository

The repository for Liquid War 6 is accessible on http://arch.savannah.gnu.org/archives/liquidwar6. This is a read-only access, but with the distributed nature of GNU Arch, it still allows you to keep track of your own changes, and submit patches. Accessing it in read/write mode with sftp requires a Savannah account and special rights on the Liquid War 6 project.

Here are typicall commands one can use to get Liquid War 6 source from the GNU Arch repository:

tla register-archive http://arch.savannah.gnu.org/archives/liquidwar6
tla get -A liquidwar6@sv.gnu.org liquidwar6--beta

All the patches in the archive are signed with GnuPG, so you can check their authenticity with my public key.

You might need to edit your $HOME/.arch-params/signing/=default.check file and put the following text in it:

tla-gpg-check gpg_command="gpg --verify-files -"

3.16.3 Setting up your own arch repository

This section is for those who want to hack the game and set up their own repositories. This will enable you to keep track of your patches, package them, and help the core maintainer merging them in the main repository.

You can introduce yourself and create a repository by issuing commands like:

You can introduce yourself and create a repository by issuing commands like:

tla my-id me@home.net
tla register-archive me@home.net--2008 /home/me/tla-archives

Then, you can get create your own repository, with a command like:

tla tag -S liquidwar6@sv.gnu.org/liquidwar6--beta--0.1 me@home.net--2008/liquidwar6--beta--0.4

The idea is that you create, locally, a depot which has a name that matches the name on savannah (this is for convenience, you could technically give it any name...) and indicate that they represent, today, the same thing.

You can get a working copy of your depot with the command:

tla get me@home.net--2008/liquidwar6--beta--0.4

This will create a complete source tree, which you are free to modify, this is where you should hack.

3.16.4 Synchronizing your repository with upstream releases

To synchronize yourself with upstream developments, go into your copy (the directory created by tla get) and type:

tla star-merge liquidwar6@sv.gnu.org/liquidwar6--beta--0.1

This will apply locally all the changes that happened since the last synchronization. Of course this is one way to work, you can decide to cherry pick patches and such stuff, but for most dayly uses, a good’ol star-merge is fine.

Not that star-merge will only apply patches on your working copy, not on your repository. The only way to actually commit the modifications on the repository is to use the commit command.

3.16.5 Submitting patches

When using Arch, you can of course still send patches created with diff, or even send updated files directly, the way you would without revision control.

But it can be more convenient to either

Here’s an example of an mkpatch command, and which will compute the differences between a previous liquidwar6--beta--0.4--patch-2 snapshot and a not yet commited latest version:

tla mkpatch {arch}/++pristine-trees/unlocked/liquidwar6/liquidwar6--beta/liquidwar6--beta--0.4/me@home.net--2006/liquidwar6--beta--0.4--patch-2 . my-patch

This will create a my-patch directory, which can be gzipped and sent by mail.

3.16.6 Recover from broken lock

Sometimes, when signing a patch, you might enter the wrong passphrase several times, or you might press CTRL+D inadvertantly. In that case, tla will be in a half-broken state, telling you it can’t acquire revision lock... A quick workarround for this is to go to the depot, find the latest patch, and in this repository, create the following folders:

++revision-lock/+contents

Both are directories, note the two ++ and the single +. the +contents directory can be empty. Once you’ve done this, try to re-commit.


Next: , Previous: , Up: Hacker's guide   [Contents][Index]

3.17 Using GIT

3.17.1 About GIT

There’s no CVS or Subversion (AKA “SVN”) source depot for Liquid War 6. Instead, a GIT depot is used. GIT has many advantages over other source control managers (SCM), among them, it’s distributed, like GNU Arch.

You can find interesting informations on GIT here:

3.17.2 Getting the latest source

Simply install git and run the following command:

git clone git://git.sv.gnu.org/liquidwar6.git

If you are behing a firewall and can’t have direct TCP/IP access:

git clone http://git.sv.gnu.org/r/liquidwar6.git

Additionnally, source can be browsed online here: http://git.savannah.gnu.org/cgit/liquidwar6.git

3.17.3 Developper access

You need an ssh access on Savannah and appropriate rights on the project, then you can type:

git clone login@git.sv.gnu.org:/srv/git/liquidwar6.git

3.17.4 Submitting patches

If you have developper access to the project, then a simply git push will commit your changes.

If not (that is, if you checked out anonymously using git clone git://git.sv.gnu.org/liquidwar6.git for instance, you can still submit patches. Follow these steps:

Note that you can need to run git format-patch -p master (with master instead of origin) it not using a fresh checkout. Also consider adding the --stdout switch, eg git format-patch -p master --stdout > my-changes.patch if you’re not using a fresh checkout.


Previous: , Up: Hacker's guide   [Contents][Index]

3.18 Jenkins builds

Liquid War 6 uses Jenkins for continuous integration.

Each time a commit is done on the main GIT source tree, a build is triggered. The list of builds, their status, is available on:

It’s interesting, among other things, to look at the log produced when the game is built, as it contains the test suite output, and can provide usefull informations of what is supposed to happen when the game is built correctly, and what happens when things go wrong.


Next: , Previous: , Up: Top   [Contents][Index]

4 Reference

This chapter is a technical reference. Most of its content is self-generated by the program itself. That is to say, most if its content is already available to you if you have the game installed. Running liquidwar6 --list and liquidwar6 --about=<keyword> is very likely to give you the very same informations, the advantage being that you’ll be sure the information is up-to-date and corresponds to the exact version of the program you have. However, publishing this in a reader-friendly way is convenient, plus it enables web search engines to harvest the content.


Next: , Up: Reference   [Contents][Index]

4.1 Basic options

4.1.1 about

Command-line option: --about=<value>

Type: string

Will allow you to get informations about a given keyword. Let’s say that, for instance, you want informations about the keyword ’map-path’. Simply run ’liquidwar6 –about=map-path’. Note that this internal self-documentation system can describe command line switches as well as XML config file parameters or environment variables, and even some Guile script functions. The ’–list’ command line switch will give you the list of all available keywords.

4.1.2 audit

Command-line option: --audit

Display all path values, defaults and current settings. This output is very usefull to track down problems such as missing directories, broken installations. If you get an error message that suggests some file is missing, then give this option a try.

4.1.3 copyright

Command-line option: --copyright

Returns the copyright notice for the program.

4.1.4 credits

Command-line option: --credits

Gives hopefully extensive information on who contributed to the game.

4.1.5 debug

Command-line option: --debug

Enables debug mode. This will turn on maximum log information, and display everything on stderr, even messages which are normally only stored in the log file.

4.1.6 defaults

Command-line option: --defaults

Clears the config file and run the game with default settings. Use this if you suspect you have broken something by tweaking user settings, or when upgrading the game to a new version.

4.1.7 help

Command-line option: --help

Returns a short help for the program.

4.1.8 host

Command-line option: --host

Display all known system host properties, including os and cpu informations.

4.1.9 list

Command-line option: --list

Returns the list of all keywords which can be queried for information. This includes command-line options, environment variables, and so on. This is the companion option of ’–about’. Results obtained with ’–list’ can be passed to ’–about’.

4.1.10 modules

Command-line option: --modules

Tells which modules have been enabled when the game was compiled. It’s still possible to add or remove modules afterwards, but this option allows you to know how things were at first.

4.1.11 pedigree

Command-line option: --pedigree

Display all build values, these are general constants which can help debugging, tracing what binary you are running, and so on. It’s a good idea to take a look at the output of ’pedigree’ if you have problems running the game.

4.1.12 test

Command-line option: --test

Runs a (hopefully) complete test suite which will call most internal Liquid War 6 functions and check out wether they work, in a simple context, without any game interference. Usefull for troubleshooting.

4.1.13 version

Command-line option: --version

Returns the version of the program, as defined by the GNU Coding Standards.


Next: , Previous: , Up: Reference   [Contents][Index]

4.2 Doc options

4.2.1 example-hints-xml

Command-line option: --example-hints-xml

Dumps on stdout an example hints.xml file. Such a file is normally shipped with the game. It is indeed generated using this command.

4.2.2 example-rules-xml

Command-line option: --example-rules-xml

Dumps on stdout an example options.xml file. Such a file is normally shipped with the game. It is indeed generated using this command.

4.2.3 example-style-xml

Command-line option: --example-style-xml

Dumps on stdout an example style.xml file. Such a file is normally shipped with the game. It is indeed generated using this command.

4.2.4 example-teams-xml

Command-line option: --example-teams-xml

Dumps on stdout an example teams.xml file. Such a file is normally shipped with the game. It is indeed generated using this command.

4.2.5 list-advanced

Command-line option: --list-advanced

List advanced options which can be used for fine-tuning the game.

4.2.6 list-aliases

Command-line option: --list-aliases

List the keyword aliases. These are here for convenience.

4.2.7 list-doc

Command-line option: --list-doc

List documentation-related command line options. These commands allow you to list all the keywords related to a given domain.

4.2.8 list-funcs

Command-line option: --list-funcs

List the C-functions which are exported to Guile, thus usable in scripts.

4.2.9 list-graphics

Command-line option: --list-graphics

List graphics options (resolution, fullscreen...).

4.2.10 list-hooks

Command-line option: --list-hooks

List user-modifiable hooks.

4.2.11 list-input

Command-line option: --list-input

List input (AKA controls) related options. Use these to change keyboard, joystick and mouse settingds.

4.2.12 list-map

Command-line option: --list-map

List map-related entries, excluding rules.xml, hints.xml and style.xml entries.

4.2.13 list-map-hints

Command-line option: --list-map-hints

List ’hints.xml’ entries. These parameters enable you to modify the behavior of the map loader.

4.2.14 list-map-rules

Command-line option: --list-map-rules

List ’options.xml’ entries. These parameters enable you to modify the gameplay.

4.2.15 list-map-style

Command-line option: --list-map-style

List ’style.xml’ entries. These parameters enable you to modify the aspect of the game.

4.2.16 list-map-teams

Command-line option: --list-map-teams

List ’teams.xml’ entries. These parameters enable you to specify which teams should play on the map.

4.2.17 list-network

Command-line option: --list-network

List network options.

4.2.18 list-path

Command-line option: --list-path

List parameters which allow you to override the defaults of the game, and force the game your own file paths and directories.

4.2.19 list-players

Command-line option: --list-players

List player-related entries, that is to say ’who plays’.

4.2.20 list-quick

Command-line option: --list-quick

List quick help entries, this includes the GNU standard options and a few troubleshooting tools.

4.2.21 list-show

Command-line option: --list-show

List command-line options which begin with ’–show-...’. These will display on the console many internal parameters. Usefull when debugging.

4.2.22 list-sound

Command-line option: --list-sound

List sound options (volume...).

4.2.23 list-team-colors

Command-line option: --list-team-colors

List the team colors, there should be 10 of them

4.2.24 list-weapons

Command-line option: --list-weapons

List the available weapons.


Next: , Previous: , Up: Reference   [Contents][Index]

4.3 Show options

4.3.1 show-build-abs-srcdir

Command-line option: --show-build-abs-srcdir

Shows the top source directory on the machine where the binary was compiled, as an absolute path.

4.3.2 show-build-bin-id

Command-line option: --show-build-bin-id

Shows the internal ’bin-id’ value. This value does not mean anything in itself but it’s supposed to change each time you compile the game.

4.3.3 show-build-bugs-url

Command-line option: --show-build-bugs-url

Shows the URL to make bug reports.

4.3.4 show-build-cflags

Command-line option: --show-build-cflags

Shows what value you should put in ’CFLAGS’ (environment variable) if you want to compile programs that use Liquid War 6 as a library, and include ’liquidwar6.h’.

4.3.5 show-build-codename

Command-line option: --show-build-codename

Shows the codename associated with this version, generally the name of someone famous who is war-related (a general, an emperor...).

4.3.6 show-build-configure-args

Command-line option: --show-build-configure-args

Shows the arguments that have been passed to the GNU Autoconf ’./configure’ script when building the program. This can be very usefull if you want to know how the program has been built.

4.3.7 show-build-copyright

Command-line option: --show-build-copyright

Shows a very short copyright notice.

4.3.8 show-build-datadir

Command-line option: --show-build-datadir

Shows the ’datadir’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local/share’. This is the generic, non Liquid War 6 specific data directory. Liquid War 6 related data is stored elsewhere (usually in a sub-directory) see the ’data-dir’ switch for more information. ’datadir’ is not ’data-dir’. That’s the point.

4.3.9 show-build-date

Command-line option: --show-build-date

Shows the date when the binary was compiled.

4.3.10 show-build-docdir

Command-line option: --show-build-docdir

Shows the ’docdir’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local/share/doc/liquidwar6’.

4.3.11 show-build-enable-allinone

Command-line option: --show-build-enable-allinone

Shows wether the ’allinone’ option has been chosen when building the game. This depends on parameters passed to ’./configure’.

4.3.12 show-build-enable-console

Command-line option: --show-build-enable-console

Shows wether the console has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of ncurses and readline.

4.3.13 show-build-enable-fullstatic

Command-line option: --show-build-enable-fullstatic

Shows wether the ’fullstatic’ option has been chosen when building the game. This depends on parameters passed to ’./configure’.

4.3.14 show-build-enable-gcov

Command-line option: --show-build-enable-gcov

Shows wether the game was build with suitable informations for gcov. This depends on parameters passed to ’./configure’.

4.3.15 show-build-enable-gprof

Command-line option: --show-build-enable-gprof

Shows wether the game was build with suitable informations for gprof. This depends on parameters passed to ’./configure’.

4.3.16 show-build-enable-gtk

Command-line option: --show-build-enable-gtk

Shows wether GTK+ support has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of GTK+ headers and libs. It uses pkg-config to detect it.

4.3.17 show-build-enable-instrument

Command-line option: --show-build-enable-instrument

Shows wether the game was build with the ’-finstrument-functions’ GCC switch. This depends on parameters passed to ’./configure’.

4.3.18 show-build-enable-mod-caca

Command-line option: --show-build-enable-mod-caca

Shows wether the mod-caca graphical backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of libcaca related libraries.

4.3.19 show-build-enable-mod-csound

Command-line option: --show-build-enable-mod-csound

Shows wether the mod-csound audio backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of the csound library.

4.3.20 show-build-enable-mod-gl1

Command-line option: --show-build-enable-mod-gl1

Shows wether the mod-gl1 graphical backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of SDL and OpenGL related libraries.

4.3.21 show-build-enable-mod-gles2

Command-line option: --show-build-enable-mod-gles2

Shows wether the mod-gles2 graphical backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of SDL and OpenGL ES related libraries.

4.3.22 show-build-enable-mod-http

Command-line option: --show-build-enable-mod-http

Shows wether the mod-http network backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of libCurl.

4.3.23 show-build-enable-mod-ogg

Command-line option: --show-build-enable-mod-ogg

Shows wether the mod-ogg audio backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of SDL and related libraries.

4.3.24 show-build-enable-mod-soft

Command-line option: --show-build-enable-mod-soft

Shows wether the mod-soft graphical backend has been enabled when building the game. This depends on parameters passed to ’./configure’ and also on the presence of SDL related libraries.

4.3.25 show-build-enable-openmp

Command-line option: --show-build-enable-openmp

Shows wether the program was built with OpenMP support. This depends on parameters passed to ’./configure’.

4.3.26 show-build-enable-optimize

Command-line option: --show-build-enable-optimize

Shows wether the ’optimize’ option has been chosen when building the game. This depends on parameters passed to ’./configure’.

4.3.27 show-build-enable-paranoid

Command-line option: --show-build-enable-paranoid

Shows wether the game was build with paranoid memory management. This is for debugging purposes, the default already includes some controls, with turned it’s really... paranoid.

4.3.28 show-build-enable-profiler

Command-line option: --show-build-enable-profiler

Shows wether the game was build with Google Profiler support. This depends on parameters passed to ’./configure’.

4.3.29 show-build-enable-valgrind

Command-line option: --show-build-enable-valgrind

Shows wether the game was build with valgrind later use in mind. This depends on parameters passed to ’./configure’.

4.3.30 show-build-endianness

Command-line option: --show-build-endianness

Returns the endianness. ’little’ corresponds to x86-like systems, ’big’ to ppc-like systems.

4.3.31 show-build-gcc-version

Command-line option: --show-build-gcc-version

Returns the version of the GNU C compiler which was used to compile the program.

4.3.32 show-build-gnu

Command-line option: --show-build-gnu

Returns 1 (true) if host OS is a GNU system, or at least has been considered as such when compiling, 0 (false) if not.

4.3.33 show-build-gp2x

Command-line option: --show-build-gp2x

Returns 1 (true) if host is a GP2X, 0 (false) if not.

4.3.34 show-build-home-url

Command-line option: --show-build-home-url

Shows the URL of the program, its homepage.

4.3.35 show-build-host-cpu

Command-line option: --show-build-host-cpu

Shows the host CPU, as defined by ’host_cpu’ in GNU Autoconf.

4.3.36 show-build-host-os

Command-line option: --show-build-host-os

Shows the host OS, as defined by ’host_os’ in GNU Autoconf.

4.3.37 show-build-hostname

Command-line option: --show-build-hostname

Shows the name of the host where the binary was compiled.

4.3.38 show-build-includedir

Command-line option: --show-build-includedir

Shows the ’includedir’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local/include’.

4.3.39 show-build-ldflags

Command-line option: --show-build-ldflags

Shows what value you should put in ’LDFLAGS’ (environment variable) if you want to link programs against libliquidwar6.

4.3.40 show-build-libdir

Command-line option: --show-build-libdir

Shows the ’libdir’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local/lib’. This is the generic, non Liquid War 6 specific library directory. Dedicated Liquid War 6 modules are stored elsewhere (usually in a sub-directory) see the ’mod-dir’ switch for more information.

4.3.41 show-build-license

Command-line option: --show-build-license

Shows the license of the program (GNU GPL v3 or later).

4.3.42 show-build-localedir

Command-line option: --show-build-localedir

Shows the ’localedir’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local/share/locale’.

4.3.43 show-build-mac-os-x

Command-line option: --show-build-mac-os-x

Returns 1 (true) if host OS is Mac OS X, 0 (false) if not.

4.3.44 show-build-md5sum

Command-line option: --show-build-md5sum

Shows the MD5 checksum, which has been calculated from the C source files. Complementary with ’show-build-stamp’.

4.3.45 show-build-ms-windows

Command-line option: --show-build-ms-windows

Returns 1 (true) if host OS is Microsoft Windows, 0 (false) if not.

4.3.46 show-build-package-id

Command-line option: --show-build-package-id

Shows the package tarname with its version, that is, ’liquidwar6-<version>

4.3.47 show-build-package-name

Command-line option: --show-build-package-name

Shows the package name, that is, ’Liquid War 6’.

4.3.48 show-build-package-string

Command-line option: --show-build-package-string

Shows the package string, that is, ’Liquid War 6 <version>

4.3.49 show-build-package-tarname

Command-line option: --show-build-package-tarname

Shows the package tarname, that is, liquidwar6.

4.3.50 show-build-pointer-size

Command-line option: --show-build-pointer-size

Returns the pointer size, in bytes. Should be 4 on 32-bit systems and 8 on 64-bit systems.

4.3.51 show-build-prefix

Command-line option: --show-build-prefix

Shows the ’prefix’ value as passed to the GNU Autoconf ’./configure’ script when compiling the program. Default is ’/usr/local’.

4.3.52 show-build-stamp

Command-line option: --show-build-stamp

Shows the build stamp. A very usefull value, more precise than the version to track down binaries. It is incremented each time the core C code is updated. It won’t reflect all the programs for it does not take scripts in account, but if you are running a work-in-progress version, it might be very convenient to use this to know what your are running exactly. It’s also used as the revision number (the third number afer MAJOR.MINOR).

4.3.53 show-build-time

Command-line option: --show-build-time

Shows the time when the binary was compiled.

4.3.54 show-build-top-srcdir

Command-line option: --show-build-top-srcdir

Shows the top source directory on the machine where the binary was compiled, as a (possibly) relative path.

4.3.55 show-build-unix

Command-line option: --show-build-unix

Returns 1 (true) if host OS is a UNIX system, or at least has been considered as such when compiling, 0 (false) if not.

4.3.56 show-build-version

Command-line option: --show-build-version

Shows the version. Note that this is different from the standard GNU ’version’ command line option which shows a complete message with a short copyright notice. This one will just return the version, without the package tarname or anything else.

4.3.57 show-build-version-base

Command-line option: --show-build-version-base

Shows the version base. This is basically MAJOR.MINOR and determines the level of compatibility of the program. Two programs with the same base version should be able to communicate on the network, share data files and even binary modules if on the same platform.

4.3.58 show-build-version-major

Command-line option: --show-build-version-major

Shows the major version number. This is just used to differenciate alpha/beta releases (using 0) from stable releases (using 6).

4.3.59 show-build-version-minor

Command-line option: --show-build-version-minor

Shows the minor version number. This is manually increased at each significant, public release of the game.

4.3.60 show-build-x86

Command-line option: --show-build-x86

Tells wether the CPU belongs to x86 family.

4.3.61 show-config-file

Command-line option: --show-config-file

Shows the config file path. Default is ’$HOME/.liquidwar6/config.xml’.

4.3.62 show-cwd

Command-line option: --show-cwd

Shows the current working directory, the value that the pwd command would return.

4.3.63 show-data-dir

Command-line option: --show-data-dir

Shows the data directory path. This is where the games searches for most of its data,the most important exception being maps, which are stored elsewhere. Default is ’/usr/local/share/liquidwar6-<version>/data’.

4.3.64 show-default-config-file

Command-line option: --show-default-config-file

Shows the default config file path. Default is ’$HOME/.liquidwar6/config.xml’.

4.3.65 show-default-data-dir

Command-line option: --show-default-data-dir

Shows the default data directory path. This is where the games searches for most of its data,the most important exception being maps, which are stored elsewhere. Default is ’/usr/local/share/liquidwar6-<version>/data’.

4.3.66 show-default-log-file

Command-line option: --show-default-log-file

Shows the default log file path. Default is ’$HOME/.liquidwar6/log.csv’.

4.3.67 show-default-map-dir

Command-line option: --show-default-map-dir

Shows the default map directory. This is where builtin maps are stored. Default is ’/usr/local/share/liquidwar6-<version>/map’.

4.3.68 show-default-map-path

Command-line option: --show-default-map-path

Shows the default map search path. This is where the game searches for maps. It’s the combination of command-line arguments and builtin paths. Might return more directories than the one specified in a single ’map-path=dir1:dir2’ argument.

4.3.69 show-default-mod-dir

Command-line option: --show-default-mod-dir

Shows the default module directory path. This is where all dynamically loaded modules are stored. Default is ’/usr/local/lib/liquidwar6-<version>’.

4.3.70 show-default-music-dir

Command-line option: --show-default-music-dir

Shows the default music directory. This is where builtin musics are stored. Default is ’/usr/local/share/liquidwar6-<version>/music’.

4.3.71 show-default-music-path

Command-line option: --show-default-music-path

Shows the default music search path. This is where the game searches for musics. It’s the combination of command-line arguments and builtin paths. Might return more directories than the one specified in a single ’music-path=dir1:dir2’ argument.

4.3.72 show-default-prefix

Command-line option: --show-default-prefix

Shows the default prefix used. This should logically be the value passed to the GNU Autoconf ./configure script when building the game. Most other path are deduced from this one. Default is ’/usr/local’.

4.3.73 show-default-script-file

Command-line option: --show-default-script-file

Shows the default main script file path. This file is very important, since the program is more or less a hudge scheme interpreter, and this file is the file loaded by Guile. In short, it is the main program. Default is ’/usr/local/share/liquidwar6-<version>/script/liquidwar6.scm’.

4.3.74 show-default-user-dir

Command-line option: --show-default-user-dir

Shows the default user directory path. This is where run-time data, config files, log files, are stored. Default is ’$HOME/.liquidwar6/’.

4.3.75 show-log-file

Command-line option: --show-log-file

Shows the log file path. Default is ’$HOME/.liquidwar6/log.csv’.

4.3.76 show-map-dir

Command-line option: --show-map-dir

Shows the map directory. This is where builtin maps are stored. Default is ’/usr/local/share/liquidwar6-<version>/map’.

4.3.77 show-map-path

Command-line option: --show-map-path

Shows the map search path. This is where the game searches for maps. It’s the combination of command-line arguments and builtin paths. Might return more directories than the one specified in a single ’map-path=dir1:dir2’ argument.

4.3.78 show-mod-dir

Command-line option: --show-mod-dir

Shows the module directory path. This is where all dynamically loaded modules are stored. Default is ’/usr/local/lib/liquidwar6-<version>’.

4.3.79 show-music-dir

Command-line option: --show-music-dir

Shows the music directory. This is where builtin maps are stored. Default is ’/usr/local/share/liquidwar6-<version>/music’.

4.3.80 show-music-path

Command-line option: --show-music-path

Shows the music search path. This is where the game searches for musics. It’s the combination of command-line arguments and builtin paths. Might return more directories than the one specified in a single ’music-path=dir1:dir2’ argument.

4.3.81 show-prefix

Command-line option: --show-prefix

Shows the prefix used. This should logically be the value passed to the GNU Autoconf ./configure script when building the game. Most other path are deduced from this one. Default is ’/usr/local’.

4.3.82 show-run-dir

Command-line option: --show-run-dir

Shows the run directory, usually the path where the binary is. It depends on how and where the program is launched. It is guessed from the argc/argv values at runtime.

4.3.83 show-script-file

Command-line option: --show-script-file

Shows the main script file path. This file is very important, since the program is more or less a hudge scheme interpreter, and this file is the file loaded by Guile. In short, it is the main program. Default is ’/usr/local/share/liquidwar6-<version>/script/liquidwar6.scm’.

4.3.84 show-user-dir

Command-line option: --show-user-dir

Shows the user directory path. This is where run-time data, config files, log files, are stored. Default is ’$HOME/.liquidwar6/’.


Next: , Previous: , Up: Reference   [Contents][Index]

4.4 Path options

4.4.1 config-file

Command-line option: --config-file

Type: string

Default value: $HOME/.liquidwar6/config.xml

Set the config file path. This enables you to use whatever config file you like, keeping all other informations in the same place.

4.4.2 data-dir

Command-line option: --data-dir

Type: string

Default value: /usr/local/share/liquidwar6-<version>/data

Set the data directory. By changing ths value you’ll be able to use an alternative data directory.

4.4.3 log-file

Command-line option: --log-file=<value>
Environment variable: LW6_LOG_FILE
XML key: log-file

Type: string

Default value: $HOME/.liquidwar6/log.csv

Set the log file path. This enables you to use whatever log file you like, keeping all other informations in the same place.

4.4.4 map-dir

Command-line option: --map-dir

Type: string

Default value: /usr/local/share/liquidwar6-<version>/map

Set the map directory path. By changing this value you’ll be able to play with your own maps in your own directory. Note that there are other ways to achieve that, but using this option will work. However, a side effect is that you might not see builtin maps anymore.

4.4.5 map-path

Command-line option: --map-path=<value>
Environment variable: LW6_MAP_PATH
XML key: map-path

Type: string

Default value: $HOME/.liquidwar6/map:/usr/local/share/liquidwar6-<version>/map

Set the map search path. By changing this value you’ll be able to play with your own maps in your own directory. This is different from ’map-dir’, since it includes ’map-dir’, plus it adds a number of other search paths. Unlike most other parameters, the values given from the command-line, from the environment variables, or from the config file, are not overwritten, but appended. That is to say if you specify a ’map-path’ with the command-line argument ’map-path=path’, but also define the ’LW6_MAP_PATH’ value and finally edit ’config.xml’ to change the ’map-path’ entry in it, you’ll end up with the game searching for maps in all these directories. Additionnally, ’map-dir’ and ’<user-dir>/map’ will always be in the list. Any given value can itself include several pathes, separated by the path separator. This separator is ’:’ on GNU/Linux, and ’;’ on Microsoft Windows. For instance, on a GNU/Linux box, you could use the command-line argument ’map-path=/foo/bar/map:/home/user/map/:/map’.

4.4.6 mod-dir

Command-line option: --mod-dir

Type: string

Default value: /usr/local/lib/liquidwar6-<version>

Set the module directory path. By changing this you will load dynamic shared libraries (game specific modules such as the graphical backend) from an alternative place. Use this at your own risks, for there can always be a binary incompatibility. You’ve been warned.

4.4.7 music-dir

Command-line option: --music-dir=<value>
Environment variable: LW6_MUSIC_DIR
XML key: music-dir

Type: string

Default value: /usr/local/share/liquidwar6-<version>/music

Set the music directory path. By changing this value you’ll be able to use your own musics in your own directory. Note that there are other ways to achieve that, but using this option will work. The major side effect is that using this option, you really replace the existing builtin musics by your own. If you simply want to add musics you can store them in $HOME/.liquidwar6/music or in the map directory itself.

4.4.8 music-path

Command-line option: --music-path=<value>
Environment variable: LW6_MUSIC_PATH
XML key: music-path

Type: string

Default value: $HOME/.liquidwar6/music:/usr/local/share/liquidwar6-<version>/music

Set the music search path. By changing this value you’ll be able to play with your own musics in your own directory. This is different from ’music-dir’, since it includes ’music-dir’, plus it adds a number of other search paths. Unlike most other parameters, the values given from the command-line, from the environment variables, or from the config file, are not overwritten, but appended. That is to say if you specify a ’music-path’ with the command-line argument ’music-path=path’, but also define the ’LW6_MUSIC_PATH’ value and finally edit ’config.xml’ to change the ’music-path’ entry in it, you’ll end up with the game searching for musics in all these directories. Additionnally, ’music-dir’ and ’<user-dir>/music’ will always be in the list. Any given value can itself include several pathes, separated by the path separator. This separator is ’:’ on GNU/Linux, and ’;’ on Microsoft Windows. For instance, on a GNU/Linux box, you could use the command-line argument ’music-path=/foo/bar/music:/home/user/music/:/music’.

4.4.9 prefix

Command-line option: --prefix

Type: string

Default value: /usr/local

Override the prefix value given to the GNU Autoconf ./configure script when building the game. Not all path will be changed, some of them might remain the same, for instance message translations (localedir). But most game-specific data including maps, graphics, sounds, will be searched according to the new given parameter.

4.4.10 script-file

Command-line option: --script-file

Type: string

Default value: /usr/local/share/liquidwar6-<version>/script/liquidwar6.scm

Set the main script file path. This file is very important, since the program is more or less a hudge scheme interpreter, and this file is the file loaded by Guile. In short, it is the main program.

4.4.11 user-dir

Command-line option: --user-dir=<value>
Environment variable: LW6_USER_DIR
XML key: user-dir

Type: string

Default value: $HOME/.liquidwar6

Set the user directory path. This is where run-time data, config files, log files, are stored. If you override this value, other parameters such as where the config and log files reside, will change.


Next: , Previous: , Up: Reference   [Contents][Index]

4.5 Players options

4.5.1 player1-control

Command-line option: --player1-control=<value>
Environment variable: LW6_PLAYER1_CONTROL
XML key: player1-control

Type: string

Default value: mouse

Control for the first player, must be mouse, keyboard, joystick1, joystick2 or custom.

4.5.2 player1-name

Command-line option: --player1-name=<value>
Environment variable: LW6_PLAYER1_NAME
XML key: player1-name

Type: string

Default value: <username>

Name of the first player, the player used by default. A default value is provided, you can of course, change it at will.

4.5.3 player1-status

Command-line option: --player1-status=<value>
Environment variable: LW6_PLAYER1_STATUS
XML key: player1-status

Type: boolean

Default value: true

Status of the first player, true if player is activated, false if idle.

4.5.4 player2-control

Command-line option: --player2-control=<value>
Environment variable: LW6_PLAYER2_CONTROL
XML key: player2-control

Type: string

Default value: keyboard

Control for the second player, must be mouse, keyboard, joystick1, joystick2 or custom.

4.5.5 player2-name

Command-line option: --player2-name=<value>
Environment variable: LW6_PLAYER2_NAME
XML key: player2-name

Type: string

Default value: player2-<hostname>

Name of the second player. A default value is provided, you’ll certainly want to change it.

4.5.6 player2-status

Command-line option: --player2-status=<value>
Environment variable: LW6_PLAYER2_STATUS
XML key: player2-status

Type: boolean

Default value: true

Status of the second player, true if player is activated, false if idle.

4.5.7 player3-control

Command-line option: --player3-control=<value>
Environment variable: LW6_PLAYER3_CONTROL
XML key: player3-control

Type: string

Default value: joystick1

Control for the third player, must be mouse, keyboard, joystick1, joystick2 or custom.

4.5.8 player3-name

Command-line option: --player3-name=<value>
Environment variable: LW6_PLAYER3_NAME
XML key: player3-name

Type: string

Default value: player3-<hostname>

Name of the third player. A default value is provided, you’ll certainly want to change it.

4.5.9 player3-status

Command-line option: --player3-status=<value>
Environment variable: LW6_PLAYER3_STATUS
XML key: player3-status

Type: boolean

Default value: false

Status of the third player, true if player is activated, false if idle.

4.5.10 player4-control

Command-line option: --player4-control=<value>
Environment variable: LW6_PLAYER4_CONTROL
XML key: player4-control

Type: string

Default value: joystick2

Control for the fourth player, must be mouse, keyboard, joystick1, joystick2 or custom.

4.5.11 player4-name

Command-line option: --player4-name=<value>
Environment variable: LW6_PLAYER4_NAME
XML key: player4-name

Type: string

Default value: player4-<hostname>

Name of the fourth player. A default value is provided, you’ll certainly want to change it.

4.5.12 player4-status

Command-line option: --player4-status=<value>
Environment variable: LW6_PLAYER4_STATUS
XML key: player4-status

Type: boolean

Default value: false

Status of the fourth player, true if player is activated, false if idle.


Next: , Previous: , Up: Reference   [Contents][Index]

4.6 Input options

4.6.1 auto-release-delay

Command-line option: --auto-release-delay=<value>
Environment variable: LW6_AUTO_RELEASE_DELAY
XML key: auto-release-delay

Type: integer

Default value: 250

Time, in milliseconds, before which a key is automatically released. This might or might not be used by the graphics backend, it’s typically used by backends which don’t always handle key releases events the right way, that is, don’t fire them. Libcaca is a good example of such a case.

4.6.2 click-to-focus

Command-line option: --click-to-focus=<value>
Environment variable: LW6_CLICK_TO_FOCUS
XML key: click-to-focus

Type: boolean

Default value: false

If set to true, you’ll need to click with the mouse to select a menuitem or move the cursor in the game. If not, some actions will be taken automatically without the need to click.

4.6.3 cursor-sensitivity

Command-line option: --cursor-sensitivity=<value>
Environment variable: LW6_CURSOR_SENSITIVITY
XML key: cursor-sensitivity

Type: float

Default value: 1.0

Keyboard and joystick sensitivity while moving the cursor. 1.0 is the default, 0.1 is slow, 10 is reponsive. This is used for moving the cursor during the game only, the option has no impact on menu navigation.

4.6.4 custom-alt

Command-line option: --custom-alt=<value>
Environment variable: LW6_CUSTOM_ALT
XML key: custom-alt

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 110) ; SDLK_n

Guile custom code associated to the ALT key equivalent.

4.6.5 custom-ctrl

Command-line option: --custom-ctrl=<value>
Environment variable: LW6_CUSTOM_CTRL
XML key: custom-ctrl

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 98) ; SDLK_b

Guile custom code associated to the CTRL key equivalent.

4.6.6 custom-down

Command-line option: --custom-down=<value>
Environment variable: LW6_CUSTOM_DOWN
XML key: custom-down

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 100) ; SDLK_d

Guile custom code associated to the DOWN key equivalent.

4.6.7 custom-enter

Command-line option: --custom-enter=<value>
Environment variable: LW6_CUSTOM_ENTER
XML key: custom-enter

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 103) ; SDLK_g

Guile custom code associated to the ENTER key equivalent.

4.6.8 custom-esc

Command-line option: --custom-esc=<value>
Environment variable: LW6_CUSTOM_ESC
XML key: custom-esc

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 102) ; SDLK_f

Guile custom code associated to the ESC key equivalent.

4.6.9 custom-left

Command-line option: --custom-left=<value>
Environment variable: LW6_CUSTOM_LEFT
XML key: custom-left

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 99) ; SDLK_c

Guile custom code associated to the LEFT key equivalent.

4.6.10 custom-pgdown

Command-line option: --custom-pgdown=<value>
Environment variable: LW6_CUSTOM_PGDOWN
XML key: custom-pgdown

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 115) ; SDLK_s

Guile custom code associated to the PGDOWN key equivalent.

4.6.11 custom-pgup

Command-line option: --custom-pgup=<value>
Environment variable: LW6_CUSTOM_PGUP
XML key: custom-pgup

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 119) ; SDLK_w

Guile custom code associated to the PGUP key equivalent.

4.6.12 custom-right

Command-line option: --custom-right=<value>
Environment variable: LW6_CUSTOM_RIGHT
XML key: custom-right

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 118) ; SDLK_v

Guile custom code associated to the RIGHT key equivalent.

4.6.13 custom-up

Command-line option: --custom-up=<value>
Environment variable: LW6_CUSTOM_UP
XML key: custom-up

Type: string

Default value: (c-lw6gui-keyboard-is-pressed 101) ; SDLK_e

Custom keycode to be used as the UP key equivalent.

4.6.14 double-click-delay

Command-line option: --double-click-delay=<value>
Environment variable: LW6_DOUBLE_CLICK_DELAY
XML key: double-click-delay

Type: integer

Default value: 333

Time, in milliseconds, determining wether two consecutive clicks make a double-click or not.

4.6.15 max-cursor-speed

Command-line option: --max-cursor-speed=<value>
Environment variable: LW6_MAX_CURSOR_SPEED
XML key: max-cursor-speed

Type: float

Default value: 10.0

Maximum cursor speed when cursor is controlled with keyboard or joystick joystick 1. Consider using cursor-sensitivity too.

4.6.16 mouse-sensitivity

Command-line option: --mouse-sensitivity=<value>
Environment variable: LW6_MOUSE_SENSITIVITY
XML key: mouse-sensitivity

Type: float

Default value: 1.0

Mouse sensitivity, 1.0 is the default, 0.1 is slow, 10 is reponsive. This is used for moving the cursor during the game only, the option has no impact on menu navigation.

4.6.17 repeat-delay

Command-line option: --repeat-delay=<value>
Environment variable: LW6_REPEAT_DELAY
XML key: repeat-delay

Type: integer

Default value: 500

Time, in milliseconds, before key repeat will start, use 0 to disable.

4.6.18 repeat-interval

Command-line option: --repeat-interval=<value>
Environment variable: LW6_REPEAT_INTERVAL
XML key: repeat-interval

Type: integer

Default value: 100

Time, in milliseconds, between two repeats, once repeat has started, use 0 to disable.

4.6.19 use-double-click

Command-line option: --use-double-click=<value>
Environment variable: LW6_USE_DOUBLE_CLICK
XML key: use-double-click

Type: boolean

Default value: false

Wether to use double-click feature, mostly usefull if running on a system that has only one button (such as a tablet-PC or anything with a tactile screen), if your mouse has three buttons, disabling this might avoid some confusion. Basically, if enabled, double-click is equivalent to right-click (fire) and triple-click is equivalent to middle-click (alternate fire).

4.6.20 use-esc-button

Command-line option: --use-esc-button=<value>
Environment variable: LW6_USE_ESC_BUTTON
XML key: use-esc-button

Type: boolean

Default value: true

Decides wether to display an ’esc’ (escape) button in the interface. This is usefull for people who control the game with the mouse only, and have a single buttons, or on a touchscreen.

4.6.21 zoom-step

Command-line option: --zoom-step=<value>
Environment variable: LW6_ZOOM_STEP
XML key: zoom-step

Type: float

Default value: 1.1

A value, strictly greater than 1, which will be used when zooming. The greater it is, the more sensible the zoom is.

4.6.22 zoom-stick-delay

Command-line option: --zoom-stick-delay=<value>
Environment variable: LW6_ZOOM_STICK_DELAY
XML key: zoom-stick-delay

Type: float

Default value: 1000

How long, in msec, the zoom will stick to its default value.


Next: , Previous: , Up: Reference   [Contents][Index]

4.7 Graphics options

4.7.1 capture

Command-line option: --capture=<value>
Environment variable: LW6_CAPTURE
XML key: capture

Type: boolean

Default value: false

Enables capture mode, in which a BMP file is dumped on the disk (in your user directory, search for a ’capture’ sub-directory).

4.7.2 fullscreen

Command-line option: --fullscreen=<value>
Environment variable: LW6_FULLSCREEN
XML key: fullscreen

Type: boolean

Default value: false

Force the game to fun fullscreen. Note that the graphics backend might ignore this hint.

4.7.3 gfx-backend

Command-line option: --gfx-backend=<value>
Environment variable: LW6_GFX_BACKEND
XML key: gfx-backend

Type: string

Default value: gl1

Sets the graphics backend AKA ’gfx’ to use. For now the only reasonnable choice is ’gl1’ and will use an OpenGL v1 / SDL 3D-accelerated driver.

4.7.4 gfx-quality

Command-line option: --gfx-quality=<value>
Environment variable: LW6_GFX_QUALITY
XML key: gfx-quality

Type: integer

Default value: 1 Min value: 0 Max value: 2

Sets the overall quality of the graphics backend. Depending on the backend, this can mean different things. For instance for the ’gl’ backend, this can change texture filtering (nearest, linear, bilinear...). This is not the same as ’pixelize’ which is a per-map option and emulates an old school appearance.

4.7.5 height

Command-line option: --height=<value>
Environment variable: LW6_HEIGHT
XML key: height

Type: integer

Default value: -1

Run the game with the given screen height.Note that the graphics backend might ignore this hint. Use with its companion option ’width’. A negative value will force the use of a default value.

4.7.6 width

Command-line option: --width=<value>
Environment variable: LW6_WIDTH
XML key: width

Type: integer

Default value: -1

Run the game with the given screen width. Note that the graphics backend might ignore this hint. Use with its companion option ’height’.A negative value will force the use of a default value.

4.7.7 windowed-mode-limit

Command-line option: --windowed-mode-limit=<value>
Environment variable: LW6_WINDOWED_MODE_LIMIT
XML key: windowed-mode-limit

Type: float

Default value: 0.95

When switching back from fullscreen mode to windowed mode, if we’re in maximum resolution, then this coefficient will be applied before resizing the window. The idea is that (obviously) a windowed mode is prefered when a little smaller that totally fullscreen. So set this to a value just below 1.0.


Next: , Previous: , Up: Reference   [Contents][Index]

4.8 Sound options

4.8.1 ambiance-exclude

Command-line option: --ambiance-exclude=<value>
Environment variable: LW6_AMBIANCE_EXCLUDE
XML key: ambiance-exclude

Type: string

Default value:

If this string is present in a music file name, this file won’t be played during the menus, it will be excluded from the list.

4.8.2 ambiance-file

Command-line option: --ambiance-file=<value>
Environment variable: LW6_AMBIANCE_FILE
XML key: ambiance-file

Type: string

Default value:

A music file which will be used to be played during the menus. If not found, game will fallback on random files.

4.8.3 ambiance-filter

Command-line option: --ambiance-filter=<value>
Environment variable: LW6_AMBIANCE_FILTER
XML key: ambiance-filter

Type: string

Default value: Chadburn

A music filter, used to select the files which are played while navigating in the menus. It works like ’music-filter’ except this one is not related to a peculiar map. This is not a complex regex-enabled filter, just a plain string search. Even the ’*’ wildcard won’t work.

4.8.4 fx-volume

Command-line option: --fx-volume=<value>
Environment variable: LW6_FX_VOLUME
XML key: fx-volume

Type: float

Default value: 0.3 Min value: 0 Max value: 1

Set the sound effects volume. This is a floating point value. 0 is mute. Maximum value is 1.

4.8.5 music-volume

Command-line option: --music-volume=<value>
Environment variable: LW6_MUSIC_VOLUME
XML key: music-volume

Type: float

Default value: 0.6 Min value: 0 Max value: 1

Set the music volume.This is a floating point value. 0 is mute. Maximum value is 1.

4.8.6 snd-backend

Command-line option: --snd-backend=<value>
Environment variable: LW6_SND_BACKEND
XML key: snd-backend

Type: string

Default value: ogg

Sets the sound backend AKA ’snd’ to use. Can be ’ogg’ or ’csound’ but only ’ogg’ will produce sound in the current release.

4.8.7 water-volume

Command-line option: --water-volume=<value>
Environment variable: LW6_WATER_VOLUME
XML key: water-volume

Type: float

Default value: 0.2 Min value: 0 Max value: 1

Set the volume for water sounds. This is a floating point value. 0 is mute. Maximum value is 1.


Next: , Previous: , Up: Reference   [Contents][Index]

4.9 Network options

4.9.1 bind-ip

Command-line option: --bind-ip=<value>
Environment variable: LW6_BIND_IP
XML key: bind-ip

Type: string

Default value: 0.0.0.0

The IP address to bind on when listening to network messages. You can use this to specifically use a given network interface, the default will listen on any available interface.

4.9.2 bind-port

Command-line option: --bind-port=<value>
Environment variable: LW6_BIND_PORT
XML key: bind-port

Type: integer

Default value: 8056 Min value: 1 Max value: 65535

The IP port to bind on when listening to network messages. The default should work out of the box, and will ease up the discovery process. That is, if you use your own settings, automatic detection of your server by other servers might not work so well.

4.9.3 broadcast

Command-line option: --broadcast=<value>
Environment variable: LW6_BROADCAST
XML key: broadcast

Type: boolean

Default value: true

Allows the program to send broadcast messages on the network. It can be usefull to disable those if you don’t use UDP node discovery and/or if there’s a sysadmin arround who does not enjoy permanent broadcasts on his LAN.

4.9.4 cli-backends

Command-line option: --cli-backends=<value>
Environment variable: LW6_CLI_BACKENDS
XML key: cli-backends

Type: string

Default value: tcp,udp,http

The client backends to use. Most of the time the default is fine, change it only if you specifically want to disactivate some protocol, or if you want to activate a custom-made client backend. It’s a comma separated list.

4.9.5 known-nodes

Command-line option: --known-nodes=<value>
Environment variable: LW6_KNOWN_NODES
XML key: known-nodes

Type: string

Default value: http://ufoot.org:8056/,http://ufoot.hd.free.fr:8056/

List of known nodes, nodes which the program will try to contact first to get the list of other nodes. This is mostly usefull when program is launched for the first time, after this it should keep an up-to-date list of known servers in its internal database and automatically reconnect to them next time it starts. You might want to change this if you really want to connect to a given server which is not publically listed. The list is comma separated.

4.9.6 node-description

Command-line option: --node-description=<value>
Environment variable: LW6_NODE_DESCRIPTION
XML key: node-description

Type: string

Default value: No description.

The description of your node, that is a text that describes your server. This will typically appear when pointing a web client on the public server URL, it is for general information, so if there’s something special about your server, say it here.

4.9.7 node-title

Command-line option: --node-title=<value>
Environment variable: LW6_NODE_TITLE
XML key: node-title

Type: string

Default value:

The title of your node, that is the name which will be displayed when listing servers. This is different from player name, for there can be several players on a single computer. By default this will be set to hostname.

4.9.8 password

Command-line option: --password=<value>
Environment variable: LW6_PASSWORD
XML key: password

Type: string

Default value:

The password to use for network games. Do not use a valuable password, as this is stored as clear text on your hard drive. Still, the game will only send a hash/checksum of the password on the network so eavesdropper won’t be able to read it. They can see the hash/checksum and use it if clever, but they can’t guess the real password. A blank password means anyone can join your games when you act like a server.

4.9.9 public-url

Command-line option: --public-url=<value>
Environment variable: LW6_PUBLIC_URL
XML key: public-url

Type: string

Default value:

The public URL of your server. By default the game will pick up one for you. In fact, the clients discovering your server should guess the public URL, probably http://<your-ip>:<your-port>/ but you might need to use your own settings if you are using NAT or an Apache reverse-proxy to rewrite HTTP requests.

4.9.10 skip-network

Command-line option: --skip-network=<value>
Environment variable: LW6_SKIP_NETWORK
XML key: skip-network

Type: boolean

Default value: false

If set, then game won’t do anything network related. No listen, no connect, no nothing. You are playing locally.

4.9.11 srv-backends

Command-line option: --srv-backends=<value>
Environment variable: LW6_SRV_BACKENDS
XML key: srv-backends

Type: string

Default value: tcpd,udpd,httpd

The server backends to use. Most of the time the default is fine, change it only if you specifically want to disactivate some protocol, or if you want to activate a custom-made server backend. It’s a comma separated list.


Next: , Previous: , Up: Reference   [Contents][Index]

4.10 Map parameters

4.10.1 chosen-map

Command-line option: --chosen-map=<value>
Environment variable: LW6_CHOSEN_MAP
XML key: chosen-map

Type: string

Default value: subflower

The last map chosen by the player, locally. This is the map which will be used for a quick-start game, a local game, or a game started as a server.

4.10.2 force

Command-line option: --force=<value>
Environment variable: LW6_FORCE
XML key: force

Type: string

Default value: respawn-team,color-conflict-mode

A comma separated list of options which should be ignored when reading map XML files. For instance, if this contains ’rounds-per-sec,moves-per-round’ then whatever values were defined for this in ’rules.xml’, then game will ignore them and use the user’s values, stored in ’config.xml’, running the game at the requested speed. This ultimately allows the player to control everything despite the values set by the map designer.

4.10.3 use-cursor-texture

Command-line option: --use-cursor-texture=<value>
Environment variable: LW6_USE_CURSOR_TEXTURE
XML key: use-cursor-texture

Type: boolean

Default value: true

Defines wether the cursor textures should be used. If unset, then the default builtin cursor texture will be used instead of the map specific one.

4.10.4 use-hints-xml

Command-line option: --use-hints-xml=<value>
Environment variable: LW6_USE_HINTS_XML
XML key: use-hints-xml

Type: boolean

Default value: true

If set, then hints will be picked up from the map defined hints.xml, if it exists. This is the default.

4.10.5 use-music-file

Command-line option: --use-music-file=<value>
Environment variable: LW6_USE_MUSIC_FILE
XML key: use-music-file

Type: boolean

Default value: true

If set, then the program will use the ’music-file’ attribute to choose the music to play. If unset, then a random builtin music will be picked up, regardless of what is specified in ’music-file’.

4.10.6 use-rules-xml

Command-line option: --use-rules-xml=<value>
Environment variable: LW6_USE_RULES_XML
XML key: use-rules-xml

Type: boolean

Default value: true

If set, then rules will be picked up from the map defined rules.xml, if it exists. This is the default. Use force-time and force-size to override this and use user-defined values anyway.

4.10.7 use-style-xml

Command-line option: --use-style-xml=<value>
Environment variable: LW6_USE_STYLE_XML
XML key: use-style-xml

Type: boolean

Default value: true

If set, then style will be picked up from the map defined style.xml, if it exists. This is the default. Use force-time and force-background to override this and use user-defined values anyway.

4.10.8 use-teams-xml

Command-line option: --use-teams-xml=<value>
Environment variable: LW6_USE_TEAMS_XML
XML key: use-teams-xml

Type: boolean

Default value: true

If set, then teams will be picked up from the map defined teams.xml, if it exists. This is the default. Use force-time and force-background to override this and use user-defined values anyway.

4.10.9 use-texture

Command-line option: --use-texture=<value>
Environment variable: LW6_USE_TEXTURE
XML key: use-texture

Type: boolean

Default value: true

Defines wether the map texture should be used. Of course if there’s no map texture, the texture... won’t be used. But if there is one, this parameter will force the game to ignore it and play with solid colors. This probably won’t look as nice as the textured map in most cases, but some players might find it more readable and confortable to play when throwing eye candy away.


Next: , Previous: , Up: Reference   [Contents][Index]

4.11 Map rules.xml

4.11.1 boost-power

Command-line option: --boost-power=<value>
Environment variable: LW6_BOOST_POWER
XML key: boost-power

Type: integer

Default value: 3 Min value: 1 Max value: 10

Defines how fast and powerfull the boost is. That is, if on ’boost.png’ it’s pitch black and this parameter is set to 3, then fighters will move and act 3 times than what they would do normally.

4.11.2 color-conflict-mode

Command-line option: --color-conflict-mode=<value>
Environment variable: LW6_COLOR_CONFLICT_MODE
XML key: color-conflict-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

How to handle color conflicts, that is, when a player requests a color, but this color is already used, what should be done? If 0, wether a color already exists won’t affect the color of a new cursor. If 1, then two players on the same computer will be allowed to share the same color/team, but if another computer is already playing with a color, any new computer will need to use another team. If 2, then it’s impossible for a new cursor to use a pre-existing color, any new cursor will require a new color, if that color is already used, a new color will be picked randomly.

4.11.3 cursor-pot-init

Command-line option: --cursor-pot-init=<value>
Environment variable: LW6_CURSOR_POT_INIT
XML key: cursor-pot-init

Type: integer

Default value: 100000 Min value: 5000 Max value: 500000

Defines the cursor potential at startup. Not really any reason to change it. Theorically, there could be maps where the default value doesn’t fit, but none has been seen yet.

4.11.4 danger-power

Command-line option: --danger-power=<value>
Environment variable: LW6_DANGER_POWER
XML key: danger-power

Type: integer

Default value: 200 Min value: 0 Max value: 10000

Defines how dangerous are the black zones defined in ’danger.png’. The value is used to decrease the fighter health at each move, so you should compare its value to something like ’fighter-attack’. Being on a dangerous zone is a bit like being attacked by an invisible and unknown ennemy.

4.11.5 exp

Command-line option: --exp=<value>
Environment variable: LW6_EXP
XML key: exp

Type: integer

Default value: 1 Min value: 0 Max value: 99

Level of experience (AKA exp) required to play the current level. If this level is validated (that is, won) then player will be granted with a level of exp+1 and be able to play all the next levels. An exp of 0 means the level is playable by a pure beginner.

4.11.6 fighter-attack

Command-line option: --fighter-attack=<value>
Environment variable: LW6_FIGHTER_ATTACK
XML key: fighter-attack

Type: integer

Default value: 500 Min value: 1 Max value: 10000

Defines how hard fighters will attack others, that is, in one attack, how many life-points the attacked fighter will loose. Increasing this will cause your opponents to melt faster when you attack them. With a low value, it will take ages to take on your opponents. Different styles of game. Can radically change the gameplay.

4.11.7 fighter-defense

Command-line option: --fighter-defense=<value>
Environment variable: LW6_FIGHTER_DEFENSE
XML key: fighter-defense

Type: integer

Default value: 50 Min value: 0 Max value: 10000

Defines how fast fighters will regenerate after an attack. When this parameter is set low, an attacked fighter, which is very dark and almost dead will take a very long time to regain energy. If the parameter is set high, it can almost instantaneously regain energy.

4.11.8 fighter-new-health

Command-line option: --fighter-new-health=<value>
Environment variable: LW6_FIGHTER_NEW_HEALTH
XML key: fighter-new-health

Type: integer

Default value: 5000 Min value: 1 Max value: 10000

Defines how healthy fighters will be when they appear on the map. This can be either at the beginning of the game of when a fighter changes team. Setting this low will allow battefields to switch from one side to another very fast, for freshly gained fighters will be feeble and very likely to return to their original camp. To calibrate this parameter, keep in mind that the absolute maximum health a fighter can have is always 10000 (ten-thousands).

4.11.9 fighter-regenerate

Command-line option: --fighter-regenerate=<value>
Environment variable: LW6_FIGHTER_REGENERATE
XML key: fighter-regenerate

Type: integer

Default value: 5 Min value: 0 Max value: 10000

Defines at which speed fighters will self-regenerate, without even begin packed together. This will allow lone fighters to regenerate a bit by hiding somewhere in the map. This is typically a low value, might even be 0.

4.11.10 frags-fade-out

Command-line option: --frags-fade-out=<value>
Environment variable: LW6_FRAGS_FADE_OUT
XML key: frags-fade-out

Type: integer

Default value: 100 Min value: 10 Max value: 100

When a player looses (in deathmatch mode) all player points will be multiplicated by this percentage, for instance if it’s 90 and player had 50 points, then player will only have 45 points, then points corresponding to the new death will be added/substrated to its total. This is to avoid players with thousands of points in advance, and keep everyone in the race. A low value will minimize the importance of game start. This is only used in modes where frags are distributed in a proportional way.

4.11.11 frags-mode

Command-line option: --frags-mode=<value>
Environment variable: LW6_FRAGS_MODE
XML key: frags-mode

Type: integer

Default value: 2 Min value: 0 Max value: 3

Defines how points are calculated in deathmatch mode, 0 is old school simple mode. 1 is in a mode in which 1 point is attributed to every winner, and looser looses all the corresponding points (total is always 0). 2 isproportional mode, with a total of 0 kept constant, that is, loosers loose as many points as attributed to winners. 3 is a mode in which at each death, winners are attributed a number of points proportional to their fighters, and loosers scores remain untouched.

4.11.12 frags-to-distribute

Command-line option: --frags-to-distribute=<value>
Environment variable: LW6_FRAGS_TO_DISTRIBUTE
XML key: frags-to-distribute

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines how many points will be distributed when in deathmatch mode. When a player looses, this amont of points will be substracted to its total, and the same amount of points will be distributed to other live players, proportionnally to how many fighters they have on the battlefield.

4.11.13 glue-power

Command-line option: --glue-power=<value>
Environment variable: LW6_GLUE_POWER
XML key: glue-power

Type: integer

Default value: 20 Min value: 1 Max value: 100

Defines how sticky and powerfull the glue is. That is, if on ’glue.png’ it’s pitch black and this parameter is set to 3, then fighters will take 3 steps to do what would normally take only one step.

4.11.14 highest-team-color-allowed

Command-line option: --highest-team-color-allowed=<value>
Environment variable: LW6_HIGHEST_TEAM_COLOR_ALLOWED
XML key: highest-team-color-allowed

Type: integer

Default value: 9 Min value: 3 Max value: 9

Id of the greatest/highest color one can use. Normally, you can leave this untouched, the program will automatically fit this according to your exp. Setting an artificially low value will just cause normally available colors to disappear, setting it to a high value does nothing, if you still don’t have access to some colors, you still don’t, period.

4.11.15 highest-weapon-allowed

Command-line option: --highest-weapon-allowed=<value>
Environment variable: LW6_HIGHEST_WEAPON_ALLOWED
XML key: highest-weapon-allowed

Type: integer

Default value: 19 Min value: 7 Max value: 19

Id of the greatest/highest weapon one can use. Normally, you can leave this untouched, the program will automatically fit this according to your exp. Setting an artificially low value will just cause normally available weapons to disappear, setting it to a high value does nothing, if you still don’t have access to some weapons, you still don’t, period.

4.11.16 max-cursor-pot

Command-line option: --max-cursor-pot=<value>
Environment variable: LW6_MAX_CURSOR_POT
XML key: max-cursor-pot

Type: integer

Default value: 1000000 Min value: 50000 Max value: 5000000

Defines the maximum cursor potential. Not really any reason to change it. Any high value should produce the same results. Low values might reveal algorithm bugs and inconsistencies.

4.11.17 max-cursor-pot-offset

Command-line option: --max-cursor-pot-offset=<value>
Environment variable: LW6_MAX_CURSOR_POT_OFFSET
XML key: max-cursor-pot-offset

Type: integer

Default value: 100 Min value: 1 Max value: 10000

Defines the maximum cursor potential offset. The idea is that in some cases, the potential of a cursor can increase in burst mode, for instance to make this cursor more important than others, so that fighters rally to it, neglecting other cursors (talking about a multi-cursor controlled team). This parameter is here to limit this burst effect and avoid bugs.

4.11.18 max-nb-cursors

Command-line option: --max-nb-cursors=<value>
Environment variable: LW6_MAX_NB_CURSORS
XML key: max-nb-cursors

Type: integer

Default value: 26 Min value: 2 Max value: 26

Defines the maximum number of cursors who can enter the game. Really makes sense in network games. Default value is 26, the maximum.

4.11.19 max-nb-nodes

Command-line option: --max-nb-nodes=<value>
Environment variable: LW6_MAX_NB_NODES
XML key: max-nb-nodes

Type: integer

Default value: 12 Min value: 2 Max value: 15

Defines the maximum number of servers who can enter the game. Really makes sense in network games. Default value is 10, and should fit in most cases. Can be raised up to 26.

4.11.20 max-nb-teams

Command-line option: --max-nb-teams=<value>
Environment variable: LW6_MAX_NB_TEAMS
XML key: max-nb-teams

Type: integer

Default value: 10 Min value: 2 Max value: 10

Defines the maximum number of teams who can enter the game. Really makes sense in network games. Default value is 10, the maximum.

4.11.21 max-round-delta

Command-line option: --max-round-delta=<value>
Environment variable: LW6_MAX_ROUND_DELTA
XML key: max-round-delta

Type: integer

Default value: 1000 Min value: 1 Max value: 10000

This is the companion value of ’round-delta’. Will put an absolute limit to the delta, which (what did you think?) is of course incremented in some cases by the core algorithm. If in doubt, don’t touch.

4.11.22 max-zone-size

Command-line option: --max-zone-size=<value>
Environment variable: LW6_MAX_ZONE_SIZE
XML key: max-zone-size

Type: integer

Default value: 8 Min value: 1 Max value: 64

Defines the maximum zone size, which is an internal and rather technical parameter. The idea is that to optimize things, Liquid War 6 divides the battlefield in squares, where it can, and tries to make these squares as big as possible, the idea being that everywhere in this square, fighters follow the same intructions. Just a technical optimization. The problem is that setting it too high will reveal the optimization and its tradeoffs to the player, who will see the fighter behave strangely, following invisible paths. Plus, it’s ugly. Depending on your tastes (speed, look’n’feel) you’ll prefer something nice or something fast. Note that anyways passed a certain value, this does not optimize anything anymore. In doubt, don’t touch it.

4.11.23 medicine-power

Command-line option: --medicine-power=<value>
Environment variable: LW6_MEDICINE_POWER
XML key: medicine-power

Type: integer

Default value: 100 Min value: 0 Max value: 10000

Defines how fast fighter will automatically regenerate on black zones defined in ’medicine.png’. The value is used to decrease the fighter health at each move, so you should compare its value to something like ’fighter-defense’. Being on a medicined zone is a bit like being defended by an invisible and unknown friend.

4.11.24 moves-per-round

Command-line option: --moves-per-round=<value>
Environment variable: LW6_MOVES_PER_ROUND
XML key: moves-per-round

Type: integer

Default value: 2 Min value: 1 Max value: 50

Defines how many times fighters move per round. Increasing this will just make fighters move faster, but won’t change anything for the rest, that is keyboard and mouse responsivity, and network traffic will stay the same. Multiplying the number of moves per round by the number of rounds per second will give the number of moves per second, which is, in fact, how fast fighters move on the screen.

4.11.25 nb-attack-tries

Command-line option: --nb-attack-tries=<value>
Environment variable: LW6_NB_ATTACK_TRIES
XML key: nb-attack-tries

Type: integer

Default value: 3 Min value: 1 Max value: 7

Defines how many tries a fighter will do before giving-up attacking and choosing another behvior (defense). By tries we mean: how many directions it will try. Going North? Going North-West? Setting this to a low value will make fighters somewhat less aggressive. This idea is that they’ll prefer to switch to the next option, that is, defense/regeneration, if there’s no opponent right in front of them.

4.11.26 nb-defense-tries

Command-line option: --nb-defense-tries=<value>
Environment variable: LW6_NB_DEFENSE_TRIES
XML key: nb-defense-tries

Type: integer

Default value: 1 Min value: 1 Max value: 7

Defines how many tries a fighter will do before giving-up attacking and choosing another behavior (do nothing). By tries we mean: how many directions it will try. Going North? Going North-West? Setting this to a low value, you’ll need a very compact pack of fighters for regeneration to operate, else fighters will hang arround unhealthy.

4.11.27 nb-move-tries

Command-line option: --nb-move-tries=<value>
Environment variable: LW6_NB_MOVE_TRIES
XML key: nb-move-tries

Type: integer

Default value: 5 Min value: 3 Max value: 7

Defines how many tries a fighter will do before giving-up moving and choosing another behvior (attack or defense). By tries we mean: how many directions it will try. Going North? Going North-West? Setting this to a low value, your fighters will look very stubborn and always try to move in one direction, neglecting the fact that they could dodge. This can lead to queues of fighters and other strange behaviors. On the other hand, setting it too high will cause fighter to always avoid the enemy, and groups of fighters will just pass each other without any fight. Matter of taste.

4.11.28 respawn-delay

Command-line option: --respawn-delay=<value>
Environment variable: LW6_RESPAWN_DELAY
XML key: respawn-delay

Type: integer

Default value: 3 Min value: 0 Max value: 30

Delay, in seconds, after which teams reappear on the battlefield, when in deathmatch mode. 0 means team right away.

4.11.29 respawn-position-mode

Command-line option: --respawn-position-mode=<value>
Environment variable: LW6_RESPAWN_POSITION_MODE
XML key: respawn-position-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Defines how teams are set up on the map when respawning. 0 means teams respect the pre-defined start positions. 1 means that a random position will be picked, among the existing positions. That is, red could take green’s place. 2 means total randomness, teams can appear anywhere.

4.11.30 respawn-team

Command-line option: --respawn-team=<value>
Environment variable: LW6_RESPAWN_TEAM
XML key: respawn-team

Type: integer

Default value: 1 Min value: 0 Max value: 1

Defines what to do when a team dies. If set to 0, team disappears forever, if set to 1, team reappears automatically with fresh fighters. It’s a deathmatch mode, where the winner is not the one who stays alive the longest time, since it makes no real sens in this case, but the one who has died less often than others.

4.11.31 round-delta

Command-line option: --round-delta=<value>
Environment variable: LW6_ROUND_DELTA
XML key: round-delta

Type: integer

Default value: 1 Min value: 0 Max value: 100

Conditions by how much the cursor potential will be incremented each time gradient is spreaded. Sounds cryptic? It is. The idea is that at each time you move your cursor of 1 pixel, theorically, you’ll need in the worst case to move of 1 more pixel to reach any point on the map. Of course this is not true but this is the default asumption, and gradient spread will fix that. Only in Liquid War 6 this is not even the worst case, for you can control your cursor with the mouse and cross walls. Whenever you cross a wall, you might have done a great distance from the fighters’ point of view, if the map is a maze. Thus this parameter, which corrects things, experience shows it does give acceptable results to increase the cursor potential by more than one at each turn. Toy arround with this if you find fighters take wrong paths on some given map. If in doubt, don’t touch.

4.11.32 rounds-per-sec

Command-line option: --rounds-per-sec=<value>
Environment variable: LW6_ROUNDS_PER_SEC
XML key: rounds-per-sec

Type: integer

Default value: 50 Min value: 1 Max value: 200

Defines the overall speed of the game. All other settings being equal, raising this value will cause the game to behave faster. Everything will be faster, except probably the display since your computer will calculate more game positions in a given time and spend more CPU time. It will also increase network traffic. Values between 10 and 50 really make sense.

4.11.33 side-attack-factor

Command-line option: --side-attack-factor=<value>
Environment variable: LW6_SIDE_ATTACK_FACTOR
XML key: side-attack-factor

Type: integer

Default value: 20 Min value: 0 Max value: 100

Defines how hard fighters will attack sideways. It’s an algorithm trick, fighters attack by default the opponent right in front, but if there’s no fighter there, they will still try to attack someone else, maybe sideways. But doing this their attack is not as strong. This parameter enables you to tune this. This is a percentage.

4.11.34 side-defense-factor

Command-line option: --side-defense-factor=<value>
Environment variable: LW6_SIDE_DEFENSE_FACTOR
XML key: side-defense-factor

Type: integer

Default value: 20 Min value: 0 Max value: 100

Defines how fast fighters will regenerate, when being side by side instead of being right in front of the other. This is a percentage.

4.11.35 single-army-size

Command-line option: --single-army-size=<value>
Environment variable: LW6_SINGLE_ARMY_SIZE
XML key: single-army-size

Type: integer

Default value: 30 Min value: 1 Max value: 95

Defines the proportion of the whole available space, which will be occupied by an army at the beginning of the game. You can either imagine playing with almost empty maps, or play very crowded with almost no space left. This is a percentage, but will be multiplied by itself to get the actual surface. That is, 50 means 50%*50%, that is, a square of 1/2 the size of a square map, so it represents 25% (1/4) of the total surface.

4.11.36 spread-mode

Command-line option: --spread-mode=<value>
Environment variable: LW6_SPREAD_MODE
XML key: spread-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

If set to 1, then gradient spread will be slower but gain in terms of homogeneity and consistency. You could consider setting this to 0 on very very big maps to save CPU cycles, else the default should work fine.

4.11.37 spread-thread

Command-line option: --spread-thread=<value>
Environment variable: LW6_SPREAD_THREAD
XML key: spread-thread

Type: integer

Default value: 0 Min value: 0 Max value: 1

If set to 1, the core algorithm with fire a separate thread to spread the gradient. By default this is turned off (set to 0). Consider this as an experimental feature, the program is already rather heavily threaded, turning this on will probably not offer any significant performance gain, even on SMP systems. This might change in the future.

4.11.38 spreads-per-round

Command-line option: --spreads-per-round=<value>
Environment variable: LW6_SPREADS_PER_ROUND
XML key: spreads-per-round

Type: integer

Default value: 5 Min value: 1 Max value: 100

Defines how many times the gradient is spread per round. Gradient spread is a very Liquid War 6 specific feature, just remember that the more often you do it, the more accurately fighters will move. That is, you will be sure they really take the shortest path. Usually this does not have much effect, the default value should fit in most cases, but you might want to decrease it on very simple maps where the gradient is obvious, or increase it on complex maps where you want fighters to be real smart.

4.11.39 start-blue-x

Command-line option: --start-blue-x=<value>
Environment variable: LW6_START_BLUE_X
XML key: start-blue-x

Type: integer

Default value: 90 Min value: 0 Max value: 100

X start position for the blue team. This is a percentage of map width, value between 0 and 100.

4.11.40 start-blue-y

Command-line option: --start-blue-y=<value>
Environment variable: LW6_START_BLUE_Y
XML key: start-blue-y

Type: integer

Default value: 10 Min value: 0 Max value: 100

Y start position for the blue team. This is a percentage of map height, value between 0 and 100.

4.11.41 start-cyan-x

Command-line option: --start-cyan-x=<value>
Environment variable: LW6_START_CYAN_X
XML key: start-cyan-x

Type: integer

Default value: 35 Min value: 0 Max value: 100

X start position for the cyan team. This is a percentage of map width, value between 0 and 100.

4.11.42 start-cyan-y

Command-line option: --start-cyan-y=<value>
Environment variable: LW6_START_CYAN_Y
XML key: start-cyan-y

Type: integer

Default value: 10 Min value: 0 Max value: 100

Y start position for the cyan team. This is a percentage of map height, value between 0 and 100.

4.11.43 start-green-x

Command-line option: --start-green-x=<value>
Environment variable: LW6_START_GREEN_X
XML key: start-green-x

Type: integer

Default value: 90 Min value: 0 Max value: 100

X start position for the green team. This is a percentage of map width, value between 0 and 100.

4.11.44 start-green-y

Command-line option: --start-green-y=<value>
Environment variable: LW6_START_GREEN_Y
XML key: start-green-y

Type: integer

Default value: 90 Min value: 0 Max value: 100

Y start position for the green team. This is a percentage of map height, value between 0 and 100.

4.11.45 start-lightblue-x

Command-line option: --start-lightblue-x=<value>
Environment variable: LW6_START_LIGHTBLUE_X
XML key: start-lightblue-x

Type: integer

Default value: 35 Min value: 0 Max value: 100

X start position for the lightblue team. This is a percentage of map width, value between 0 and 100.

4.11.46 start-lightblue-y

Command-line option: --start-lightblue-y=<value>
Environment variable: LW6_START_LIGHTBLUE_Y
XML key: start-lightblue-y

Type: integer

Default value: 90 Min value: 0 Max value: 100

Y start position for the lightblue team. This is a percentage of map height, value between 0 and 100.

4.11.47 start-magenta-x

Command-line option: --start-magenta-x=<value>
Environment variable: LW6_START_MAGENTA_X
XML key: start-magenta-x

Type: integer

Default value: 65 Min value: 0 Max value: 100

X start position for the magenta team. This is a percentage of map width, value between 0 and 100.

4.11.48 start-magenta-y

Command-line option: --start-magenta-y=<value>
Environment variable: LW6_START_MAGENTA_Y
XML key: start-magenta-y

Type: integer

Default value: 90 Min value: 0 Max value: 100

Y start position for the magenta team. This is a percentage of map height, value between 0 and 100.

4.11.49 start-orange-x

Command-line option: --start-orange-x=<value>
Environment variable: LW6_START_ORANGE_X
XML key: start-orange-x

Type: integer

Default value: 65 Min value: 0 Max value: 100

X start position for the orange team. This is a percentage of map width, value between 0 and 100.

4.11.50 start-orange-y

Command-line option: --start-orange-y=<value>
Environment variable: LW6_START_ORANGE_Y
XML key: start-orange-y

Type: integer

Default value: 10 Min value: 0 Max value: 100

Y start position for the orange team. This is a percentage of map height, value between 0 and 100.

4.11.51 start-pink-x

Command-line option: --start-pink-x=<value>
Environment variable: LW6_START_PINK_X
XML key: start-pink-x

Type: integer

Default value: 10 Min value: 0 Max value: 100

X start position for the pink team. This is a percentage of map width, value between 0 and 100.

4.11.52 start-pink-y

Command-line option: --start-pink-y=<value>
Environment variable: LW6_START_PINK_Y
XML key: start-pink-y

Type: integer

Default value: 50 Min value: 0 Max value: 100

Y start position for the pink team. This is a percentage of map height, value between 0 and 100.

4.11.53 start-position-mode

Command-line option: --start-position-mode=<value>
Environment variable: LW6_START_POSITION_MODE
XML key: start-position-mode

Type: integer

Default value: 0 Min value: 0 Max value: 2

Defines how teams are set up on the map at game startup. 0 means teams respect the pre-defined start positions. 1 means that a random position will be picked, among the existing positions. That is, red could take green’s place. 2 means total randomness, teams can appear anywhere.

4.11.54 start-purple-x

Command-line option: --start-purple-x=<value>
Environment variable: LW6_START_PURPLE_X
XML key: start-purple-x

Type: integer

Default value: 90 Min value: 0 Max value: 100

X start position for the purple team. This is a percentage of map width, value between 0 and 100.

4.11.55 start-purple-y

Command-line option: --start-purple-y=<value>
Environment variable: LW6_START_PURPLE_Y
XML key: start-purple-y

Type: integer

Default value: 50 Min value: 0 Max value: 100

Y start position for the purple team. This is a percentage of map height, value between 0 and 100.

4.11.56 start-red-x

Command-line option: --start-red-x=<value>
Environment variable: LW6_START_RED_X
XML key: start-red-x

Type: integer

Default value: 10 Min value: 0 Max value: 100

X start position for the red team. This is a percentage of map width, value between 0 and 100.

4.11.57 start-red-y

Command-line option: --start-red-y=<value>
Environment variable: LW6_START_RED_Y
XML key: start-red-y

Type: integer

Default value: 10 Min value: 0 Max value: 100

Y start position for the red team. This is a percentage of map height, value between 0 and 100.

4.11.58 start-yellow-x

Command-line option: --start-yellow-x=<value>
Environment variable: LW6_START_YELLOW_X
XML key: start-yellow-x

Type: integer

Default value: 10 Min value: 0 Max value: 100

X start position for the yellow team. This is a percentage of map width, value between 0 and 100.

4.11.59 start-yellow-y

Command-line option: --start-yellow-y=<value>
Environment variable: LW6_START_YELLOW_Y
XML key: start-yellow-y

Type: integer

Default value: 90 Min value: 0 Max value: 100

Y start position for the yellow team. This is a percentage of map height, value between 0 and 100.

4.11.60 team-profile-blue-aggressive

Command-line option: --team-profile-blue-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_AGGRESSIVE
XML key: team-profile-blue-aggressive

Type: integer

Default value: 150 Min value: 5 Max value: 2000

Defines how aggressive the blue team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.61 team-profile-blue-fast

Command-line option: --team-profile-blue-fast=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_FAST
XML key: team-profile-blue-fast

Type: integer

Default value: 50 Min value: 5 Max value: 2000

Changes the speed of the blue team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.62 team-profile-blue-handicap

Command-line option: --team-profile-blue-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_HANDICAP
XML key: team-profile-blue-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the blue team.

4.11.63 team-profile-blue-mobile

Command-line option: --team-profile-blue-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_MOBILE
XML key: team-profile-blue-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the blue team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.64 team-profile-blue-vulnerable

Command-line option: --team-profile-blue-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_VULNERABLE
XML key: team-profile-blue-vulnerable

Type: integer

Default value: 60 Min value: 5 Max value: 2000

Defines how vulnerable the blue team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.65 team-profile-blue-weapon-alternate-id

Command-line option: --team-profile-blue-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_WEAPON_ALTERNATE_ID
XML key: team-profile-blue-weapon-alternate-id

Type: integer

Default value: 8 Min value: 0 Max value: 19

Id of the default alternate weapon for the blue team, see the documentation about weapons to know what these ids mean.

4.11.66 team-profile-blue-weapon-id

Command-line option: --team-profile-blue-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_WEAPON_ID
XML key: team-profile-blue-weapon-id

Type: integer

Default value: 14 Min value: 0 Max value: 19

Id of the default weapon for the blue team, see the documentation about weapons to know what these ids mean.

4.11.67 team-profile-blue-weapon-mode

Command-line option: --team-profile-blue-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_BLUE_WEAPON_MODE
XML key: team-profile-blue-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for blue team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.68 team-profile-cyan-aggressive

Command-line option: --team-profile-cyan-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_AGGRESSIVE
XML key: team-profile-cyan-aggressive

Type: integer

Default value: 44 Min value: 5 Max value: 2000

Defines how aggressive the cyan team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.69 team-profile-cyan-fast

Command-line option: --team-profile-cyan-fast=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_FAST
XML key: team-profile-cyan-fast

Type: integer

Default value: 40 Min value: 5 Max value: 2000

Changes the speed of the cyan team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.70 team-profile-cyan-handicap

Command-line option: --team-profile-cyan-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_HANDICAP
XML key: team-profile-cyan-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the cyan team.

4.11.71 team-profile-cyan-mobile

Command-line option: --team-profile-cyan-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_MOBILE
XML key: team-profile-cyan-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the cyan team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.72 team-profile-cyan-vulnerable

Command-line option: --team-profile-cyan-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_VULNERABLE
XML key: team-profile-cyan-vulnerable

Type: integer

Default value: 12 Min value: 5 Max value: 2000

Defines how vulnerable the cyan team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.73 team-profile-cyan-weapon-alternate-id

Command-line option: --team-profile-cyan-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_WEAPON_ALTERNATE_ID
XML key: team-profile-cyan-weapon-alternate-id

Type: integer

Default value: 12 Min value: 0 Max value: 19

Id of the default alternate weapon for the cyan team, see the documentation about weapons to know what these ids mean.

4.11.74 team-profile-cyan-weapon-id

Command-line option: --team-profile-cyan-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_WEAPON_ID
XML key: team-profile-cyan-weapon-id

Type: integer

Default value: 3 Min value: 0 Max value: 19

Id of the default weapon for the cyan team, see the documentation about weapons to know what these ids mean.

4.11.75 team-profile-cyan-weapon-mode

Command-line option: --team-profile-cyan-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_CYAN_WEAPON_MODE
XML key: team-profile-cyan-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for cyan team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.76 team-profile-green-aggressive

Command-line option: --team-profile-green-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_AGGRESSIVE
XML key: team-profile-green-aggressive

Type: integer

Default value: 70 Min value: 5 Max value: 2000

Defines how aggressive the green team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.77 team-profile-green-fast

Command-line option: --team-profile-green-fast=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_FAST
XML key: team-profile-green-fast

Type: integer

Default value: 70 Min value: 5 Max value: 2000

Changes the speed of the green team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.78 team-profile-green-handicap

Command-line option: --team-profile-green-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_HANDICAP
XML key: team-profile-green-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the green team.

4.11.79 team-profile-green-mobile

Command-line option: --team-profile-green-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_MOBILE
XML key: team-profile-green-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the green team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.80 team-profile-green-vulnerable

Command-line option: --team-profile-green-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_VULNERABLE
XML key: team-profile-green-vulnerable

Type: integer

Default value: 30 Min value: 5 Max value: 2000

Defines how vulnerable the green team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.81 team-profile-green-weapon-alternate-id

Command-line option: --team-profile-green-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_WEAPON_ALTERNATE_ID
XML key: team-profile-green-weapon-alternate-id

Type: integer

Default value: 7 Min value: 0 Max value: 19

Id of the default alternate weapon for the green team, see the documentation about weapons to know what these ids mean.

4.11.82 team-profile-green-weapon-id

Command-line option: --team-profile-green-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_WEAPON_ID
XML key: team-profile-green-weapon-id

Type: integer

Default value: 13 Min value: 0 Max value: 19

Id of the default weapon for the green team, see the documentation about weapons to know what these ids mean.

4.11.83 team-profile-green-weapon-mode

Command-line option: --team-profile-green-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_GREEN_WEAPON_MODE
XML key: team-profile-green-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for green team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.84 team-profile-lightblue-aggressive

Command-line option: --team-profile-lightblue-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_AGGRESSIVE
XML key: team-profile-lightblue-aggressive

Type: integer

Default value: 200 Min value: 5 Max value: 2000

Defines how aggressive the lightblue team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.85 team-profile-lightblue-fast

Command-line option: --team-profile-lightblue-fast=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_FAST
XML key: team-profile-lightblue-fast

Type: integer

Default value: 20 Min value: 5 Max value: 2000

Changes the speed of the lightblue team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.86 team-profile-lightblue-handicap

Command-line option: --team-profile-lightblue-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_HANDICAP
XML key: team-profile-lightblue-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the lightblue team.

4.11.87 team-profile-lightblue-mobile

Command-line option: --team-profile-lightblue-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_MOBILE
XML key: team-profile-lightblue-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the lightblue team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.88 team-profile-lightblue-vulnerable

Command-line option: --team-profile-lightblue-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_VULNERABLE
XML key: team-profile-lightblue-vulnerable

Type: integer

Default value: 8 Min value: 5 Max value: 2000

Defines how vulnerable the lightblue team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.89 team-profile-lightblue-weapon-alternate-id

Command-line option: --team-profile-lightblue-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_WEAPON_ALTERNATE_ID
XML key: team-profile-lightblue-weapon-alternate-id

Type: integer

Default value: 17 Min value: 0 Max value: 19

Id of the default alternate weapon for the lightblue team, see the documentation about weapons to know what these ids mean.

4.11.90 team-profile-lightblue-weapon-id

Command-line option: --team-profile-lightblue-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_WEAPON_ID
XML key: team-profile-lightblue-weapon-id

Type: integer

Default value: 4 Min value: 0 Max value: 19

Id of the default weapon for the lightblue team, see the documentation about weapons to know what these ids mean.

4.11.91 team-profile-lightblue-weapon-mode

Command-line option: --team-profile-lightblue-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_LIGHTBLUE_WEAPON_MODE
XML key: team-profile-lightblue-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for lightblue team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.92 team-profile-magenta-aggressive

Command-line option: --team-profile-magenta-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_AGGRESSIVE
XML key: team-profile-magenta-aggressive

Type: integer

Default value: 192 Min value: 5 Max value: 2000

Defines how aggressive the magenta team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.93 team-profile-magenta-fast

Command-line option: --team-profile-magenta-fast=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_FAST
XML key: team-profile-magenta-fast

Type: integer

Default value: 320 Min value: 5 Max value: 2000

Changes the speed of the magenta team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.94 team-profile-magenta-handicap

Command-line option: --team-profile-magenta-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_HANDICAP
XML key: team-profile-magenta-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the magenta team.

4.11.95 team-profile-magenta-mobile

Command-line option: --team-profile-magenta-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_MOBILE
XML key: team-profile-magenta-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the magenta team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.96 team-profile-magenta-vulnerable

Command-line option: --team-profile-magenta-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_VULNERABLE
XML key: team-profile-magenta-vulnerable

Type: integer

Default value: 1920 Min value: 5 Max value: 2000

Defines how vulnerable the magenta team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.97 team-profile-magenta-weapon-alternate-id

Command-line option: --team-profile-magenta-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_WEAPON_ALTERNATE_ID
XML key: team-profile-magenta-weapon-alternate-id

Type: integer

Default value: 15 Min value: 0 Max value: 19

Id of the default alternate weapon for the magenta team, see the documentation about weapons to know what these ids mean.

4.11.98 team-profile-magenta-weapon-id

Command-line option: --team-profile-magenta-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_WEAPON_ID
XML key: team-profile-magenta-weapon-id

Type: integer

Default value: 6 Min value: 0 Max value: 19

Id of the default weapon for the magenta team, see the documentation about weapons to know what these ids mean.

4.11.99 team-profile-magenta-weapon-mode

Command-line option: --team-profile-magenta-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_MAGENTA_WEAPON_MODE
XML key: team-profile-magenta-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for magenta team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.100 team-profile-orange-aggressive

Command-line option: --team-profile-orange-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_AGGRESSIVE
XML key: team-profile-orange-aggressive

Type: integer

Default value: 48 Min value: 5 Max value: 2000

Defines how aggressive the orange team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.101 team-profile-orange-fast

Command-line option: --team-profile-orange-fast=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_FAST
XML key: team-profile-orange-fast

Type: integer

Default value: 160 Min value: 5 Max value: 2000

Changes the speed of the orange team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.102 team-profile-orange-handicap

Command-line option: --team-profile-orange-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_HANDICAP
XML key: team-profile-orange-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the orange team.

4.11.103 team-profile-orange-mobile

Command-line option: --team-profile-orange-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_MOBILE
XML key: team-profile-orange-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the orange team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.104 team-profile-orange-vulnerable

Command-line option: --team-profile-orange-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_VULNERABLE
XML key: team-profile-orange-vulnerable

Type: integer

Default value: 144 Min value: 5 Max value: 2000

Defines how vulnerable the orange team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.105 team-profile-orange-weapon-alternate-id

Command-line option: --team-profile-orange-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_WEAPON_ALTERNATE_ID
XML key: team-profile-orange-weapon-alternate-id

Type: integer

Default value: 16 Min value: 0 Max value: 19

Id of the default alternate weapon for the orange team, see the documentation about weapons to know what these ids mean.

4.11.106 team-profile-orange-weapon-id

Command-line option: --team-profile-orange-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_WEAPON_ID
XML key: team-profile-orange-weapon-id

Type: integer

Default value: 0 Min value: 0 Max value: 19

Id of the default weapon for the orange team, see the documentation about weapons to know what these ids mean.

4.11.107 team-profile-orange-weapon-mode

Command-line option: --team-profile-orange-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_ORANGE_WEAPON_MODE
XML key: team-profile-orange-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for orange team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.108 team-profile-pink-aggressive

Command-line option: --team-profile-pink-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_AGGRESSIVE
XML key: team-profile-pink-aggressive

Type: integer

Default value: 640 Min value: 5 Max value: 2000

Defines how aggressive the pink team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.109 team-profile-pink-fast

Command-line option: --team-profile-pink-fast=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_FAST
XML key: team-profile-pink-fast

Type: integer

Default value: 80 Min value: 5 Max value: 2000

Changes the speed of the pink team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.110 team-profile-pink-handicap

Command-line option: --team-profile-pink-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_HANDICAP
XML key: team-profile-pink-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the pink team.

4.11.111 team-profile-pink-mobile

Command-line option: --team-profile-pink-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_MOBILE
XML key: team-profile-pink-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the pink team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.112 team-profile-pink-vulnerable

Command-line option: --team-profile-pink-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_VULNERABLE
XML key: team-profile-pink-vulnerable

Type: integer

Default value: 640 Min value: 5 Max value: 2000

Defines how vulnerable the pink team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.113 team-profile-pink-weapon-alternate-id

Command-line option: --team-profile-pink-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_WEAPON_ALTERNATE_ID
XML key: team-profile-pink-weapon-alternate-id

Type: integer

Default value: 19 Min value: 0 Max value: 19

Id of the default alternate weapon for the pink team, see the documentation about weapons to know what these ids mean.

4.11.114 team-profile-pink-weapon-id

Command-line option: --team-profile-pink-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_WEAPON_ID
XML key: team-profile-pink-weapon-id

Type: integer

Default value: 1 Min value: 0 Max value: 19

Id of the default weapon for the pink team, see the documentation about weapons to know what these ids mean.

4.11.115 team-profile-pink-weapon-mode

Command-line option: --team-profile-pink-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_PINK_WEAPON_MODE
XML key: team-profile-pink-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for pink team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.116 team-profile-purple-aggressive

Command-line option: --team-profile-purple-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_AGGRESSIVE
XML key: team-profile-purple-aggressive

Type: integer

Default value: 32 Min value: 5 Max value: 2000

Defines how aggressive the purple team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.117 team-profile-purple-fast

Command-line option: --team-profile-purple-fast=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_FAST
XML key: team-profile-purple-fast

Type: integer

Default value: 80 Min value: 5 Max value: 2000

Changes the speed of the purple team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.118 team-profile-purple-handicap

Command-line option: --team-profile-purple-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_HANDICAP
XML key: team-profile-purple-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the purple team.

4.11.119 team-profile-purple-mobile

Command-line option: --team-profile-purple-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_MOBILE
XML key: team-profile-purple-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the purple team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.120 team-profile-purple-vulnerable

Command-line option: --team-profile-purple-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_VULNERABLE
XML key: team-profile-purple-vulnerable

Type: integer

Default value: 16 Min value: 5 Max value: 2000

Defines how vulnerable the purple team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.121 team-profile-purple-weapon-alternate-id

Command-line option: --team-profile-purple-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_WEAPON_ALTERNATE_ID
XML key: team-profile-purple-weapon-alternate-id

Type: integer

Default value: 18 Min value: 0 Max value: 19

Id of the default alternate weapon for the purple team, see the documentation about weapons to know what these ids mean.

4.11.122 team-profile-purple-weapon-id

Command-line option: --team-profile-purple-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_WEAPON_ID
XML key: team-profile-purple-weapon-id

Type: integer

Default value: 11 Min value: 0 Max value: 19

Id of the default weapon for the purple team, see the documentation about weapons to know what these ids mean.

4.11.123 team-profile-purple-weapon-mode

Command-line option: --team-profile-purple-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_PURPLE_WEAPON_MODE
XML key: team-profile-purple-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for purple team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.124 team-profile-red-aggressive

Command-line option: --team-profile-red-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_RED_AGGRESSIVE
XML key: team-profile-red-aggressive

Type: integer

Default value: 220 Min value: 5 Max value: 2000

Defines how aggressive the red team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.125 team-profile-red-fast

Command-line option: --team-profile-red-fast=<value>
Environment variable: LW6_TEAM_PROFILE_RED_FAST
XML key: team-profile-red-fast

Type: integer

Default value: 160 Min value: 5 Max value: 2000

Changes the speed of the red team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.126 team-profile-red-handicap

Command-line option: --team-profile-red-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_RED_HANDICAP
XML key: team-profile-red-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the red team.

4.11.127 team-profile-red-mobile

Command-line option: --team-profile-red-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_RED_MOBILE
XML key: team-profile-red-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the red team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.128 team-profile-red-vulnerable

Command-line option: --team-profile-red-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_RED_VULNERABLE
XML key: team-profile-red-vulnerable

Type: integer

Default value: 110 Min value: 5 Max value: 2000

Defines how vulnerable the red team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.129 team-profile-red-weapon-alternate-id

Command-line option: --team-profile-red-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_RED_WEAPON_ALTERNATE_ID
XML key: team-profile-red-weapon-alternate-id

Type: integer

Default value: 2 Min value: 0 Max value: 19

Id of the default alternate weapon for the red team, see the documentation about weapons to know what these ids mean.

4.11.130 team-profile-red-weapon-id

Command-line option: --team-profile-red-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_RED_WEAPON_ID
XML key: team-profile-red-weapon-id

Type: integer

Default value: 10 Min value: 0 Max value: 19

Id of the default weapon for the red team, see the documentation about weapons to know what these ids mean.

4.11.131 team-profile-red-weapon-mode

Command-line option: --team-profile-red-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_RED_WEAPON_MODE
XML key: team-profile-red-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for red team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.132 team-profile-yellow-aggressive

Command-line option: --team-profile-yellow-aggressive=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_AGGRESSIVE
XML key: team-profile-yellow-aggressive

Type: integer

Default value: 200 Min value: 5 Max value: 2000

Defines how aggressive the yellow team is. This is a percentage, if set to 200 then team will attack twice as much as any other team with the default value. Setting this to a high value clearly advantages this team.

4.11.133 team-profile-yellow-fast

Command-line option: --team-profile-yellow-fast=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_FAST
XML key: team-profile-yellow-fast

Type: integer

Default value: 70 Min value: 5 Max value: 2000

Changes the speed of the yellow team. This is a percentage, if set to 50, then team will move twice slower than other teams with the default parameter. Setting this high is very likely to advantage the team.

4.11.134 team-profile-yellow-handicap

Command-line option: --team-profile-yellow-handicap=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_HANDICAP
XML key: team-profile-yellow-handicap

Type: integer

Default value: 100 Min value: 10 Max value: 1000

Defines the handicap for the yellow team.

4.11.135 team-profile-yellow-mobile

Command-line option: --team-profile-yellow-mobile=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_MOBILE
XML key: team-profile-yellow-mobile

Type: integer

Default value: 0 Min value: -3 Max value: 3

Increases (or decreases if negative) the number of move/attack/defense tries for the yellow team. If set to a high value team will appear more mobile and do more things, but it won’t change its cruising speed. It’s not obvious to tell wether this is an advantage or not, but it clearly changes the behavior.

4.11.136 team-profile-yellow-vulnerable

Command-line option: --team-profile-yellow-vulnerable=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_VULNERABLE
XML key: team-profile-yellow-vulnerable

Type: integer

Default value: 90 Min value: 5 Max value: 2000

Defines how vulnerable the yellow team is. This is a percentage, if set to 200 then team will be attacked twice as much as any other team with the default value. Setting this to a high value clearly disadvantages this team.

4.11.137 team-profile-yellow-weapon-alternate-id

Command-line option: --team-profile-yellow-weapon-alternate-id=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_WEAPON_ALTERNATE_ID
XML key: team-profile-yellow-weapon-alternate-id

Type: integer

Default value: 9 Min value: 0 Max value: 19

Id of the default alternate weapon for the yellow team, see the documentation about weapons to know what these ids mean.

4.11.138 team-profile-yellow-weapon-id

Command-line option: --team-profile-yellow-weapon-id=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_WEAPON_ID
XML key: team-profile-yellow-weapon-id

Type: integer

Default value: 5 Min value: 0 Max value: 19

Id of the default weapon for the yellow team, see the documentation about weapons to know what these ids mean.

4.11.139 team-profile-yellow-weapon-mode

Command-line option: --team-profile-yellow-weapon-mode=<value>
Environment variable: LW6_TEAM_PROFILE_YELLOW_WEAPON_MODE
XML key: team-profile-yellow-weapon-mode

Type: integer

Default value: 1 Min value: 0 Max value: 2

Weapon mode for yellow team. 0 means there’s no weapon, 1 means one weapon per team, defined by the weapon-id parameter, 2 means random weapon.

4.11.140 total-armies-size

Command-line option: --total-armies-size=<value>
Environment variable: LW6_TOTAL_ARMIES_SIZE
XML key: total-armies-size

Type: integer

Default value: 60 Min value: 1 Max value: 95

Defines the proportion of the whole available space, which can be occupied by all the armies present together. Setting this low, whenever a new team arrives on the map, fighters might be stolen to other teams, otherwise the ame would get too crowded. This allows you to play with reasonnably enough fighters with 2 players, while still allowing interesting gameplay with many players. This is a percentage, but will be multiplied by itself to get the actual surface. That is, 50 means 50%*50%, that is, a square of 1/2 the size of a square map, so it represents 25% (1/4) of the total surface.

4.11.141 total-time

Command-line option: --total-time=<value>
Environment variable: LW6_TOTAL_TIME
XML key: total-time

Type: integer

Default value: 900 Min value: 10 Max value: 864000

Defines the maximum time of the game, in seconds. Note that in some cases, the game can end much earlier if some player has managed to win before the bell rings. Also, technically, this value will be translated into rounds and moves, and the game engine will wait until enough rounds and moves have been played. So if the computer is too slow and the desired speed is not reached, then the game will last for a longer time.

4.11.142 use-team-profiles

Command-line option: --use-team-profiles=<value>
Environment variable: LW6_USE_TEAM_PROFILES
XML key: use-team-profiles

Type: integer

Default value: 1 Min value: 0 Max value: 1

If set, then all the team-profile-... values will be taken in account. This enables a mode in which teams behave differently according to their colors. If you disable this, then all teams will behave the same, which is more fair, but might not be as fun.

4.11.143 vertical-move

Command-line option: --vertical-move=<value>
Environment variable: LW6_VERTICAL_MOVE
XML key: vertical-move

Type: integer

Default value: 1 Min value: 0 Max value: 7

Defines when to process a vertical move (along the Z ’depth’ axis). If set to 0, fighters never spontaneously move along this axis. If set to 1, it will be tried just after the first move failed. If set to 2, it will be tried just after the second move failed. And so on.

4.11.144 weapon-charge-delay

Command-line option: --weapon-charge-delay=<value>
Environment variable: LW6_WEAPON_CHARGE_DELAY
XML key: weapon-charge-delay

Type: integer

Default value: 30 Min value: 1 Max value: 600

How long it will take for weapons to charge and be usable, by default. Unit is seconds.

4.11.145 weapon-charge-max

Command-line option: --weapon-charge-max=<value>
Environment variable: LW6_WEAPON_CHARGE_MAX
XML key: weapon-charge-max

Type: integer

Default value: 200 Min value: 100 Max value: 1000

Maximum (percentage) of charge intensity that one have. For instance, if this is 400, then if you wait four times more than required before firing, then you weapon will have four times its default power, but if you wait five times more it will still be four times more powerfull, it’s just the limit after which it’s useless to charge.

4.11.146 weapon-duration

Command-line option: --weapon-duration=<value>
Environment variable: LW6_WEAPON_DURATION
XML key: weapon-duration

Type: integer

Default value: 3 Min value: 1 Max value: 60

How long all weapons (for which duration makes sense) will last. Unit is seconds.

4.11.147 weapon-tune-berzerk-power

Command-line option: --weapon-tune-berzerk-power=<value>
Environment variable: LW6_WEAPON_TUNE_BERZERK_POWER
XML key: weapon-tune-berzerk-power

Type: integer

Default value: 3 Min value: 1 Max value: 100

Use to specifiy how strong berzerk mode is, if set to 3, then attacks will be 3 times as efficient in berzerk mode.

4.11.148 weapon-tune-turbo-power

Command-line option: --weapon-tune-turbo-power=<value>
Environment variable: LW6_WEAPON_TUNE_TURBO_POWER
XML key: weapon-tune-turbo-power

Type: integer

Default value: 3 Min value: 1 Max value: 10

Defines how fast fighters move in turbo mode, if set to 3, then fighters move and act 3 times as fast.

4.11.149 x-polarity

Command-line option: --x-polarity=<value>
Environment variable: LW6_X_POLARITY
XML key: x-polarity

Type: integer

Default value: 0 Min value: -1 Max value: 1

Defines how the map will be wrapped on the X (horizontal) axis. If set to 0, nothing is wrapped. If set to 1, the right and left borders are connected, any fighter can disappear on the right border and reappear on the left border, for instance. If set to -1, it will be wrapped but also inversed, that is on a 320x240 map, a fighter disappearing on the left border at position (0,60) will reapper on the right border at position (319,180). You can combine it with ’y-polarity’.

4.11.150 y-polarity

Command-line option: --y-polarity=<value>
Environment variable: LW6_Y_POLARITY
XML key: y-polarity

Type: integer

Default value: 0 Min value: -1 Max value: 1

Defines how the map will be wrapped on the Y (vertical) axis. If set to 0, nothing is wrapped. If set to 1, the top and bottom borders are connected, any fighter can disappear on the top border and reappear on the bottom border, for instance. If set to -1, it will be wrapped but also inversed, that is on a 320x240 map, a fighter disappearing on the bottom border at position (40,239) will reapper on the top border at position (280,0). You can combine it with ’x-polarity’.

4.11.151 z-polarity

Command-line option: --z-polarity=<value>
Environment variable: LW6_Z_POLARITY
XML key: z-polarity

Type: integer

Default value: 0 Min value: 0 Max value: 1

Defines how the map will be wrapped on the Z (deep) axis. If set to 0, nothing is wrapped. If set to 1, when using a 4 layer map, for instance, fighters on layer 1 will be able to go directly to layer 4 even if layers 2 and 3 are filled with walls. A value of -1 is forbidden, this is not like x and y axis, it does not really make sense. Consider this an advanced setting which might save a layer in some tricky cases, the default value of 0 should fit in most cases.


Next: , Previous: , Up: Reference   [Contents][Index]

4.12 Map hints.xml

4.12.1 background-color-auto

Command-line option: --background-color-auto=<value>
Environment variable: LW6_BACKGROUND_COLOR_AUTO
XML key: background-color-auto

Type: boolean

Default value: true

Defines wether hud colors will be set automatically from base and alternate colors. This is a time saver to keep map designers from requiring to redefined every single color in the game. You only need to set color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg. Then hud_color_frame_bg, hud_color_frame_fg, hud_color_text_bg and hud_color_text_fg will be automatically set.

4.12.2 downsize-using-bench-value

Command-line option: --downsize-using-bench-value=<value>
Environment variable: LW6_DOWNSIZE_USING_BENCH_VALUE
XML key: downsize-using-bench-value

Type: boolean

Default value: true

If set, then the game will automatically downsize a map according to the ’bench-value’ parameter. Downsizing means: a 1600x1200 maps becomes 200x150, for instance. Downsizing causes fighters to be bigger because map resolution is lower. This will avoid running the game on a too big map, with your computer not being able to handle it at the required speed.

4.12.3 downsize-using-fighter-scale

Command-line option: --downsize-using-fighter-scale=<value>
Environment variable: LW6_DOWNSIZE_USING_FIGHTER_SCALE
XML key: downsize-using-fighter-scale

Type: boolean

Default value: false

If set, then the game will automatically downsize a map according to the ’fighter-scale’ parameter. Downsizing means: a 1600x1200 maps becomes 200x150, for instance. Downsizing causes fighters to be bigger because map resolution is lower. This can be usefull if you don’t want fighters to be too small.

4.12.4 fighter-scale

Command-line option: --fighter-scale=<value>
Environment variable: LW6_FIGHTER_SCALE
XML key: fighter-scale

Type: float

Default value: 1.0

Defines how wide (in pixels) fighters must be. This parameter is very important and will largely condition the number of fighters on the map. It is used when loading the map. If it is, for instance, set to 1, there will be exactly a fighter per pixel on the screen. That is, if you play 640x480 on an empty map, the maximum fighters you could have is about 300000. The idea is that by changing the resolution, you also define the density of the map. In pratice, this is done in the hope that someone with a slow computer will pick up a low resolution and therefore play small levels. Conversely, someone with a brand new computer with powerfull CPU & GPU will use great resolutions and be happy with many fighters on the map. Still, changing the resolution after loading the map will not affet the number of fighters. Same for network games, the first player, who loads the map, defines its properties according to its own settings.

4.12.5 guess-colors

Command-line option: --guess-colors=<value>
Environment variable: LW6_GUESS_COLORS
XML key: guess-colors

Type: boolean

Default value: true

Defines wether colors should be set automatically from texture colors. If set to true, then the program will try to pick up colors automatically from the texture, and will override the values of the color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg parameters. How these colors are picked up can’t be garanteed, so if the map does not have strong contrast or if there can be any form of ambiguity, it’s safe to set this to false and define one’s own colors.

4.12.6 guess-moves-per-sec

Command-line option: --guess-moves-per-sec=<value>
Environment variable: LW6_GUESS_MOVES_PER_SEC
XML key: guess-moves-per-sec

Type: boolean

Default value: true

If set, then loader will use ’time-to-cross-level’ to guess the game speed parameters.

4.12.7 hud-color-auto

Command-line option: --hud-color-auto=<value>
Environment variable: LW6_HUD_COLOR_AUTO
XML key: hud-color-auto

Type: boolean

Default value: true

Defines wether hud colors will be set automatically from base and alternate colors. This is a time saver to keep map designers from requiring to redefined every single color in the game. You only need to set color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg. Then hud_color_frame_bg, hud_color_frame_fg, hud_color_text_bg and hud_color_text_fg will be automatically set.

4.12.8 max-map-height

Command-line option: --max-map-height=<value>
Environment variable: LW6_MAX_MAP_HEIGHT
XML key: max-map-height

Type: integer

Default value: 1000

Allows you to give a maximum map height. When designing a map you might wonder: this is dumb I’m conceiving this map I know its height, why should I limit it? Now think of the play who plays on a old slowish computer with a tiny screen. He might redefine this himself, and does not necessarly wishes to fire Gimp to rescale the map.

4.12.9 max-map-surface

Command-line option: --max-map-surface=<value>
Environment variable: LW6_MAX_MAP_SURFACE
XML key: max-map-surface

Type: integer

Default value: 1000000

Allows you to give a maximum map surface. Map surface is simply (width * height). This parameter is just here to save you the hassle of defining both ’max-map-width’ and ’max-map-height’ in a consistent manner.

4.12.10 max-map-width

Command-line option: --max-map-width=<value>
Environment variable: LW6_MAX_MAP_WIDTH
XML key: max-map-width

Type: integer

Default value: 1500

Allows you to give a maximum map width. When designing a map you might wonder: this is dumb I’m conceiving this map I know its width, why should I limit it? Now think of the play who plays on a old slowish computer with a tiny screen. He might redefine this himself, and does not necessarly wishes to fire Gimp to rescale the map.

4.12.11 menu-color-auto

Command-line option: --menu-color-auto=<value>
Environment variable: LW6_MENU_COLOR_AUTO
XML key: menu-color-auto

Type: boolean

Default value: true

Defines wether menu colors will be set automatically from base and alternate colors. This is a time saver to keep map designers from requiring to redefined every single color in the game. You only need to set color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg. Then menu_color_default_bg, menu_color_default_fg, menu_color_selected_bg, menu_color_selected_fg, menu_color_disabled_bg and menu_color_disabled_fg will be automatically set.

4.12.12 min-map-height

Command-line option: --min-map-height=<value>
Environment variable: LW6_MIN_MAP_HEIGHT
XML key: min-map-height

Type: integer

Default value: 30

Allows you to give a minimum map height. When designing a map you might wonder: this is dumb I’m conceiving this map I know its height, why should I limit it? Now think of the player who decided to play with highly-defined maps because he has a super calculator and a hudge screen. He might redefine this himself, and does not necessarly wishes to fire Gimp to rescale the map.

4.12.13 min-map-surface

Command-line option: --min-map-surface=<value>
Environment variable: LW6_MIN_MAP_SURFACE
XML key: min-map-surface

Type: integer

Default value: 3600

Allows you to give a minimum map surface. Map surface is simply (width * height). This parameter is just here to save you the hassle of defining both ’min-map-width’ and ’min-map-height’ in a consistent manner.

4.12.14 min-map-width

Command-line option: --min-map-width=<value>
Environment variable: LW6_MIN_MAP_WIDTH
XML key: min-map-width

Type: integer

Default value: 40

Allows you to give a minimum map width. When designing a map you might wonder: this is dumb I’m conceiving this map I know its width, why should I limit it? Now think of the player who decided to play with highly-defined maps because he has a super calculator and a hudge screen. He might redefine this himself, and does not necessarly wishes to fire Gimp to rescale the map.

4.12.15 resample

Command-line option: --resample=<value>
Environment variable: LW6_RESAMPLE
XML key: resample

Type: boolean

Default value: true

If set to true, maps will always be resampled to a size which depends on your screen resolution, zoom factor, and the rest. If false, maps will be set at the exact resolution of map.png.

4.12.16 speed

Command-line option: --speed=<value>
Environment variable: LW6_SPEED
XML key: speed

Type: float

Default value: 1.0

This parameter is the main parameter on which game speed depends. The map loader will garantee, by downscaling the map, that to cross the level (by crossing the level we mean, for instance, going from top-left corner to bottom-right corner in a straight line) a fighter will take a constant amount of time. Under the hood, the loader might of course rescale the map but it will also change game speed so that, at the end, fighters take a constant time to cross the level. This is, indeed, the most important thing, players do not care much if internally there are X or Y moves per second, the global game experience depends on how fast fighter movement looks on the screen. The default settings corresponds roughly to one second to cross the level. If you set this to 2.0, it will go twice faster.

4.12.17 system-color-auto

Command-line option: --system-color-auto=<value>
Environment variable: LW6_SYSTEM_COLOR_AUTO
XML key: system-color-auto

Type: boolean

Default value: true

Defines wether system colors will be set automatically from base and alternate colors. This is a time saver to keep map designers from requiring to redefined every single color in the game. You only need to set color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg. Then system_color_bg and system_color_fg will be automatically set.

4.12.18 upsize-using-bench-value

Command-line option: --upsize-using-bench-value=<value>
Environment variable: LW6_UPSIZE_USING_BENCH_VALUE
XML key: upsize-using-bench-value

Type: boolean

Default value: false

If set, then the game will automatically upsize a map according to the ’fighter-scale’ parameter. Upsizing means: a 160x120 maps becomes 400x300, for instance. Upsizing causes fighters to be smaller because map resolution is higher. This will avoid useless pixelish ’jumbo fighters’ look when your computer is powerfull enough to do better.

4.12.19 upsize-using-fighter-scale

Command-line option: --upsize-using-fighter-scale=<value>
Environment variable: LW6_UPSIZE_USING_FIGHTER_SCALE
XML key: upsize-using-fighter-scale

Type: boolean

Default value: true

If set, then the game will automatically upsize a map according to the ’fighter-scale’ parameter. Upsizing means: a 160x120 maps becomes 400x300, for instance. Upsizing causes fighters to be smaller because map resolution is higher. This can be usefull if you don’t want fighters to be too big.

4.12.20 view-color-auto

Command-line option: --view-color-auto=<value>
Environment variable: LW6_VIEW_COLOR_AUTO
XML key: view-color-auto

Type: boolean

Default value: true

Defines wether view colors will be set automatically from base and alternate colors. This is a time saver to keep map designers from requiring to redefined every single color in the game. You only need to set color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg. Then view_color_cursor_bg, view_color_cursor_fg, view_color_map_bg and view_color_map_fg will be automatically set.

4.12.21 wall-grease

Command-line option: --wall-grease=<value>
Environment variable: LW6_WALL_GREASE
XML key: wall-grease

Type: integer

Default value: 0 Min value: -5 Max value: 5

This parameter allows you to make walls (AKA map foreground) thicker, or thiner, when map is loaded. Indeed, when map are resampled, and especially when they are downscaled, some walls may disappear, or some passages may be blocked. The loader can’t automatically figure out wether it’s more important to keep an existing wall or to keep an open passage for fighters. This parameter helps doing so, if you set it to a low value, level will be less greasy, and many passages might open themselves. On the contrary, if grease is at a high level, then a thin line of almost isolated pixels might become a thick wall. There’s no real garantee your wall or passage will always be present, but it’s a same bet to assume on a ’tunnel-like’ level one needs to set grease to a low value, and on a ’wide open’ level with few walls one needs to set grease to a high value.


Next: , Previous: , Up: Reference   [Contents][Index]

4.13 Map style.xml

4.13.1 animation-density

Command-line option: --animation-density=<value>
Environment variable: LW6_ANIMATION_DENSITY
XML key: animation-density

Type: float

Default value: 1.0 Min value: 0 Max value: 10

Density of the background animation, that is, for instance, if the background animation is about displaying bubbles, using a high value will display many bubbles. A value of 1.0 corresponds to the default setting.

4.13.2 animation-speed

Command-line option: --animation-speed=<value>
Environment variable: LW6_ANIMATION_SPEED
XML key: animation-speed

Type: float

Default value: 1.0 Min value: 0 Max value: 10

Speed of the background animation, that is, for instance, if the background animation is about displaying bubbles, using a high value will cause bubbles to move very fast. A value of 1.0 corresponds to the default setting.

4.13.3 background-color-root-bg

Command-line option: --background-color-root-bg=<value>
Environment variable: LW6_BACKGROUND_COLOR_ROOT_BG
XML key: background-color-root-bg

Type: color

Default value: #000000

Defines the main background color. This is, for instance, the color which will be used to clear the screen before drawing thing. Will be automatically guessed from the map texture if color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.4 background-color-root-fg

Command-line option: --background-color-root-fg=<value>
Environment variable: LW6_BACKGROUND_COLOR_ROOT_FG
XML key: background-color-root-fg

Type: color

Default value: #cccccc

Defines a color which will be used together with color-base-bg to compose the background. It can be wise to have a minimum contrast between this color and color-base-bg, but it is not mandatory, especially if other colors are manually redefined. Will be automatically guessed from the map texture if color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.5 background-color-stuff-bg

Command-line option: --background-color-stuff-bg=<value>
Environment variable: LW6_BACKGROUND_COLOR_STUFF_BG
XML key: background-color-stuff-bg

Type: color

Default value: #333333

Defines a color which will be used together with color-alternate-fg to draw things (animations, sprites, text, whatever) in the background. It should be different enough from color-alternate-fg so that one can really distinguish these colors. Will be automatically guessed from the map texture if color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.6 background-color-stuff-fg

Command-line option: --background-color-stuff-fg=<value>
Environment variable: LW6_BACKGROUND_COLOR_STUFF_FG
XML key: background-color-stuff-fg

Type: color

Default value: #ffffff

Defines a color which will be used to draw things (animations, sprites, text, whatever) in the background. It should be different enough from color-alternate-bg so that one can really distinguish these colors. Think of this as the sprite, the text, the whatever-needs-to-be-seen-uses-this color. Will be automatically guessed from the map texture if color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.7 background-style

Command-line option: --background-style=<value>
Environment variable: LW6_BACKGROUND_STYLE
XML key: background-style

Type: string

Default value: bubbles

The background defines, of course, what is displayed at the background, but it also conditions the colors used for other items, such as the menus for instance. The possible values are ’void’ and ’bubbles’.

4.13.8 blink-cursor

Command-line option: --blink-cursor=<value>
Environment variable: LW6_BLINK_CURSOR
XML key: blink-cursor

Type: boolean

Default value: false

If set, then cursor will blink, allowing you to see what’s under the cursor. It’s just a matter of taste, you might to always have your cursor displayed, or prefer to have it disappear from time to time so that you can see the action below

4.13.9 color-alternate-bg

Command-line option: --color-alternate-bg=<value>
Environment variable: LW6_COLOR_ALTERNATE_BG
XML key: color-alternate-bg

Type: color

Default value: #333333

Defines the alternate color, more precisely, its bg (background) part. Colors are always defined by a bg/fg pair. Most colors in the game can be deduced from this one, usually to color a map you only need to define color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg.

4.13.10 color-alternate-fg

Command-line option: --color-alternate-fg=<value>
Environment variable: LW6_COLOR_ALTERNATE_FG
XML key: color-alternate-fg

Type: color

Default value: #ffffff

Defines the alternate color, more precisely, its fg (foreground) part. Colors are always defined by a bg/fg pair. Most colors in the game can be deduced from this one, usually to color a map you only need to define color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg.

4.13.11 color-base-bg

Command-line option: --color-base-bg=<value>
Environment variable: LW6_COLOR_BASE_BG
XML key: color-base-bg

Type: color

Default value: #000000

Defines the base color, more precisely, its bg (background) part. Colors are always defined by a bg/fg pair. Most colors in the game can be deduced from this one, usually to color a map you only need to define color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg.

4.13.12 color-base-fg

Command-line option: --color-base-fg=<value>
Environment variable: LW6_COLOR_BASE_FG
XML key: color-base-fg

Type: color

Default value: #cccccc

Defines the base color, more precisely, its fg (foreground) part. Colors are always defined by a bg/fg pair. Most colors in the game can be deduced from this one, usually to color a map you only need to define color-base-bg, color-base-fg, color-alternate-bg and color-alternate-fg.

4.13.13 colorize

Command-line option: --colorize=<value>
Environment variable: LW6_COLORIZE
XML key: colorize

Type: boolean

Default value: true

If set, then all background drawings including textures will use the background colors. This means, for instance, that if background colors are set automatically by color-auto from the map texture, then the background will adopt the same range of colors than the map itself. In short, the background will mimic the map.

4.13.14 colorize-cursor

Command-line option: --colorize-cursor=<value>
Environment variable: LW6_COLORIZE_CURSOR
XML key: colorize-cursor

Type: boolean

Default value: true

If set, then all cursors will use the automatic guessed colors, or the specified colors, but basically they won’t be displayed using their native colors. This can be usefull for you can wish to use a generic non-colored texture for your cursor and let it be colorized automatically so that it’s accorded to the level.

4.13.15 cursor-size

Command-line option: --cursor-size=<value>
Environment variable: LW6_CURSOR_SIZE
XML key: cursor-size

Type: float

Default value: 1.0 Min value: 0 Max value: 10

Size of the cursors on the map. 1 is the default, setting it to a higher value will make cursors bigger, a lower value will make them smaller.

4.13.16 hidden-layer-alpha

Command-line option: --hidden-layer-alpha=<value>
Environment variable: LW6_HIDDEN_LAYER_ALPHA
XML key: hidden-layer-alpha

Type: float

Default value: 0.1 Min value: 0 Max value: 1

Whenever players are supposed to be hidden behind a wall, for instance if they are in layer 2 and layer 1 is filled with walls, it’s still possible to see them, but with a low alpha value (almost transparent). This parameter allows you to trick this value, 0 will make these players absolutely invisible, 1 will make them totally opaque, like if they were on layer 1.

4.13.17 hud-color-frame-bg

Command-line option: --hud-color-frame-bg=<value>
Environment variable: LW6_HUD_COLOR_FRAME_BG
XML key: hud-color-frame-bg

Type: color

Default value: #000000

Defines the background color for the hud frame. Ignored if hud-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.18 hud-color-frame-fg

Command-line option: --hud-color-frame-fg=<value>
Environment variable: LW6_HUD_COLOR_FRAME_FG
XML key: hud-color-frame-fg

Type: color

Default value: #cccccc

Defines the foreground color for the hud frame. Ignored if hud-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.19 hud-color-text-bg

Command-line option: --hud-color-text-bg=<value>
Environment variable: LW6_HUD_COLOR_TEXT_BG
XML key: hud-color-text-bg

Type: color

Default value: #333333

Defines the background color for hud text. Ignored if hud-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.20 hud-color-text-fg

Command-line option: --hud-color-text-fg=<value>
Environment variable: LW6_HUD_COLOR_TEXT_FG
XML key: hud-color-text-fg

Type: color

Default value: #ffffff

Defines the foreground color for hud text. Ignored if hud-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.21 hud-style

Command-line option: --hud-style=<value>
Environment variable: LW6_HUD_STYLE
XML key: hud-style

Type: string

Default value: floating

The hud is where informations about the game are displayed. This means, who is winning, are other status-like informations. Possible values include ’floating’ and ’tactical’.

4.13.22 keep-ratio

Command-line option: --keep-ratio=<value>
Environment variable: LW6_KEEP_RATIO
XML key: keep-ratio

Type: boolean

Default value: true

Defines wether the map should keep its ratio, or if it should be stretched to fill the shape of your screen.

4.13.23 menu-color-default-bg

Command-line option: --menu-color-default-bg=<value>
Environment variable: LW6_MENU_COLOR_DEFAULT_BG
XML key: menu-color-default-bg

Type: color

Default value: #333333

Defines the default background color for menus. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.24 menu-color-default-fg

Command-line option: --menu-color-default-fg=<value>
Environment variable: LW6_MENU_COLOR_DEFAULT_FG
XML key: menu-color-default-fg

Type: color

Default value: #ffffff

Defines the default foreground color for menus. In fact, this is the main color for menu text, the color used to draw letters in menus. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.25 menu-color-disabled-bg

Command-line option: --menu-color-disabled-bg=<value>
Environment variable: LW6_MENU_COLOR_DISABLED_BG
XML key: menu-color-disabled-bg

Type: color

Default value: #000000

Defines the background color for a disabled menu item. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.26 menu-color-disabled-fg

Command-line option: --menu-color-disabled-fg=<value>
Environment variable: LW6_MENU_COLOR_DISABLED_FG
XML key: menu-color-disabled-fg

Type: color

Default value: #cccccc

Defines the foreground color for a disabled menu item. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.27 menu-color-selected-bg

Command-line option: --menu-color-selected-bg=<value>
Environment variable: LW6_MENU_COLOR_SELECTED_BG
XML key: menu-color-selected-bg

Type: color

Default value: #ffffff

Defines the background color for a selected menu item. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.28 menu-color-selected-fg

Command-line option: --menu-color-selected-fg=<value>
Environment variable: LW6_MENU_COLOR_SELECTED_FG
XML key: menu-color-selected-fg

Type: color

Default value: #333333

Defines the foreground color for a selected menu item. Ignored if menu-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.29 menu-style

Command-line option: --menu-style=<value>
Environment variable: LW6_MENU_STYLE
XML key: menu-style

Type: string

Default value: cylinder

The menu style is simply the name of the engine used to power the menu system. The only possible value, for now, is ’cylinder’.

4.13.30 music-exclude

Command-line option: --music-exclude=<value>
Environment variable: LW6_MUSIC_EXCLUDE
XML key: music-exclude

Type: string

Default value: Chadburn

If this string is found in a music file name, it will be excluded from the list when playing in random mode.

4.13.31 music-file

Command-line option: --music-file=<value>
Environment variable: LW6_MUSIC_FILE
XML key: music-file

Type: string

Default value:

Allows you to play a custom music file (typically your own ogg music) and override default game music. If file does not exist, game will use its internal music. The file will be searched for in the current ’music-path’ but also in the current map directory. No absolute or even relative path are allowed, only a plain filename with no slash or backslash. Avoid special characters at all cost.

4.13.32 music-filter

Command-line option: --music-filter=<value>
Environment variable: LW6_MUSIC_FILTER
XML key: music-filter

Type: string

Default value:

A music filter, used when files are played randomly. This is not a complex regex-enabled filter, just a plain string search. Even the ’*’ wildcard won’t work. If you want precise control on what music file to play, please consider reorganizing your files and/or use the ’music-file’ parameter.

4.13.33 pixelize

Command-line option: --pixelize=<value>
Environment variable: LW6_PIXELIZE
XML key: pixelize

Type: boolean

Default value: false

Depending on the renderer capabilities, will try to pixelize some parts of the game. This can be used to emulate the old LW5 appearance.

4.13.34 system-color-bg

Command-line option: --system-color-bg=<value>
Environment variable: LW6_SYSTEM_COLOR_BG
XML key: system-color-bg

Type: color

Default value: #333333

Defines the system background color, used when displaying system info, such as the number of frames per second. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.35 system-color-fg

Command-line option: --system-color-fg=<value>
Environment variable: LW6_SYSTEM_COLOR_FG
XML key: system-color-fg

Type: color

Default value: #ffffff

Defines the system foreground color, used when displaying system info, such as the number of frames per second. This will typically be text color. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.36 team-color-blue

Command-line option: --team-color-blue=<value>
Environment variable: LW6_TEAM_COLOR_BLUE
XML key: team-color-blue

Type: color

Default value: #0000ff

Defines the color for the blue team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.37 team-color-cyan

Command-line option: --team-color-cyan=<value>
Environment variable: LW6_TEAM_COLOR_CYAN
XML key: team-color-cyan

Type: color

Default value: #00ffff

Defines the color for the cyan team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.38 team-color-dead

Command-line option: --team-color-dead=<value>
Environment variable: LW6_TEAM_COLOR_DEAD
XML key: team-color-dead

Type: color

Default value: #000000

Defines the color for the teams when they are dead. By default it is black, this means when a team is weak it becomes black. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.39 team-color-green

Command-line option: --team-color-green=<value>
Environment variable: LW6_TEAM_COLOR_GREEN
XML key: team-color-green

Type: color

Default value: #00ff00

Defines the color for the green team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.40 team-color-lightblue

Command-line option: --team-color-lightblue=<value>
Environment variable: LW6_TEAM_COLOR_LIGHTBLUE
XML key: team-color-lightblue

Type: color

Default value: #88bbff

Defines the color for the light blue team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.41 team-color-magenta

Command-line option: --team-color-magenta=<value>
Environment variable: LW6_TEAM_COLOR_MAGENTA
XML key: team-color-magenta

Type: color

Default value: #ff00ff

Defines the color for the magenta team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.42 team-color-orange

Command-line option: --team-color-orange=<value>
Environment variable: LW6_TEAM_COLOR_ORANGE
XML key: team-color-orange

Type: color

Default value: #ff8800

Defines the color for the orange team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.43 team-color-pink

Command-line option: --team-color-pink=<value>
Environment variable: LW6_TEAM_COLOR_PINK
XML key: team-color-pink

Type: color

Default value: #ff88bb

Defines the color for the pink team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.44 team-color-purple

Command-line option: --team-color-purple=<value>
Environment variable: LW6_TEAM_COLOR_PURPLE
XML key: team-color-purple

Type: color

Default value: #bb88ff

Defines the color for the purple team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.45 team-color-red

Command-line option: --team-color-red=<value>
Environment variable: LW6_TEAM_COLOR_RED
XML key: team-color-red

Type: color

Default value: #ff0000

Defines the color for the red team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.46 team-color-yellow

Command-line option: --team-color-yellow=<value>
Environment variable: LW6_TEAM_COLOR_YELLOW
XML key: team-color-yellow

Type: color

Default value: #ffff00

Defines the color for the yellow team. Syntax is HTML-like, #RGB or #RRGGBB.

4.13.47 view-color-cursor-bg

Command-line option: --view-color-cursor-bg=<value>
Environment variable: LW6_VIEW_COLOR_CURSOR_BG
XML key: view-color-cursor-bg

Type: color

Default value: #333333

Defines the background cursor color. Will typically be used to draw the shape of the cursor. Ignored if view-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.48 view-color-cursor-fg

Command-line option: --view-color-cursor-fg=<value>
Environment variable: LW6_VIEW_COLOR_CURSOR_FG
XML key: view-color-cursor-fg

Type: color

Default value: #ffffff

Defines the foreground cursor color. Will typically be used to draw text in the cursor. Ignored if view-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.49 view-color-map-bg

Command-line option: --view-color-map-bg=<value>
Environment variable: LW6_VIEW_COLOR_MAP_BG
XML key: view-color-map-bg

Type: color

Default value: #000000

Defines the background map color. If there’s no map texture defined or if use-texture is false, this is the color of the places where armies will go. Ignored if view-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.50 view-color-map-fg

Command-line option: --view-color-map-fg=<value>
Environment variable: LW6_VIEW_COLOR_MAP_FG
XML key: view-color-map-fg

Type: color

Default value: #cccccc

Defines the foreground map color. If there’s no map texture defined or if use-texture is false, this is the color of walls, what armies can’t go through. Ignored if view-color-auto is set. Can be #RGB, #RGBA, #RRGGBB or #RRGGBBAA.

4.13.51 view-style

Command-line option: --view-style=<value>
Environment variable: LW6_VIEW_STYLE
XML key: view-style

Type: string

Default value: flat

The view style conditions which renderer is used for the map, the area where fighters are displayed. This is not the graphics backend. Indeed, the graphics backend defines which technical tool one uses (which library) one runs, wether this parameter says what kind of rendering one wants.

4.13.52 waves

Command-line option: --waves=<value>
Environment variable: LW6_WAVES
XML key: waves

Type: boolean

Default value: true

Activates the wave effect, that’s to say level appears to be under water when playing.

4.13.53 x-wrap

Command-line option: --x-wrap=<value>
Environment variable: LW6_X_WRAP
XML key: x-wrap

Type: boolean

Default value: true

Defines wether the map should be wrapped on the x axis. This is the companion of ’x-polarity’, if no polarity is defined, map can’t be wrapped, but in some cases, one might wish to have a map with polarity but without wrapping if, for instance, textures do not tile nicely.

4.13.54 y-wrap

Command-line option: --y-wrap=<value>
Environment variable: LW6_Y_WRAP
XML key: y-wrap

Type: boolean

Default value: true

Defines wether the map should be wrapped on the y axis. This is the companion of ’y-polarity’, if no polarity is defined, map can’t be wrapped, but in some cases, one might wish to have a map with polarity but without wrapping if, for instance, textures do not tile nicely.

4.13.55 zoom

Command-line option: --zoom=<value>
Environment variable: LW6_ZOOM
XML key: zoom

Type: float

Default value: 1.0

Defines the map zoom. If lower than 1.0, map will occupy only a fraction of the screen, if greater than 1.0, some areas will be outside the screen, and the player will need to scroll through it.

4.13.56 zoom-max

Command-line option: --zoom-max=<value>
Environment variable: LW6_ZOOM_MAX
XML key: zoom-max

Type: float

Default value: 30.0

Defines the max map zoom. If set to a high value, you’ll be able to dynamically view the map with hudge fighters, seeing only a fraction of the level.

4.13.57 zoom-min

Command-line option: --zoom-min=<value>
Environment variable: LW6_ZOOM_MIN
XML key: zoom-min

Type: float

Default value: 0.3

Defines the min map zoom. If set to a low value, you’ll be able to dynamically view a very small, reduced map.


Next: , Previous: , Up: Reference   [Contents][Index]

4.14 Map teams.xml

4.14.1 bot-iq

Command-line option: --bot-iq=<value>
Environment variable: LW6_BOT_IQ
XML key: bot-iq

Type: integer

Default value: 100 Min value: 0 Max value: 200

The IQ (intelligence quotient) of bots. Typically, a value of 100 will make the bot behave normally, performing at its best. A value of 0 will just make it act the worst way it can. Values over 100 probably won’t change anything compared to 100, but this truely depends on which bot backend you’re running.

4.14.2 bot-speed

Command-line option: --bot-speed=<value>
Environment variable: LW6_BOT_SPEED
XML key: bot-speed

Type: float

Default value: 1.0f

The speed of bots, 1 means normal speed, higher value will speed it up, lower will slow it down. Note that this only has an impact on bot engines, not on the game speed itself.

4.14.3 bot1-ai

Command-line option: --bot1-ai=<value>
Environment variable: LW6_BOT1_AI
XML key: bot1-ai

Type: string

Default value: idiot

AI engine for bot number 1.

4.14.4 bot1-color

Command-line option: --bot1-color=<value>
Environment variable: LW6_BOT1_COLOR
XML key: bot1-color

Type: string

Default value: green

Color for bot number 1.

4.14.5 bot2-ai

Command-line option: --bot2-ai=<value>
Environment variable: LW6_BOT2_AI
XML key: bot2-ai

Type: string

Default value: idiot

AI engine for bot number 2.

4.14.6 bot2-color

Command-line option: --bot2-color=<value>
Environment variable: LW6_BOT2_COLOR
XML key: bot2-color

Type: string

Default value: blue

Color for bot number 2.

4.14.7 bot3-ai

Command-line option: --bot3-ai=<value>
Environment variable: LW6_BOT3_AI
XML key: bot3-ai

Type: string

Default value: random

AI engine for bot number 3.

4.14.8 bot3-color

Command-line option: --bot3-color=<value>
Environment variable: LW6_BOT3_COLOR
XML key: bot3-color

Type: string

Default value: yellow

Color for bot number 3.

4.14.9 bot4-ai

Command-line option: --bot4-ai=<value>
Environment variable: LW6_BOT4_AI
XML key: bot4-ai

Type: string

Default value: follow

AI engine for bot number 4.

4.14.10 bot4-color

Command-line option: --bot4-color=<value>
Environment variable: LW6_BOT4_COLOR
XML key: bot4-color

Type: string

Default value: cyan

Color for bot number 4.

4.14.11 bot5-ai

Command-line option: --bot5-ai=<value>
Environment variable: LW6_BOT5_AI
XML key: bot5-ai

Type: string

Default value: random

AI engine for bot number 5.

4.14.12 bot5-color

Command-line option: --bot5-color=<value>
Environment variable: LW6_BOT5_COLOR
XML key: bot5-color

Type: string

Default value: magenta

Color for bot number 5.

4.14.13 bot6-ai

Command-line option: --bot6-ai=<value>
Environment variable: LW6_BOT6_AI
XML key: bot6-ai

Type: string

Default value: follow

AI engine for bot number 6.

4.14.14 bot6-color

Command-line option: --bot6-color=<value>
Environment variable: LW6_BOT6_COLOR
XML key: bot6-color

Type: string

Default value: orange

Color for bot number 6.

4.14.15 bot7-ai

Command-line option: --bot7-ai=<value>
Environment variable: LW6_BOT7_AI
XML key: bot7-ai

Type: string

Default value: idiot

AI engine for bot number 7.

4.14.16 bot7-color

Command-line option: --bot7-color=<value>
Environment variable: LW6_BOT7_COLOR
XML key: bot7-color

Type: string

Default value: lightblue

Color for bot number 7.

4.14.17 bot8-ai

Command-line option: --bot8-ai=<value>
Environment variable: LW6_BOT8_AI
XML key: bot8-ai

Type: string

Default value: idiot

AI engine for bot number 8.

4.14.18 bot8-color

Command-line option: --bot8-color=<value>
Environment variable: LW6_BOT8_COLOR
XML key: bot8-color

Type: string

Default value: purple

Color for bot number 8.

4.14.19 bot9-ai

Command-line option: --bot9-ai=<value>
Environment variable: LW6_BOT9_AI
XML key: bot9-ai

Type: string

Default value: idiot

AI engine for bot number 9.

4.14.20 bot9-color

Command-line option: --bot9-color=<value>
Environment variable: LW6_BOT9_COLOR
XML key: bot9-color

Type: string

Default value: pink

Color for bot number 9.

4.14.21 nb-bots

Command-line option: --nb-bots=<value>
Environment variable: LW6_NB_BOTS
XML key: nb-bots

Type: integer

Default value: 2 Min value: 0 Max value: 9

Number of bots on the map. 0 means no bots, if set to 1 the the bot1-... settings will be used, if set to 2 then bot1-... and bot2-... will be used, and so on.

4.14.22 player1-color

Command-line option: --player1-color=<value>
Environment variable: LW6_PLAYER1_COLOR
XML key: player1-color

Type: string

Default value: red

Color of the first player, must be red, green, blue, yellow, cyan, magenta, orange, lightblue, purple or pink

4.14.23 player2-color

Command-line option: --player2-color=<value>
Environment variable: LW6_PLAYER2_COLOR
XML key: player2-color

Type: string

Default value: green

Color of the second player, must be red, green, blue, yellow, cyan, magenta, orange, lightblue, purple or pink

4.14.24 player3-color

Command-line option: --player3-color=<value>
Environment variable: LW6_PLAYER3_COLOR
XML key: player3-color

Type: string

Default value: blue

Color of the third player, must be red, green, blue, yellow, cyan, magenta, orange, lightblue, purple or pink

4.14.25 player4-color

Command-line option: --player4-color=<value>
Environment variable: LW6_PLAYER4_COLOR
XML key: player4-color

Type: string

Default value: yellow

Color of the fourth player, must be red, green, blue, yellow, cyan, magenta, orange, lightblue, purple or pink


Next: , Previous: , Up: Reference   [Contents][Index]

4.15 Advanced settings

4.15.1 base64-decode

Command-line option: --base64-decode

If specified, program will take stdin and base64 decode it to stdout. This is for testing purpose (for network messages for instance). Will decode in standard base64 encoding using characters + and / but also the url-compliant version using - and /, see RFC 4648 for details.

4.15.2 base64-encode

Command-line option: --base64-encode

If specified, program will take stdin and base64 encode it to stdout. This is for testing purpose (for network messages for instance). Will *not* use standard base64 encoding using characters + and / but - and _ instead to be url-compliant, see RFC 4648 for details.

4.15.3 bench

Command-line option: --bench

Runs a benchmarking test which will report an approximative performance estimation of the game on your computer. The result is in an arbitrary unit, but it is logarithmic, and works the way the audio decibels do. That is, 30 is 10 times greater than 20. 10 is supposed to be a reference of a computer that can reasonnably run the game. So if you get 40, you are 1000 times powerfull enough. Negative values can technically show up on very slow computers.

4.15.4 bench-value

Command-line option: --bench-value=<value>
Environment variable: LW6_BENCH_VALUE
XML key: bench-value

Type: integer

Default value: 20

Contains the current bench value of the computer running the game. This is used internally to choose the right map settings. You can override this value and use your own but... use at your own risk. Pretending you have a faster computer than what you really have can lead to confusion.

4.15.5 bin-id

Command-line option: --bin-id=<value>
Environment variable: LW6_BIN_ID
XML key: bin-id

Type: integer

Default value: 0

The internal ’bin-id’ value. Note that this is not necessarly equal to the value returned by ’show-build-bin-id’. When they are different, it is assumed this is because of a software upgrade.

4.15.6 check

Command-line option: --check

Running the game with ’–check’ is almost like running ’–test’, the difference is that ’–check’ will not run tests which involve graphics or sound backends, so it’s adapted to pure console mode. This can be usefull for automated checks on a build farm, or if you want to check things in a headless (pure console) environment.

4.15.7 commands-per-sec

Command-line option: --commands-per-sec=<value>
Environment variable: LW6_COMMANDS_PER_SEC
XML key: commands-per-sec

Type: integer

Default value: 10 Min value: 1 Max value: 1000

Defines the number of commands per second. When a command is generated, orders are actually sent to the game engine, for instance, ’this cursor moved there’. So this option will affect game responsiveness, setting this to a high value will make the game more responsive but consume bandwidth on network games.

4.15.8 cunit

Command-line option: --cunit

Running the game with ’–cunit’ is almost like running ’–test’, the difference is that ’–cunit’ will use CUnit interactive interface, allowing the user to cherry-pick some tests, and avoid running the whole suite just for one test. This can be usefull for debugging, when individual test binaries are not available.

4.15.9 daemon

Command-line option: --daemon

Start the game in daemon mode, this is typically used with the server mode, if you want the process to be detached from the console and executed in the background.

4.15.10 debug-layer-id

Command-line option: --debug-layer-id=<value>
Environment variable: LW6_DEBUG_LAYER_ID
XML key: debug-layer-id

Type: integer

Default value: 0 Min value: 0 Max value: 6

A team id which will be used for debugging purposes, for instance when displaying gradient.

4.15.11 debug-team-id

Command-line option: --debug-team-id=<value>
Environment variable: LW6_DEBUG_TEAM_ID
XML key: debug-team-id

Type: integer

Default value: 0 Min value: 0 Max value: 9

A team id which will be used for debugging purposes, for instance when displaying gradient.

4.15.12 demo

Command-line option: --demo

Start the game in demo mode. 2 bots play against each other forever.

4.15.13 dialog-timeout

Command-line option: --dialog-timeout=<value>
Environment variable: LW6_DIALOG_TIMEOUT
XML key: dialog-timeout

Type: integer

Default value: 3600 Min value: 0 Max value: 86400

Timeout, in seconds, after which a dialog will automatically be closed, wether user clicked on it or not. Mostly used for testing, to avoid program being stall on a visual prompt. 0 will simply disable this feature and wait forever. Note that some platforms might not support this. Interfaces using Gtk do support it.

4.15.14 dirty-read

Command-line option: --dirty-read=<value>
Environment variable: LW6_DIRTY_READ
XML key: dirty-read

Type: integer

Default value: 2 Min value: 0 Max value: 2

How to handle dirty reads and locks when displaying stuff. If set to 0, there will be no dirty reads at all, a lock (mutex) will be set whenever it’s needed. If set to 1, display might be done with inconsistent data, however the data itself won’t be modified while displaying. If set to 2, displayed data can (and will) be modified while the rendering thread is running.

4.15.15 display-background

Command-line option: --display-background=<value>
Environment variable: LW6_DISPLAY_BACKGROUND
XML key: display-background

Type: boolean

Default value: true

Decides wether the background animation/image should be displayed at all.

4.15.16 display-console

Command-line option: --display-console=<value>
Environment variable: LW6_DISPLAY_CONSOLE
XML key: display-console

Type: boolean

Default value: false

Defines wether the interactive system console must be displayed. Note that console support must have been enabled at compilation time. It might not be available on your computer, for instance if you are running a system such as Microsoft Windows.

4.15.17 display-cursors

Command-line option: --display-cursors=<value>
Environment variable: LW6_DISPLAY_CURSORS
XML key: display-cursors

Type: boolean

Default value: true

Debugging option which can be set to ’false’ to disable the display of cursors when playing.

4.15.18 display-debug-gradient

Command-line option: --display-debug-gradient=<value>
Environment variable: LW6_DISPLAY_DEBUG_GRADIENT
XML key: display-debug-gradient

Type: boolean

Default value: false

Set this to ’true’ to display the gradient, this is usefull to debug the core algorithm or understand how it works.

4.15.19 display-debug-zones

Command-line option: --display-debug-zones=<value>
Environment variable: LW6_DISPLAY_DEBUG_ZONES
XML key: display-debug-zones

Type: boolean

Default value: false

Set this to ’true’ to display the zones, this is usefull to debug the core algorithm or understand how it works.

4.15.20 display-fighters

Command-line option: --display-fighters=<value>
Environment variable: LW6_DISPLAY_FIGHTERS
XML key: display-fighters

Type: boolean

Default value: true

Debugging option which can be set to ’false’ to disable the display of fighters when playing.

4.15.21 display-fps

Command-line option: --display-fps=<value>
Environment variable: LW6_DISPLAY_FPS
XML key: display-fps

Type: boolean

Default value: false

Set this to ’true’ to display the number of frames per second. When this gets too low... play a smaller map, buy a new computer or contribute and hack Liquid War 6 so that it runs faster!

4.15.22 display-hud

Command-line option: --display-hud=<value>
Environment variable: LW6_DISPLAY_HUD
XML key: display-hud

Type: boolean

Default value: true

Decides wether the hud (informations while playing) should be displayed.

4.15.23 display-log

Command-line option: --display-log=<value>
Environment variable: LW6_DISPLAY_LOG
XML key: display-log

Type: boolean

Default value: true

Set this to ’false’ to disable the display of error messages on the screen. Mote that you can miss valuable informations.

4.15.24 display-map

Command-line option: --display-map=<value>
Environment variable: LW6_DISPLAY_MAP
XML key: display-map

Type: boolean

Default value: true

Debugging option which can be set to ’false’ to disable map (level) display when playing.

4.15.25 display-menu

Command-line option: --display-menu=<value>
Environment variable: LW6_DISPLAY_MENU
XML key: display-menu

Type: boolean

Default value: true

Debugging option which can be set to ’false’ to disable the display of menus.

4.15.26 display-meta

Command-line option: --display-meta=<value>
Environment variable: LW6_DISPLAY_META
XML key: display-meta

Type: boolean

Default value: true

Set to ’false’ to disable the display of meta information, this includes the help, tootips and breadcrumbs in menus.

4.15.27 display-mouse

Command-line option: --display-mouse=<value>
Environment variable: LW6_DISPLAY_MOUSE
XML key: display-mouse

Type: boolean

Default value: true

Set this to ’false’ to always hide the mouse pointer.

4.15.28 display-mps

Command-line option: --display-mps=<value>
Environment variable: LW6_DISPLAY_MPS
XML key: display-mps

Type: boolean

Default value: false

Set this to ’true’ to display the number of moves per second. In theory the game should maintain this constant but in practise it can get low if your computer is too slow or too busy.

4.15.29 display-preview

Command-line option: --display-preview=<value>
Environment variable: LW6_DISPLAY_PREVIEW
XML key: display-preview

Type: boolean

Default value: true

Decides wether a map preview should be displayed when choosing a level.

4.15.30 display-progress

Command-line option: --display-progress=<value>
Environment variable: LW6_DISPLAY_PROGRESS
XML key: display-progress

Type: boolean

Default value: true

Decides wether a progress bar should be displayed when a long operation is realized as a background task.

4.15.31 display-score

Command-line option: --display-score=<value>
Environment variable: LW6_DISPLAY_SCORE
XML key: display-score

Type: boolean

Default value: true

Decides wether the score screen should be displayed.

4.15.32 display-splash

Command-line option: --display-splash=<value>
Environment variable: LW6_DISPLAY_SPLASH
XML key: display-splash

Type: boolean

Default value: true

Set this to ’false’ to disable the display of the splash screen at game startup.

4.15.33 display-url

Command-line option: --display-url=<value>
Environment variable: LW6_DISPLAY_URL
XML key: display-url

Type: boolean

Default value: false

Set this to ’true’ to display the URL (homepage) of the game. This is mostly used when doing screenshots, so that generated images contain a link to the homepage.

4.15.34 executed-again

Command-line option: --executed-again=<value>
Environment variable: LW6_EXECUTED_AGAIN
XML key: executed-again

Type: boolean

Default value: false

This environment variable/keyword is used to detect wether the program has been launched by itself with an internal execv call. This is used as a workarround to set some environment variables (DYLD_LIBRARY_PATH on Mac OS X for instance) before the program is run, as sometimes using setenv() inside the program does not work.

4.15.35 gfx-cpu-usage

Command-line option: --gfx-cpu-usage=<value>
Environment variable: LW6_GFX_CPU_USAGE
XML key: gfx-cpu-usage

Type: float

Default value: 0.75 Min value: 0 Max value: 1

Percentage of the CPU which will be used by the display thread. It’s wise to leave some time to other threads to execute. The OS does it naturally, but setting this helps the whole process by explicitely pausing (sleep call) the display thread. You could change this to a low value if you have lagging games but smooth display.

4.15.36 gfx-debug

Command-line option: --gfx-debug=<value>
Environment variable: LW6_GFX_DEBUG
XML key: gfx-debug

Type: boolean

Default value: false

Enables dedicated graphics debugging tools. This is different from ’debug’ mode which is global, this one is really graphics specific.

4.15.37 io-per-sec

Command-line option: --io-per-sec=<value>
Environment variable: LW6_IO_PER_SEC
XML key: io-per-sec

Type: integer

Default value: 20 Min value: 1 Max value: 1000

Defines the number of calls to input/output functions per second. This can affect speed of menus but also cursors, but won’t change the speed of the game itself. It’s a cosmectic, comfort option.

4.15.38 jpeg-quality

Command-line option: --jpeg-quality=<value>
Environment variable: LW6_JPEG_QUALITY
XML key: jpeg-quality

Type: integer

Default value: 85 Min value: 0 Max value: 85

Quality used by libjpeg when creating screenshot images. The same value you would give to Gimp before exporting an image as a JPEG.

4.15.39 loader-sleep

Command-line option: --loader-sleep=<value>
Environment variable: LW6_LOADER_SLEEP
XML key: loader-sleep

Type: float

Default value: 0.5

Defines how long the loader thread should wait between two polls. Default value should fit in most cases.

4.15.40 local-bench-delta

Command-line option: --local-bench-delta=<value>
Environment variable: LW6_LOCAL_BENCH_DELTA
XML key: local-bench-delta

Type: integer

Default value: 0 Min value: -70 Max value: 20

A value which is added to bench before starting a local game. This is typically zero or negative, as adding to bench is like pretending your computer is faster than it really is.

4.15.41 log-level

Command-line option: --log-level=<value>
Environment variable: LW6_LOG_LEVEL
XML key: log-level

Type: integer

Default value: 3 Min value: 0 Max value: 4

Defines the log level, that is, how verbose the program will be regarding logs and console output. 0 (ERROR) is the minimum, only errors are reported. 1 (WARNING) means errors + warnings. 2 (NOTICE) displays most important messages. 3 (INFO) is the default, the log file will contain all messages but debug stuff. 4 (DEBUG) logs everything, including debug informations.

4.15.42 log-timeout

Command-line option: --log-timeout=<value>
Environment variable: LW6_LOG_TIMEOUT
XML key: log-timeout

Type: integer

Default value: 5000

Delay, in msec, for which a log message will stay displayed on the screen.

4.15.43 magic-number

Command-line option: --magic-number=<value>
Environment variable: LW6_MAGIC_NUMBER
XML key: magic-number

Type: integer

Default value: 14741

This ’magic’ number probably requires an explanation. It’s used to estimate how big a map can be built. The calculus is very approximative, basically bench_value*magic_number=total_fighters_on_map*rounds_per_sec*moves_per_round with total_fighters_on_map depending on various parameters such as map size but also how many fighters are on the map. The map loader will try and adjust the map size so that it is just big enough not to saturate your CPU while being as high-res as possible. The magic number in itself has no real meaning, the higher it gets, the more optimized it means the game is. Normally you shouldn’t change this but if you find the map resizing is too agressively pessimistic, or if for some reason bench returns bogus values, you can modify it.

4.15.44 max-local-bench-value

Command-line option: --max-local-bench-value=<value>
Environment variable: LW6_MAX_LOCAL_BENCH_VALUE
XML key: max-local-bench-value

Type: integer

Default value: 800

Even if your computer is very fast, this parameter will be used to tame the optimism of the test, and do not load maps in very high detail. It’s believed at some point, it’s best to keep your extra power to deal with unordinary situations rather than waste it on useless details. Game should be fun with that setting, but if you really want to use your shiny CPU at its maximum, raise this.

4.15.45 max-network-bench-value

Command-line option: --max-network-bench-value=<value>
Environment variable: LW6_MAX_NETWORK_BENCH_VALUE
XML key: max-network-bench-value

Type: integer

Default value: 200

On network games, we need to be sure everyone can play in correct conditions, therefore maps won’t be loaded with more details than this, by default. You’re free to increase this parameter but it can cause your games to be unjoignable by some people.

4.15.46 memory-bazooka-eraser

Command-line option: --memory-bazooka-eraser=<value>
Environment variable: LW6_MEMORY_BAZOOKA_ERASER
XML key: memory-bazooka-eraser

Type: boolean

Default value: true

The memory eraser is a tool which will systematically fill allocated memory with ’M’, and overwrite all allocated bytes with ’F’ before freeing memory. It will even handle realloc calls. This is usefull to track bugs. Indeed, with this option enabled, freshly allocated memory will never contain zeroes unless one calls calloc, and if you ever free some memory zone before being done with it, it will be filled with junk and therefore not be usable. The memory bazooka must be big enough if you want this feature to actually work.

4.15.47 memory-bazooka-size

Command-line option: --memory-bazooka-size=<value>
Environment variable: LW6_MEMORY_BAZOOKA_SIZE
XML key: memory-bazooka-size

Type: integer

Default value: 99991

The memory bazooka is a brute-force tool, conceived after a full night spent tracking some memory leak. The idea is to keep a track of all allocated pointers, when the data was allocated (timestamp), where in the code (file, line), and even point out what data there is in that place. A memory bazooka report at the end of the game will just show what’s left. There should be nothing. This parameter is here to avoid wasting CPU cycles on a feature which is very debug-oriented and does not really make sense for the casual user. Set it to 0 for best performance, something like 100 might just be helpfull, but 1000000 is the right way to seriously debug code.

4.15.48 net-log

Command-line option: --net-log=<value>
Environment variable: LW6_NET_LOG
XML key: net-log

Type: boolean

Default value: false

Activates network log, that is, logs everything sent/received over the network, except data which is sent through a third party library such as libCurl. This is mostly for debugging purpose, it can lead to rather big log files.

4.15.49 net-per-sec

Command-line option: --net-per-sec=<value>
Environment variable: LW6_NET_PER_SEC
XML key: net-per-sec

Type: integer

Default value: 500 Min value: 1 Max value: 1000

Defines the number of calls to network functions per second. This can technically change the network transfers speed, the higher the number, the faster it should be, but at the same time it can technically be more CPU greedy.

4.15.50 network-bench-delta

Command-line option: --network-bench-delta=<value>
Environment variable: LW6_NETWORK_BENCH_DELTA
XML key: network-bench-delta

Type: integer

Default value: -5 Min value: -70 Max value: 20

A value which is added to bench before starting a network game. This is typically a negative value, lower than the one added to local game. This is because network games can be more CPU greedy.

4.15.51 network-reliability

Command-line option: --network-reliability=<value>
Environment variable: LW6_NETWORK_RELIABILITY
XML key: network-reliability

Type: integer

Default value: 1000 Min value: 1 Max value: 1000000000

The program assumes network is non-reliable, however the problem with those assumptions is that when you test, network is always reliable, even with non-garanteed protocols like UDP. This option will force the program to actually ignore some calls to send or recv functions, simulating a network disfunction. This is to ensure the internal mecanisms correcting network problems do work for good, on daily regular use. It’s not possible to set it to a perfect behavior, never dropping any packet, however using the default settings you probably won’t even notice the performance drop induced by having to fix problems. The highest the number is, the most reliable network will look, the algorithm is simply to drop one message out of X.

4.15.52 open-relay

Command-line option: --open-relay=<value>
Environment variable: LW6_OPEN_RELAY
XML key: open-relay

Type: boolean

Default value: false

Enables forwarding of abritrary network messages. If open relay is forbidden, the game will only forward messages when physical sender and logical sender are the same. This is to say if messages come from A for C and is sent by A to B, B will forward it to C. But if message comes from X to C and is sent by A to B, then B won’t forward it. In practice, it means without open relay, messages can only be forwarded once.

4.15.53 pilot-lag

Command-line option: --pilot-lag=<value>
Environment variable: LW6_PILOT_LAG
XML key: pilot-lag

Type: integer

Default value: 10

Maximum lag, in rounds, until the game engine is slowed down. This will typically be usefull if your computer is too slow for the map resolution and the game speed you set up.

4.15.54 quick-start

Command-line option: --quick-start

Start the game just like if the player had requested a quick start, without showing any menu.

4.15.55 reset

Command-line option: --reset

Clears the config file so that the game will run with defaults next time. The idea is to get rid of traces of previous executions. The difference with ’–defaults’ is that ’–reset’ does not run the game, while ’–defaults’ does.

4.15.56 reset-config-on-upgrade

Command-line option: --reset-config-on-upgrade=<value>
Environment variable: LW6_RESET_CONFIG_ON_UPGRADE
XML key: reset-config-on-upgrade

Type: boolean

Default value: true

If set, then a reset (config file set to defaults) is run every time you upgrade the game.

4.15.57 screenshots-per-min

Command-line option: --screenshots-per-min=<value>
Environment variable: LW6_SCREENSHOTS_PER_MIN
XML key: screenshots-per-min

Type: integer

Default value: 12

Defines the number of screenshots / node info per minute. This can a quite costly operation, but still it must not be too low else screenshots are too outdated.

4.15.58 server

Command-line option: --server

Start the game in server mode, without requiring any graphics backend. Server mode is usefull if you just want to start a network node without hosting any real game on it. It can be used to list existing nodes and sessions or as a bounce server in case some clients can’t contact each other because firewalled. If you only want to start a server game on your computer, don’t use this option, just start the game normally and start a game server by clicking on the GUI buttons.

4.15.59 simulate-basic

Command-line option: --simulate-basic

Simulates some fights using the basic colors red, green, yellow and blue. Will output on the console a percentage based on scores obtained by the teams. This is typically for map designers and/or people who want to fiddle with team profiles, if some team is really stronger than another one, it should appear in these percentages.

4.15.60 simulate-full

Command-line option: --simulate-full

Simulates some fights using all available colors. This can be very long, it will run approximatively 1000 games consecutively, you can look in the log file to see the progress. Will output on the console a percentage based on scores obtained by the teams. This is typically for map designers and/or people who want to fiddle with team profiles, if some team is really stronger than another one, it should appear in these percentages.

4.15.61 target-fps

Command-line option: --target-fps=<value>
Environment variable: LW6_TARGET_FPS
XML key: target-fps

Type: integer

Default value: 60 Min value: 1 Max value: 1000

Defines how many frames will be displayed per second. Of course this is a maximum value, if your hardware can’t keep up with this value, display will just be slow, no matter what value you define here. Note that you might really wish to have something rather low here, to keep network and ’logic’ function responsiveness. Passed 60 frames per second, speed is really only for visual comfort, as Liquid War 6 is now so fast-paced that it requires 200 frames/sec to outperform opponents.

4.15.62 trap-errors

Command-line option: --trap-errors=<value>
Environment variable: LW6_TRAP_ERRORS
XML key: trap-errors

Type: boolean

Default value: false

If set to true, will trap segmentation fault and floating point errors, and display messages about those in a custom box instead of the default one

4.15.63 trojan

Command-line option: --trojan=<value>
Environment variable: LW6_TROJAN
XML key: trojan

Type: boolean

Default value: false

Make the program act like a (stupid) trojan horse, trying to fake messages, sending various inconsistent informations. This is to check the normal version of the program is able to detect such a fake and kick it out of the game. It’s of no use for regular players, be sure to unset this if you want to play for good.

4.15.64 z-decode

Command-line option: --z-decode

If specified, program will take stdin and z-decode it to stdout. This is for testing purpose (for network messages for instance). Z-decoding, here means verifying there a Z at the beginning, base64 decode and pass the content through Zlib inflating. I content is not Z-prefixed, will be returned as is.

4.15.65 z-encode

Command-line option: --z-encode

If specified, program will take stdin and z-encode it to stdout. This is for testing purpose (for network messages for instance). Z-encoding, here means passing the message through Zlib deflating then base64 encoding and prefix it with a Z.


Next: , Previous: , Up: Reference   [Contents][Index]

4.16 C to Guile

4.16.1 c-gettext

C function exported to Guile: c-gettext

Calls GNU gettext to convert string in current locale. Note that ’_’ (plain underscode) is exported as well, so that code can be written using ’_’ as a function.

4.16.2 c-lw6-exit

C function exported to Guile: c-lw6-exit

Wrapper on lw6_exit.

4.16.3 c-lw6-get-ret

C function exported to Guile: c-lw6-get-ret

Wrapper on lw6_get_ret.

4.16.4 c-lw6-release

C function exported to Guile: c-lw6-release

Wrapper on lw6_release.

4.16.5 c-lw6-set-ret

C function exported to Guile: c-lw6-set-ret

Wrapper on lw6_set_ret.

4.16.6 c-lw6bot-get-backends

C function exported to Guile: c-lw6bot-get-backends

Wrapper on lw6bot_get_backends.

4.16.7 c-lw6bot-new

C function exported to Guile: c-lw6bot-new

Wrapper on lw6bot_new.

4.16.8 c-lw6bot-next-move

C function exported to Guile: c-lw6bot-next-move

Wrapper on lw6bot_next_move.

4.16.9 c-lw6cfg-defaults

C function exported to Guile: c-lw6cfg-defaults

Wrapper on lw6cfg_defaults.

4.16.10 c-lw6cfg-get-option

C function exported to Guile: c-lw6cfg-get-option

Wrapper on lw6cfg_get_option.

4.16.11 c-lw6cfg-init

C function exported to Guile: c-lw6cfg-init

Wrapper on lw6cfg_init.

4.16.12 c-lw6cfg-load

C function exported to Guile: c-lw6cfg-load

Wrapper on lw6cfg_load.

4.16.13 c-lw6cfg-option-exists

C function exported to Guile: c-lw6cfg-option-exists

Wrapper on lw6cfg_option_exists.

4.16.14 c-lw6cfg-quit

C function exported to Guile: c-lw6cfg-quit

Wrapper on lw6cfg_quit.

4.16.15 c-lw6cfg-save

C function exported to Guile: c-lw6cfg-save

Wrapper on lw6cfg_save.

4.16.16 c-lw6cfg-set-option

C function exported to Guile: c-lw6cfg-set-option

Wrapper on lw6cfg_set_option.

4.16.17 c-lw6cfg-unified-get-log-file

C function exported to Guile: c-lw6cfg-unified-get-log-file

Wrapper on lw6cfg_unified_get_log_file.

4.16.18 c-lw6cfg-unified-get-map-path

C function exported to Guile: c-lw6cfg-unified-get-map-path

Wrapper on lw6cfg_unified_get_map_path.

4.16.19 c-lw6cfg-unified-get-music-path

C function exported to Guile: c-lw6cfg-unified-get-music-path

Wrapper on lw6cfg_unified_get_music_path.

4.16.20 c-lw6cfg-unified-get-user-dir

C function exported to Guile: c-lw6cfg-unified-get-user-dir

Wrapper on lw6cfg_unified_get_user_dir.

4.16.21 c-lw6cli-get-backends

C function exported to Guile: c-lw6cli-get-backends

Wrapper on lw6cli_get_backends.

4.16.22 c-lw6cns-console-support

C function exported to Guile: c-lw6cns-console-support

Wrapper on lw6cns_console_support.

4.16.23 c-lw6cns-init

C function exported to Guile: c-lw6cns-init

Wrapper on lw6cns_init.

4.16.24 c-lw6cns-poll

C function exported to Guile: c-lw6cns-poll

Wrapper on lw6cns_poll.

4.16.25 c-lw6cns-quit

C function exported to Guile: c-lw6cns-quit

Wrapper on lw6cns_quit.

4.16.26 c-lw6cns-term-support

C function exported to Guile: c-lw6cns-term-support

Wrapper on lw6cns_term_support.

4.16.27 c-lw6dsp-get-average-fps

C function exported to Guile: c-lw6dsp-get-average-fps

Wrapper on lw6dsp_get_average_fps.

4.16.28 c-lw6dsp-get-fullscreen-modes

C function exported to Guile: c-lw6dsp-get-fullscreen-modes

Wrapper on lw6dsp_get_fullscreen_modes.

4.16.29 c-lw6dsp-get-instant-fps

C function exported to Guile: c-lw6dsp-get-instant-fps

Wrapper on lw6dsp_get_instant_fps.

4.16.30 c-lw6dsp-get-last-frame-rendering-time

C function exported to Guile: c-lw6dsp-get-last-frame-rendering-time

Wrapper on lw6dsp_get_last_frame_rendering_time.

4.16.31 c-lw6dsp-get-nb-frames

C function exported to Guile: c-lw6dsp-get-nb-frames

Wrapper on lw6dsp_get_nb_frames.

4.16.32 c-lw6dsp-get-video-mode

C function exported to Guile: c-lw6dsp-get-video-mode

Wrapper on lw6dsp_get_video_mode.

4.16.33 c-lw6dsp-new

C function exported to Guile: c-lw6dsp-new

Wrapper on lw6dsp_new.

4.16.34 c-lw6dsp-release

C function exported to Guile: c-lw6dsp-release

Wrapper on lw6dsp_release.

4.16.35 c-lw6dsp-update

C function exported to Guile: c-lw6dsp-update

Wrapper on lw6dsp_update.

4.16.36 c-lw6gen-create-from-seed

C function exported to Guile: c-lw6gen-create-from-seed

Wrapper on lw6gen_create_from_seed.

4.16.37 c-lw6gen-seed-new

C function exported to Guile: c-lw6gen-seed-new

Wrapper on lw6gen_seed_new.

4.16.38 c-lw6gen-seed-normalize

C function exported to Guile: c-lw6gen-seed-normalize

Wrapper on lw6gen_seed_normalize.

4.16.39 c-lw6gfx-get-backends

C function exported to Guile: c-lw6gfx-get-backends

Wrapper on lw6gfx_get_backends.

4.16.40 c-lw6gui-default-look

C function exported to Guile: c-lw6gui-default-look

Wrapper on lw6gui_default_look.

4.16.41 c-lw6gui-input-reset

C function exported to Guile: c-lw6gui-input-reset

Wrapper on lw6gui_input_reset.

4.16.42 c-lw6gui-joystick1-get-move-pad

C function exported to Guile: c-lw6gui-joystick1-get-move-pad

Wrapper on lw6gui_joystick1_get_move_pad.

4.16.43 c-lw6gui-joystick1-pop-button-a

C function exported to Guile: c-lw6gui-joystick1-pop-button-a

Wrapper on lw6gui_joystick1_pop_button_a.

4.16.44 c-lw6gui-joystick1-pop-button-b

C function exported to Guile: c-lw6gui-joystick1-pop-button-b

Wrapper on lw6gui_joystick1_pop_button_b.

4.16.45 c-lw6gui-joystick1-pop-button-c

C function exported to Guile: c-lw6gui-joystick1-pop-button-c

Wrapper on lw6gui_joystick1_pop_button_c.

4.16.46 c-lw6gui-joystick1-pop-button-d

C function exported to Guile: c-lw6gui-joystick1-pop-button-d

Wrapper on lw6gui_joystick1_pop_button_d.

4.16.47 c-lw6gui-joystick1-pop-button-e

C function exported to Guile: c-lw6gui-joystick1-pop-button-e

Wrapper on lw6gui_joystick1_pop_button_e.

4.16.48 c-lw6gui-joystick1-pop-button-f

C function exported to Guile: c-lw6gui-joystick1-pop-button-f

Wrapper on lw6gui_joystick1_pop_button_f.

4.16.49 c-lw6gui-joystick1-pop-pad-down

C function exported to Guile: c-lw6gui-joystick1-pop-pad-down

Wrapper on lw6gui_joystick1_pop_pad_down.

4.16.50 c-lw6gui-joystick1-pop-pad-left

C function exported to Guile: c-lw6gui-joystick1-pop-pad-left

Wrapper on lw6gui_joystick1_pop_pad_left.

4.16.51 c-lw6gui-joystick1-pop-pad-right

C function exported to Guile: c-lw6gui-joystick1-pop-pad-right

Wrapper on lw6gui_joystick1_pop_pad_right.

4.16.52 c-lw6gui-joystick1-pop-pad-up

C function exported to Guile: c-lw6gui-joystick1-pop-pad-up

Wrapper on lw6gui_joystick1_pop_pad_up.

4.16.53 c-lw6gui-joystick2-get-move-pad

C function exported to Guile: c-lw6gui-joystick2-get-move-pad

Wrapper on lw6gui_joystick2_get_move_pad.

4.16.54 c-lw6gui-joystick2-pop-button-a

C function exported to Guile: c-lw6gui-joystick2-pop-button-a

Wrapper on lw6gui_joystick2_pop_button_a.

4.16.55 c-lw6gui-joystick2-pop-button-b

C function exported to Guile: c-lw6gui-joystick2-pop-button-b

Wrapper on lw6gui_joystick2_pop_button_b.

4.16.56 c-lw6gui-joystick2-pop-button-c

C function exported to Guile: c-lw6gui-joystick2-pop-button-c

Wrapper on lw6gui_joystick2_pop_button_c.

4.16.57 c-lw6gui-joystick2-pop-button-d

C function exported to Guile: c-lw6gui-joystick2-pop-button-d

Wrapper on lw6gui_joystick2_pop_button_d.

4.16.58 c-lw6gui-joystick2-pop-button-e

C function exported to Guile: c-lw6gui-joystick2-pop-button-e

Wrapper on lw6gui_joystick2_pop_button_e.

4.16.59 c-lw6gui-joystick2-pop-button-f

C function exported to Guile: c-lw6gui-joystick2-pop-button-f

Wrapper on lw6gui_joystick2_pop_button_f.

4.16.60 c-lw6gui-joystick2-pop-pad-down

C function exported to Guile: c-lw6gui-joystick2-pop-pad-down

Wrapper on lw6gui_joystick2_pop_pad_down.

4.16.61 c-lw6gui-joystick2-pop-pad-left

C function exported to Guile: c-lw6gui-joystick2-pop-pad-left

Wrapper on lw6gui_joystick2_pop_pad_left.

4.16.62 c-lw6gui-joystick2-pop-pad-right

C function exported to Guile: c-lw6gui-joystick2-pop-pad-right

Wrapper on lw6gui_joystick2_pop_pad_right.

4.16.63 c-lw6gui-joystick2-pop-pad-up

C function exported to Guile: c-lw6gui-joystick2-pop-pad-up

Wrapper on lw6gui_joystick2_pop_pad_up.

4.16.64 c-lw6gui-keyboard-get-move-pad

C function exported to Guile: c-lw6gui-keyboard-get-move-pad

Wrapper on lw6gui_keyboard_get_move_pad.

4.16.65 c-lw6gui-keyboard-is-pressed

C function exported to Guile: c-lw6gui-keyboard-is-pressed

Wrapper on lw6gui_keyboard_is_pressed.

4.16.66 c-lw6gui-keyboard-pop-arrow-down

C function exported to Guile: c-lw6gui-keyboard-pop-arrow-down

Wrapper on lw6gui_keyboard_pop_arrow_down.

4.16.67 c-lw6gui-keyboard-pop-arrow-left

C function exported to Guile: c-lw6gui-keyboard-pop-arrow-left

Wrapper on lw6gui_keyboard_pop_arrow_left.

4.16.68 c-lw6gui-keyboard-pop-arrow-right

C function exported to Guile: c-lw6gui-keyboard-pop-arrow-right

Wrapper on lw6gui_keyboard_pop_arrow_right.

4.16.69 c-lw6gui-keyboard-pop-arrow-up

C function exported to Guile: c-lw6gui-keyboard-pop-arrow-up

Wrapper on lw6gui_keyboard_pop_arrow_up.

4.16.70 c-lw6gui-keyboard-pop-key-alt

C function exported to Guile: c-lw6gui-keyboard-pop-key-alt

Wrapper on lw6gui_keyboard_pop_key_alt.

4.16.71 c-lw6gui-keyboard-pop-key-ctrl

C function exported to Guile: c-lw6gui-keyboard-pop-key-ctrl

Wrapper on lw6gui_keyboard_pop_key_ctrl.

4.16.72 c-lw6gui-keyboard-pop-key-enter

C function exported to Guile: c-lw6gui-keyboard-pop-key-enter

Wrapper on lw6gui_keyboard_pop_key_enter.

4.16.73 c-lw6gui-keyboard-pop-key-esc

C function exported to Guile: c-lw6gui-keyboard-pop-key-esc

Wrapper on lw6gui_keyboard_pop_key_esc.

4.16.74 c-lw6gui-keyboard-pop-key-pgdown

C function exported to Guile: c-lw6gui-keyboard-pop-key-pgdown

Wrapper on lw6gui_keyboard_pop_key_pgdown.

4.16.75 c-lw6gui-keyboard-pop-key-pgup

C function exported to Guile: c-lw6gui-keyboard-pop-key-pgup

Wrapper on lw6gui_keyboard_pop_key_pgup.

4.16.76 c-lw6gui-look-get

C function exported to Guile: c-lw6gui-look-get

Wrapper on lw6gui_look_get.

4.16.77 c-lw6gui-look-set

C function exported to Guile: c-lw6gui-look-set

Wrapper on lw6gui_look_set.

4.16.78 c-lw6gui-look-zoom-in

C function exported to Guile: c-lw6gui-look-zoom-in

Wrapper on lw6gui_look_zoom_in.

4.16.79 c-lw6gui-look-zoom-out

C function exported to Guile: c-lw6gui-look-zoom-out

Wrapper on lw6gui_look_zoom_out.

4.16.80 c-lw6gui-menu-append

C function exported to Guile: c-lw6gui-menu-append

Wrapper on lw6gui_menu_append.

4.16.81 c-lw6gui-menu-close-popup

C function exported to Guile: c-lw6gui-menu-close-popup

Wrapper on lw6gui_menu_close_popup.

4.16.82 c-lw6gui-menu-enable-esc

C function exported to Guile: c-lw6gui-menu-enable-esc

Wrapper on lw6gui_menu_enable_esc.

4.16.83 c-lw6gui-menu-has-popup

C function exported to Guile: c-lw6gui-menu-has-popup

Wrapper on lw6gui_menu_has_popup.

4.16.84 c-lw6gui-menu-new

C function exported to Guile: c-lw6gui-menu-new

Wrapper on lw6gui_menu_new.

4.16.85 c-lw6gui-menu-remove

C function exported to Guile: c-lw6gui-menu-remove

Wrapper on lw6gui_menu_remove.

4.16.86 c-lw6gui-menu-remove-all

C function exported to Guile: c-lw6gui-menu-remove-all

Wrapper on lw6gui_menu_remove_all.

4.16.87 c-lw6gui-menu-scroll-down

C function exported to Guile: c-lw6gui-menu-scroll-down

Wrapper on lw6gui_menu_scroll_down.

4.16.88 c-lw6gui-menu-scroll-up

C function exported to Guile: c-lw6gui-menu-scroll-up

Wrapper on lw6gui_menu_scroll_up.

4.16.89 c-lw6gui-menu-select

C function exported to Guile: c-lw6gui-menu-select

Wrapper on lw6gui_menu_select.

4.16.90 c-lw6gui-menu-select-esc

C function exported to Guile: c-lw6gui-menu-select-esc

Wrapper on lw6gui_menu_select_esc.

4.16.91 c-lw6gui-menu-set-breadcrumbs

C function exported to Guile: c-lw6gui-menu-set-breadcrumbs

Wrapper on lw6gui_menu_set_breadcrumbs.

4.16.92 c-lw6gui-menu-sync

C function exported to Guile: c-lw6gui-menu-sync

Wrapper on lw6gui_menu_sync.

4.16.93 c-lw6gui-mouse-get-state

C function exported to Guile: c-lw6gui-mouse-get-state

Wrapper on lw6gui_mouse_get_state.

4.16.94 c-lw6gui-mouse-poll-move

C function exported to Guile: c-lw6gui-mouse-poll-move

Wrapper on lw6gui_mouse_poll_move.

4.16.95 c-lw6gui-mouse-pop-button-left

C function exported to Guile: c-lw6gui-mouse-pop-button-left

Wrapper on lw6gui_mouse_pop_button_left.

4.16.96 c-lw6gui-mouse-pop-button-middle

C function exported to Guile: c-lw6gui-mouse-pop-button-middle

Wrapper on lw6gui_mouse_pop_button_middle.

4.16.97 c-lw6gui-mouse-pop-button-right

C function exported to Guile: c-lw6gui-mouse-pop-button-right

Wrapper on lw6gui_mouse_pop_button_right.

4.16.98 c-lw6gui-mouse-pop-double-click

C function exported to Guile: c-lw6gui-mouse-pop-double-click

Wrapper on lw6gui_mouse_pop_double_click.

4.16.99 c-lw6gui-mouse-pop-simple-click

C function exported to Guile: c-lw6gui-mouse-pop-simple-click

Wrapper on lw6gui_mouse_pop_simple_click.

4.16.100 c-lw6gui-mouse-pop-triple-click

C function exported to Guile: c-lw6gui-mouse-pop-triple-click

Wrapper on lw6gui_mouse_pop_triple_click.

4.16.101 c-lw6gui-mouse-pop-wheel-down

C function exported to Guile: c-lw6gui-mouse-pop-wheel-down

Wrapper on lw6gui_mouse_pop_wheel_down.

4.16.102 c-lw6gui-mouse-pop-wheel-up

C function exported to Guile: c-lw6gui-mouse-pop-wheel-up

Wrapper on lw6gui_mouse_pop_wheel_up.

4.16.103 c-lw6hlp-about

C function exported to Guile: c-lw6hlp-about

Wrapper on lw6hlp_about.

4.16.104 c-lw6hlp-get-default-value

C function exported to Guile: c-lw6hlp-get-default-value

Wrapper on lw6hlp_get_default_value.

4.16.105 c-lw6hlp-list

C function exported to Guile: c-lw6hlp-list

Wrapper on lw6hlp_list.

4.16.106 c-lw6hlp-list-advanced

C function exported to Guile: c-lw6hlp-list-advanced

Wrapper on lw6hlp_list_advanced.

4.16.107 c-lw6hlp-list-aliases

C function exported to Guile: c-lw6hlp-list-aliases

Wrapper on lw6hlp_list_aliases.

4.16.108 c-lw6hlp-list-doc

C function exported to Guile: c-lw6hlp-list-doc

Wrapper on lw6hlp_list_doc.

4.16.109 c-lw6hlp-list-funcs

C function exported to Guile: c-lw6hlp-list-funcs

Wrapper on lw6hlp_list_funcs.

4.16.110 c-lw6hlp-list-graphics

C function exported to Guile: c-lw6hlp-list-graphics

Wrapper on lw6hlp_list_graphics.

4.16.111 c-lw6hlp-list-hooks

C function exported to Guile: c-lw6hlp-list-hooks

Wrapper on lw6hlp_list_hooks.

4.16.112 c-lw6hlp-list-input

C function exported to Guile: c-lw6hlp-list-input

Wrapper on lw6hlp_list_input.

4.16.113 c-lw6hlp-list-map

C function exported to Guile: c-lw6hlp-list-map

Wrapper on lw6hlp_list_map.

4.16.114 c-lw6hlp-list-map-hints

C function exported to Guile: c-lw6hlp-list-map-hints

Wrapper on lw6hlp_list_map_hints.

4.16.115 c-lw6hlp-list-map-rules

C function exported to Guile: c-lw6hlp-list-map-rules

Wrapper on lw6hlp_list_map_rules.

4.16.116 c-lw6hlp-list-map-style

C function exported to Guile: c-lw6hlp-list-map-style

Wrapper on lw6hlp_list_map_style.

4.16.117 c-lw6hlp-list-map-teams

C function exported to Guile: c-lw6hlp-list-map-teams

Wrapper on lw6hlp_list_map_teams.

4.16.118 c-lw6hlp-list-network

C function exported to Guile: c-lw6hlp-list-network

Wrapper on lw6hlp_list_network.

4.16.119 c-lw6hlp-list-path

C function exported to Guile: c-lw6hlp-list-path

Wrapper on lw6hlp_list_path.

4.16.120 c-lw6hlp-list-players

C function exported to Guile: c-lw6hlp-list-players

Wrapper on lw6hlp_list_players.

4.16.121 c-lw6hlp-list-quick

C function exported to Guile: c-lw6hlp-list-quick

Wrapper on lw6hlp_list_quick.

4.16.122 c-lw6hlp-list-show

C function exported to Guile: c-lw6hlp-list-show

Wrapper on lw6hlp_list_show.

4.16.123 c-lw6hlp-list-sound

C function exported to Guile: c-lw6hlp-list-sound

Wrapper on lw6hlp_list_sound.

4.16.124 c-lw6hlp-list-team-colors

C function exported to Guile: c-lw6hlp-list-team-colors

Wrapper on lw6hlp_list_team_colors.

4.16.125 c-lw6hlp-list-weapons

C function exported to Guile: c-lw6hlp-list-weapons

Wrapper on lw6hlp_list_weapons.

4.16.126 c-lw6img-screenshot

C function exported to Guile: c-lw6img-screenshot

Wrapper on lw6img_screenshot.

4.16.127 c-lw6ker-add-cursor

C function exported to Guile: c-lw6ker-add-cursor

Wrapper on lw6ker_add_cursor.

4.16.128 c-lw6ker-build-game-state

C function exported to Guile: c-lw6ker-build-game-state

Wrapper on lw6ker_build_game_state.

4.16.129 c-lw6ker-build-game-struct

C function exported to Guile: c-lw6ker-build-game-struct

Wrapper on lw6ker_build_game_struct.

4.16.130 c-lw6ker-cursor-exists

C function exported to Guile: c-lw6ker-cursor-exists

Wrapper on lw6ker_cursor_exists.

4.16.131 c-lw6ker-did-cursor-win

C function exported to Guile: c-lw6ker-did-cursor-win

Wrapper on lw6ker_did_cursor_win.

4.16.132 c-lw6ker-do-round

C function exported to Guile: c-lw6ker-do-round

Wrapper on lw6ker_do_round.

4.16.133 c-lw6ker-dup-game-state

C function exported to Guile: c-lw6ker-dup-game-state

Wrapper on lw6ker_dup_game_state.

4.16.134 c-lw6ker-game-state-checksum

C function exported to Guile: c-lw6ker-game-state-checksum

Wrapper on lw6ker_game_state_checksum.

4.16.135 c-lw6ker-game-struct-checksum

C function exported to Guile: c-lw6ker-game-struct-checksum

Wrapper on lw6ker_game_struct_checksum.

4.16.136 c-lw6ker-get-cursor

C function exported to Guile: c-lw6ker-get-cursor

Wrapper on lw6ker_get_cursor.

4.16.137 c-lw6ker-get-moves

C function exported to Guile: c-lw6ker-get-moves

Wrapper on lw6ker_get_moves.

4.16.138 c-lw6ker-get-nb-colors

C function exported to Guile: c-lw6ker-get-nb-colors

Wrapper on lw6ker_game_state_get_nb_colors.

4.16.139 c-lw6ker-get-nb-cursors

C function exported to Guile: c-lw6ker-get-nb-cursors

Wrapper on lw6ker_game_state_get_nb_cursors.

4.16.140 c-lw6ker-get-nb-nodes

C function exported to Guile: c-lw6ker-get-nb-nodes

Wrapper on lw6ker_game_state_get_nb_nodes.

4.16.141 c-lw6ker-get-rounds

C function exported to Guile: c-lw6ker-get-rounds

Wrapper on lw6ker_get_rounds.

4.16.142 c-lw6ker-get-spreads

C function exported to Guile: c-lw6ker-get-spreads

Wrapper on lw6ker_get_spreads.

4.16.143 c-lw6ker-is-over

C function exported to Guile: c-lw6ker-is-over

Wrapper on lw6ker_is_over.

4.16.144 c-lw6ker-node-exists

C function exported to Guile: c-lw6ker-node-exists

Wrapper on lw6ker_node_exists.

4.16.145 c-lw6ker-register-node

C function exported to Guile: c-lw6ker-register-node

Wrapper on lw6ker_register_node.

4.16.146 c-lw6ker-remove-cursor

C function exported to Guile: c-lw6ker-remove-cursor

Wrapper on lw6ker_remove_cursor.

4.16.147 c-lw6ker-set-cursor

C function exported to Guile: c-lw6ker-set-cursor

Wrapper on lw6ker_set_cursor.

4.16.148 c-lw6ker-sync-game-state

C function exported to Guile: c-lw6ker-sync-game-state

Wrapper on lw6ker_sync_game_state.

4.16.149 c-lw6ker-unregister-node

C function exported to Guile: c-lw6ker-unregister-node

Wrapper on lw6ker_unregister_node.

4.16.150 c-lw6ldr-chain-entry

C function exported to Guile: c-lw6ldr-chain-entry

Wrapper on lw6ldr_chain_entry.

4.16.151 c-lw6ldr-exp-validate

C function exported to Guile: c-lw6ldr-exp-validate

Wrapper on lw6ldr_exp_validate.

4.16.152 c-lw6ldr-get-entries

C function exported to Guile: c-lw6ldr-get-entries

Wrapper on lw6ldr_get_entries.

4.16.153 c-lw6ldr-hints-get-default

C function exported to Guile: c-lw6ldr-hints-get-default

Wrapper on lw6ldr_hints_get_default.

4.16.154 c-lw6ldr-print-examples

C function exported to Guile: c-lw6ldr-print-examples

Wrapper on lw6ldr_print_examples.

4.16.155 c-lw6ldr-read

C function exported to Guile: c-lw6ldr-read

Wrapper on lw6ldr_read.

4.16.156 c-lw6ldr-read-relative

C function exported to Guile: c-lw6ldr-read-relative

Wrapper on lw6ldr_read_relative.

4.16.157 c-lw6map-exp-get-unlocked-team-color

C function exported to Guile: c-lw6map-exp-get-unlocked-team-color

Wrapper on lw6map_exp_get_unlocked_team_color.

4.16.158 c-lw6map-exp-get-unlocked-weapon

C function exported to Guile: c-lw6map-exp-get-unlocked-weapon

Wrapper on lw6map_exp_get_unlocked_weapon.

4.16.159 c-lw6map-exp-is-team-color-allowed

C function exported to Guile: c-lw6map-exp-is-team-color-allowed

Wrapper on lw6map_exp_is_team_color_allowed.

4.16.160 c-lw6map-exp-is-weapon-allowed

C function exported to Guile: c-lw6map-exp-is-weapon-allowed

Wrapper on lw6map_exp_is_weapon_allowed.

4.16.161 c-lw6map-get-look

C function exported to Guile: c-lw6map-get-look

Wrapper on lw6map_get_look.

4.16.162 c-lw6map-get-max-nb-colors

C function exported to Guile: c-lw6map-get-max-nb-colors

Wrapper on lw6map_get_max_nb_colors.

4.16.163 c-lw6map-get-max-nb-cursors

C function exported to Guile: c-lw6map-get-max-nb-cursors

Wrapper on lw6map_get_max_nb_cursors.

4.16.164 c-lw6map-get-max-nb-nodes

C function exported to Guile: c-lw6map-get-max-nb-nodes

Wrapper on lw6map_get_max_nb_nodes.

4.16.165 c-lw6map-get-music-dir

C function exported to Guile: c-lw6map-get-music-dir

Wrapper on lw6map_get_music_dir.

4.16.166 c-lw6map-get-title

C function exported to Guile: c-lw6map-get-title

Wrapper on lw6map_get_title.

4.16.167 c-lw6map-param-get

C function exported to Guile: c-lw6map-param-get

Wrapper on lw6map_param_get.

4.16.168 c-lw6map-rules-get-default

C function exported to Guile: c-lw6map-rules-get-default

Wrapper on lw6map_rules_get_default.

4.16.169 c-lw6map-rules-get-int

C function exported to Guile: c-lw6map-rules-get-int

Wrapper on lw6map_rules_get_int.

4.16.170 c-lw6map-rules-get-max

C function exported to Guile: c-lw6map-rules-get-max

Wrapper on lw6map_rules_get_max.

4.16.171 c-lw6map-rules-get-min

C function exported to Guile: c-lw6map-rules-get-min

Wrapper on lw6map_rules_get_min.

4.16.172 c-lw6map-style-get-default

C function exported to Guile: c-lw6map-style-get-default

Wrapper on lw6map_style_get_default.

4.16.173 c-lw6map-team-color-index-to-key

C function exported to Guile: c-lw6map-team-color-index-to-key

Wrapper on lw6map_team_color_index_to_key.

4.16.174 c-lw6map-team-color-index-to-label

C function exported to Guile: c-lw6map-team-color-index-to-label

Wrapper on lw6map_team_color_index_to_label.

4.16.175 c-lw6map-team-color-key-to-index

C function exported to Guile: c-lw6map-team-color-key-to-index

Wrapper on lw6map_team_color_key_to_index.

4.16.176 c-lw6map-team-color-list

C function exported to Guile: c-lw6map-team-color-list

Wrapper on lw6map_team_color_list.

4.16.177 c-lw6map-teams-get-default

C function exported to Guile: c-lw6map-teams-get-default

Wrapper on lw6map_teams_get_default.

4.16.178 c-lw6map-weapon-index-to-key

C function exported to Guile: c-lw6map-weapon-index-to-key

Wrapper on lw6map_weapon_index_to_key.

4.16.179 c-lw6map-weapon-index-to-label

C function exported to Guile: c-lw6map-weapon-index-to-label

Wrapper on lw6map_weapon_index_to_label.

4.16.180 c-lw6map-weapon-key-to-index

C function exported to Guile: c-lw6map-weapon-key-to-index

Wrapper on lw6map_weapon_key_to_index.

4.16.181 c-lw6map-weapon-list

C function exported to Guile: c-lw6map-weapon-list

Wrapper on lw6map_weapon_list.

4.16.182 c-lw6net-init

C function exported to Guile: c-lw6net-init

Wrapper on lw6net_init.

4.16.183 c-lw6net-quit

C function exported to Guile: c-lw6net-quit

Wrapper on lw6net_quit.

4.16.184 c-lw6p2p-db-default-name

C function exported to Guile: c-lw6p2p-db-default-name

Wrapper on lw6p2p_db_default_name.

4.16.185 c-lw6p2p-db-new

C function exported to Guile: c-lw6p2p-db-new

Wrapper on lw6p2p_db_new.

4.16.186 c-lw6p2p-db-reset

C function exported to Guile: c-lw6p2p-db-reset

Wrapper on lw6p2p_db_reset.

4.16.187 c-lw6p2p-node-calibrate

C function exported to Guile: c-lw6p2p-node-calibrate

Wrapper on lw6p2p_node_calibrate.

4.16.188 c-lw6p2p-node-client-join

C function exported to Guile: c-lw6p2p-node-client-join

Wrapper on lw6p2p_node_client_join.

4.16.189 c-lw6p2p-node-close

C function exported to Guile: c-lw6p2p-node-close

Wrapper on lw6p2p_node_close.

4.16.190 c-lw6p2p-node-disconnect

C function exported to Guile: c-lw6p2p-node-disconnect

Wrapper on lw6p2p_node_disconnect.

4.16.191 c-lw6p2p-node-get-entries

C function exported to Guile: c-lw6p2p-node-get-entries

Wrapper on lw6p2p_node_get_entries.

4.16.192 c-lw6p2p-node-get-id

C function exported to Guile: c-lw6p2p-node-get-id

Wrapper on lw6p2p_node_get_id.

4.16.193 c-lw6p2p-node-get-local-seq-0

C function exported to Guile: c-lw6p2p-node-get-local-seq-0

Wrapper on lw6p2p_node_get_local_seq_0.

4.16.194 c-lw6p2p-node-get-local-seq-last

C function exported to Guile: c-lw6p2p-node-get-local-seq-last

Wrapper on lw6p2p_node_get_local_seq_last.

4.16.195 c-lw6p2p-node-get-next-draft-msg

C function exported to Guile: c-lw6p2p-node-get-next-draft-msg

Wrapper on lw6p2p_node_get_next_draft_msg.

4.16.196 c-lw6p2p-node-get-next-reference-msg

C function exported to Guile: c-lw6p2p-node-get-next-reference-msg

Wrapper on lw6p2p_node_get_next_reference_msg.

4.16.197 c-lw6p2p-node-get-seq-draft

C function exported to Guile: c-lw6p2p-node-get-seq-draft

Wrapper on lw6p2p_node_get_seq_draft.

4.16.198 c-lw6p2p-node-get-seq-max

C function exported to Guile: c-lw6p2p-node-get-seq-max

Wrapper on lw6p2p_node_get_seq_max.

4.16.199 c-lw6p2p-node-get-seq-min

C function exported to Guile: c-lw6p2p-node-get-seq-min

Wrapper on lw6p2p_node_get_seq_min.

4.16.200 c-lw6p2p-node-get-seq-reference

C function exported to Guile: c-lw6p2p-node-get-seq-reference

Wrapper on lw6p2p_node_get_seq_reference.

4.16.201 c-lw6p2p-node-is-dump-needed

C function exported to Guile: c-lw6p2p-node-is-dump-needed

Wrapper on lw6p2p_node_is_dump_needed.

4.16.202 c-lw6p2p-node-is-peer-connected

C function exported to Guile: c-lw6p2p-node-is-peer-connected

Wrapper on lw6p2p_node_is_peer_connected.

4.16.203 c-lw6p2p-node-is-peer-registered

C function exported to Guile: c-lw6p2p-node-is-peer-registered

Wrapper on lw6p2p_node_is_peer_registered.

4.16.204 c-lw6p2p-node-is-seed-needed

C function exported to Guile: c-lw6p2p-node-is-seed-needed

Wrapper on lw6p2p_node_is_seed_needed.

4.16.205 c-lw6p2p-node-new

C function exported to Guile: c-lw6p2p-node-new

Wrapper on lw6p2p_node_new.

4.16.206 c-lw6p2p-node-poll

C function exported to Guile: c-lw6p2p-node-poll

Wrapper on lw6p2p_node_poll.

4.16.207 c-lw6p2p-node-put-local-msg

C function exported to Guile: c-lw6p2p-node-put-local-msg

Wrapper on lw6p2p_node_put_local_msg.

4.16.208 c-lw6p2p-node-refresh-peer

C function exported to Guile: c-lw6p2p-node-refresh-peer

Wrapper on lw6p2p_node_refresh_peer.

4.16.209 c-lw6p2p-node-server-start

C function exported to Guile: c-lw6p2p-node-server-start

Wrapper on lw6p2p_node_server_start.

4.16.210 c-lw6p2p-node-update-info

C function exported to Guile: c-lw6p2p-node-update-info

Wrapper on lw6p2p_node_update_info.

4.16.211 c-lw6pil-bench

C function exported to Guile: c-lw6pil-bench

Wrapper on lw6pil_bench.

4.16.212 c-lw6pil-build-pilot

C function exported to Guile: c-lw6pil-build-pilot

Wrapper on lw6pil_build_pilot.

4.16.213 c-lw6pil-calibrate

C function exported to Guile: c-lw6pil-calibrate

Wrapper on lw6pil_calibrate.

4.16.214 c-lw6pil-commit

C function exported to Guile: c-lw6pil-commit

Wrapper on lw6pil_commit.

4.16.215 c-lw6pil-did-cursor-win

C function exported to Guile: c-lw6pil-did-cursor-win

Wrapper on lw6pil_did_cursor_win.

4.16.216 c-lw6pil-dump-command-generate

C function exported to Guile: c-lw6pil-dump-command-generate

Wrapper on lw6pil_dump_command_generate.

4.16.217 c-lw6pil-execute-command

C function exported to Guile: c-lw6pil-execute-command

Wrapper on lw6pil_execute_command.

4.16.218 c-lw6pil-fix-coords

C function exported to Guile: c-lw6pil-fix-coords

Wrapper on lw6pil_coords_fix.

4.16.219 c-lw6pil-fix-coords-x10

C function exported to Guile: c-lw6pil-fix-coords-x10

Wrapper on lw6pil_coords_fix_x10.

4.16.220 c-lw6pil-get-last-commit-seq

C function exported to Guile: c-lw6pil-get-last-commit-seq

Wrapper on lw6pil_get_last_commit_seq.

4.16.221 c-lw6pil-get-looser

C function exported to Guile: c-lw6pil-get-looser

Wrapper on lw6pil_get_looser.

4.16.222 c-lw6pil-get-max-seq

C function exported to Guile: c-lw6pil-get-max-seq

Wrapper on lw6pil_get_max_seq.

4.16.223 c-lw6pil-get-next-seq

C function exported to Guile: c-lw6pil-get-next-seq

Wrapper on lw6pil_get_next_seq.

4.16.224 c-lw6pil-get-reference-current-seq

C function exported to Guile: c-lw6pil-get-reference-current-seq

Wrapper on lw6pil_get_reference_current_seq.

4.16.225 c-lw6pil-get-reference-target-seq

C function exported to Guile: c-lw6pil-get-reference-target-seq

Wrapper on lw6pil_get_reference_target_seq.

4.16.226 c-lw6pil-get-round-0

C function exported to Guile: c-lw6pil-get-round-0

Wrapper on lw6pil_get_round_0.

4.16.227 c-lw6pil-get-seq-0

C function exported to Guile: c-lw6pil-get-seq-0

Wrapper on lw6pil_get_seq_0.

4.16.228 c-lw6pil-get-winner

C function exported to Guile: c-lw6pil-get-winner

Wrapper on lw6pil_get_winner.

4.16.229 c-lw6pil-is-over

C function exported to Guile: c-lw6pil-is-over

Wrapper on lw6pil_is_over.

4.16.230 c-lw6pil-local-command

C function exported to Guile: c-lw6pil-local-command

Wrapper on lw6pil_local_command.

4.16.231 c-lw6pil-local-cursors-set-main

C function exported to Guile: c-lw6pil-local-cursors-set-main

Wrapper on lw6pil_local_cursors_set_main.

4.16.232 c-lw6pil-local-cursors-set-mouse-controlled

C function exported to Guile: c-lw6pil-local-cursors-set-mouse-controlled

Wrapper on lw6pil_local_cursors_set_mouse_controlled.

4.16.233 c-lw6pil-make-backup

C function exported to Guile: c-lw6pil-make-backup

Wrapper on lw6pil_make_backup.

4.16.234 c-lw6pil-poll-dump

C function exported to Guile: c-lw6pil-poll-dump

Wrapper on lw6pil_poll_dump.

4.16.235 c-lw6pil-round2seq

C function exported to Guile: c-lw6pil-round2seq

Wrapper on lw6pil_round2seq.

4.16.236 c-lw6pil-seed-command-generate

C function exported to Guile: c-lw6pil-seed-command-generate

Wrapper on lw6pil_seed_command_generate.

4.16.237 c-lw6pil-send-command

C function exported to Guile: c-lw6pil-send-command

Wrapper on lw6pil_send_command.

4.16.238 c-lw6pil-seq-random-0

C function exported to Guile: c-lw6pil-seq-random-0

Wrapper on lw6pil_seq_random_0.

4.16.239 c-lw6pil-seq2round

C function exported to Guile: c-lw6pil-seq2round

Wrapper on lw6pil_seq2round.

4.16.240 c-lw6pil-slow-down

C function exported to Guile: c-lw6pil-slow-down

Wrapper on lw6pil_slow_down.

4.16.241 c-lw6pil-speed-up

C function exported to Guile: c-lw6pil-speed-up

Wrapper on lw6pil_speed_up.

4.16.242 c-lw6pil-suite-get-checkpoint

C function exported to Guile: c-lw6pil-suite-get-checkpoint

Wrapper on lw6pil_suite_get_checkpoint.

4.16.243 c-lw6pil-suite-get-commands-by-node-index

C function exported to Guile: c-lw6pil-suite-get-commands-by-node-index

Wrapper on lw6pil_suite_get_command_by_node_index, returns the list of all steps.

4.16.244 c-lw6pil-suite-get-commands-by-stage

C function exported to Guile: c-lw6pil-suite-get-commands-by-stage

Wrapper on lw6pil_suite_get_command_by_stage, returns the list of all steps.

4.16.245 c-lw6pil-suite-get-node-id

C function exported to Guile: c-lw6pil-suite-get-node-id

Wrapper on lw6pil_suite_get_node_id.

4.16.246 c-lw6pil-suite-get-seq-0

C function exported to Guile: c-lw6pil-suite-get-seq-0

Wrapper on lw6pil_suite_get_seq_0.

4.16.247 c-lw6pil-suite-init

C function exported to Guile: c-lw6pil-suite-init

Wrapper on lw6pil_suite_init.

4.16.248 c-lw6pil-sync-from-backup

C function exported to Guile: c-lw6pil-sync-from-backup

Wrapper on lw6pil_sync_from_backup.

4.16.249 c-lw6pil-sync-from-draft

C function exported to Guile: c-lw6pil-sync-from-draft

Wrapper on lw6pil_sync_from_draft.

4.16.250 c-lw6pil-sync-from-reference

C function exported to Guile: c-lw6pil-sync-from-reference

Wrapper on lw6pil_sync_from_reference.

4.16.251 c-lw6snd-get-backends

C function exported to Guile: c-lw6snd-get-backends

Wrapper on lw6snd_get_backends.

4.16.252 c-lw6snd-is-music-file

C function exported to Guile: c-lw6snd-is-music-file

Wrapper on lw6snd_is_music_file.

4.16.253 c-lw6snd-new

C function exported to Guile: c-lw6snd-new

Wrapper on lw6snd_new.

4.16.254 c-lw6snd-play-fx

C function exported to Guile: c-lw6snd-play-fx

Wrapper on lw6snd_play_fx.

4.16.255 c-lw6snd-play-music-file

C function exported to Guile: c-lw6snd-play-music-file

Wrapper on lw6snd_play_music_file.

4.16.256 c-lw6snd-play-music-random

C function exported to Guile: c-lw6snd-play-music-random

Wrapper on lw6snd_play_music_random.

4.16.257 c-lw6snd-poll

C function exported to Guile: c-lw6snd-poll

Wrapper on lw6snd_poll.

4.16.258 c-lw6snd-release

C function exported to Guile: c-lw6snd-release

Wrapper on lw6snd_release.

4.16.259 c-lw6snd-set-fx-volume

C function exported to Guile: c-lw6snd-set-fx-volume

Wrapper on lw6snd_set_fx_volume.

4.16.260 c-lw6snd-set-music-volume

C function exported to Guile: c-lw6snd-set-music-volume

Wrapper on lw6snd_set_music_volume.

4.16.261 c-lw6snd-set-water-volume

C function exported to Guile: c-lw6snd-set-water-volume

Wrapper on lw6snd_set_water_volume.

4.16.262 c-lw6snd-stop-music

C function exported to Guile: c-lw6snd-stop-music

Wrapper on lw6snd_stop_music.

4.16.263 c-lw6srv-get-backends

C function exported to Guile: c-lw6srv-get-backends

Wrapper on lw6srv_get_backends.

4.16.264 c-lw6sys-build-get-abs-srcdir

C function exported to Guile: c-lw6sys-build-get-abs-srcdir

Wrapper on lw6sys_build_get_abs_srcdir.

4.16.265 c-lw6sys-build-get-bin-id

C function exported to Guile: c-lw6sys-build-get-bin-id

Wrapper on lw6sys_build_get_bin_id.

4.16.266 c-lw6sys-build-get-bugs-url

C function exported to Guile: c-lw6sys-build-get-bugs-url

Wrapper on lw6sys_build_get_bugs_url.

4.16.267 c-lw6sys-build-get-cflags

C function exported to Guile: c-lw6sys-build-get-cflags

Wrapper on lw6sys_build_get_cflags.

4.16.268 c-lw6sys-build-get-codename

C function exported to Guile: c-lw6sys-build-get-codename

Wrapper on lw6sys_build_get_codename.

4.16.269 c-lw6sys-build-get-configure-args

C function exported to Guile: c-lw6sys-build-get-configure-args

Wrapper on lw6sys_build_get_configure_args.

4.16.270 c-lw6sys-build-get-copyright

C function exported to Guile: c-lw6sys-build-get-copyright

Wrapper on lw6sys_build_get_copyright.

4.16.271 c-lw6sys-build-get-datadir

C function exported to Guile: c-lw6sys-build-get-datadir

Wrapper on lw6sys_build_get_datadir.

4.16.272 c-lw6sys-build-get-date

C function exported to Guile: c-lw6sys-build-get-date

Wrapper on lw6sys_build_get_date.

4.16.273 c-lw6sys-build-get-docdir

C function exported to Guile: c-lw6sys-build-get-docdir

Wrapper on lw6sys_build_get_docdir.

4.16.274 c-lw6sys-build-get-enable-allinone

C function exported to Guile: c-lw6sys-build-get-enable-allinone

Wrapper on lw6sys_build_get_enable_allinone.

4.16.275 c-lw6sys-build-get-enable-console

C function exported to Guile: c-lw6sys-build-get-enable-console

Wrapper on lw6sys_build_get_enable_console.

4.16.276 c-lw6sys-build-get-enable-fullstatic

C function exported to Guile: c-lw6sys-build-get-enable-fullstatic

Wrapper on lw6sys_build_get_enable_fullstatic.

4.16.277 c-lw6sys-build-get-enable-gcov

C function exported to Guile: c-lw6sys-build-get-enable-gcov

Wrapper on lw6sys_build_get_enable_gcov.

4.16.278 c-lw6sys-build-get-enable-gprof

C function exported to Guile: c-lw6sys-build-get-enable-gprof

Wrapper on lw6sys_build_get_enable_gprof.

4.16.279 c-lw6sys-build-get-enable-gtk

C function exported to Guile: c-lw6sys-build-get-enable-gtk

Wrapper on lw6sys_build_get_enable_gtk.

4.16.280 c-lw6sys-build-get-enable-instrument

C function exported to Guile: c-lw6sys-build-get-enable-instrument

Wrapper on lw6sys_build_get_enable_instrument.

4.16.281 c-lw6sys-build-get-enable-mod-caca

C function exported to Guile: c-lw6sys-build-get-enable-mod-caca

Wrapper on lw6sys_build_get_enable_mod_caca.

4.16.282 c-lw6sys-build-get-enable-mod-csound

C function exported to Guile: c-lw6sys-build-get-enable-mod-csound

Wrapper on lw6sys_build_get_enable_mod_csound.

4.16.283 c-lw6sys-build-get-enable-mod-gl1

C function exported to Guile: c-lw6sys-build-get-enable-mod-gl1

Wrapper on lw6sys_build_get_enable_mod_gl1.

4.16.284 c-lw6sys-build-get-enable-mod-gles2

C function exported to Guile: c-lw6sys-build-get-enable-mod-gles2

Wrapper on lw6sys_build_get_enable_mod_gles2.

4.16.285 c-lw6sys-build-get-enable-mod-http

C function exported to Guile: c-lw6sys-build-get-enable-mod-http

Wrapper on lw6sys_build_get_enable_mod_http.

4.16.286 c-lw6sys-build-get-enable-mod-ogg

C function exported to Guile: c-lw6sys-build-get-enable-mod-ogg

Wrapper on lw6sys_build_get_enable_mod_ogg.

4.16.287 c-lw6sys-build-get-enable-mod-soft

C function exported to Guile: c-lw6sys-build-get-enable-mod-soft

Wrapper on lw6sys_build_get_enable_mod_soft.

4.16.288 c-lw6sys-build-get-enable-openmp

C function exported to Guile: c-lw6sys-build-get-enable-openmp

Wrapper on lw6sys_build_get_enable_openmp.

4.16.289 c-lw6sys-build-get-enable-optimize

C function exported to Guile: c-lw6sys-build-get-enable-optimize

Wrapper on lw6sys_build_get_enable_optimize.

4.16.290 c-lw6sys-build-get-enable-paranoid

C function exported to Guile: c-lw6sys-build-get-enable-paranoid

Wrapper on lw6sys_build_get_enable_paranoid.

4.16.291 c-lw6sys-build-get-enable-profiler

C function exported to Guile: c-lw6sys-build-get-enable-profiler

Wrapper on lw6sys_build_get_enable_profiler.

4.16.292 c-lw6sys-build-get-enable-valgrind

C function exported to Guile: c-lw6sys-build-get-enable-valgrind

Wrapper on lw6sys_build_get_enable_valgrind.

4.16.293 c-lw6sys-build-get-endianness

C function exported to Guile: c-lw6sys-build-get-endianness

Wrapper on lw6sys_build_get_endianness.

4.16.294 c-lw6sys-build-get-gcc-version

C function exported to Guile: c-lw6sys-build-get-gcc-version

Wrapper on lw6sys_build_get_gcc_version.

4.16.295 c-lw6sys-build-get-home-url

C function exported to Guile: c-lw6sys-build-get-home-url

Wrapper on lw6sys_build_get_home_url.

4.16.296 c-lw6sys-build-get-host-cpu

C function exported to Guile: c-lw6sys-build-get-host-cpu

Wrapper on lw6sys_build_get_host_cpu.

4.16.297 c-lw6sys-build-get-host-os

C function exported to Guile: c-lw6sys-build-get-host-os

Wrapper on lw6sys_build_get_host_os.

4.16.298 c-lw6sys-build-get-hostname

C function exported to Guile: c-lw6sys-build-get-hostname

Wrapper on lw6sys_build_get_hostname.

4.16.299 c-lw6sys-build-get-includedir

C function exported to Guile: c-lw6sys-build-get-includedir

Wrapper on lw6sys_build_get_includedir.

4.16.300 c-lw6sys-build-get-ldflags

C function exported to Guile: c-lw6sys-build-get-ldflags

Wrapper on lw6sys_build_get_ldflags.

4.16.301 c-lw6sys-build-get-libdir

C function exported to Guile: c-lw6sys-build-get-libdir

Wrapper on lw6sys_build_get_libdir.

4.16.302 c-lw6sys-build-get-license

C function exported to Guile: c-lw6sys-build-get-license

Wrapper on lw6sys_build_get_license.

4.16.303 c-lw6sys-build-get-localedir

C function exported to Guile: c-lw6sys-build-get-localedir

Wrapper on lw6sys_build_get_localedir.

4.16.304 c-lw6sys-build-get-md5sum

C function exported to Guile: c-lw6sys-build-get-md5sum

Wrapper on lw6sys_build_get_md5sum.

4.16.305 c-lw6sys-build-get-package-id

C function exported to Guile: c-lw6sys-build-get-package-id

Wrapper on lw6sys_build_get_package_id.

4.16.306 c-lw6sys-build-get-package-name

C function exported to Guile: c-lw6sys-build-get-package-name

Wrapper on lw6sys_build_get_package_name.

4.16.307 c-lw6sys-build-get-package-string

C function exported to Guile: c-lw6sys-build-get-package-string

Wrapper on lw6sys_build_get_package_string.

4.16.308 c-lw6sys-build-get-package-tarname

C function exported to Guile: c-lw6sys-build-get-package-tarname

Wrapper on lw6sys_build_get_package_tarname.

4.16.309 c-lw6sys-build-get-pointer-size

C function exported to Guile: c-lw6sys-build-get-pointer-size

Wrapper on lw6sys_build_get_pointer_size.

4.16.310 c-lw6sys-build-get-prefix

C function exported to Guile: c-lw6sys-build-get-prefix

Wrapper on lw6sys_build_get_prefix.

4.16.311 c-lw6sys-build-get-stamp

C function exported to Guile: c-lw6sys-build-get-stamp

Wrapper on lw6sys_build_get_stamp.

4.16.312 c-lw6sys-build-get-time

C function exported to Guile: c-lw6sys-build-get-time

Wrapper on lw6sys_build_get_time.

4.16.313 c-lw6sys-build-get-top-srcdir

C function exported to Guile: c-lw6sys-build-get-top-srcdir

Wrapper on lw6sys_build_get_top_srcdir.

4.16.314 c-lw6sys-build-get-version

C function exported to Guile: c-lw6sys-build-get-version

Wrapper on lw6sys_build_get_version.

4.16.315 c-lw6sys-build-get-version-base

C function exported to Guile: c-lw6sys-build-get-version-base

Wrapper on lw6sys_build_get_version_base.

4.16.316 c-lw6sys-build-get-version-major

C function exported to Guile: c-lw6sys-build-get-version-major

Wrapper on lw6sys_build_get_version_major.

4.16.317 c-lw6sys-build-get-version-minor

C function exported to Guile: c-lw6sys-build-get-version-minor

Wrapper on lw6sys_build_get_version_minor.

4.16.318 c-lw6sys-build-is-gnu

C function exported to Guile: c-lw6sys-build-is-gnu

Wrapper on lw6sys_build_is_gnu.

4.16.319 c-lw6sys-build-is-gp2x

C function exported to Guile: c-lw6sys-build-is-gp2x

Wrapper on lw6sys_build_is_gp2x.

4.16.320 c-lw6sys-build-is-mac-os-x

C function exported to Guile: c-lw6sys-build-is-mac-os-x

Wrapper on lw6sys_build_is_mac_os_x.

4.16.321 c-lw6sys-build-is-ms-windows

C function exported to Guile: c-lw6sys-build-is-ms-windows

Wrapper on lw6sys_build_is_ms_windows.

4.16.322 c-lw6sys-build-is-unix

C function exported to Guile: c-lw6sys-build-is-unix

Wrapper on lw6sys_build_is_unix.

4.16.323 c-lw6sys-build-is-x86

C function exported to Guile: c-lw6sys-build-is-x86

Wrapper on lw6sys_build_is_x86.

4.16.324 c-lw6sys-debug-get

C function exported to Guile: c-lw6sys-debug-get

Wrapper on lw6sys_debug_get.

4.16.325 c-lw6sys-debug-set

C function exported to Guile: c-lw6sys-debug-set

Wrapper on lw6sys_debug_set.

4.16.326 c-lw6sys-delay

C function exported to Guile: c-lw6sys-delay

Wrapper on lw6sys_delay.

4.16.327 c-lw6sys-dump

C function exported to Guile: c-lw6sys-dump

Wrapper on lw6sys_dump.

4.16.328 c-lw6sys-dump-clear

C function exported to Guile: c-lw6sys-dump-clear

Wrapper on lw6sys_dump_clear.

4.16.329 c-lw6sys-generate-id-16

C function exported to Guile: c-lw6sys-generate-id-16

Wrapper on lw6sys_generate_id_16.

4.16.330 c-lw6sys-generate-id-32

C function exported to Guile: c-lw6sys-generate-id-32

Wrapper on lw6sys_generate_id_32.

4.16.331 c-lw6sys-generate-id-64

C function exported to Guile: c-lw6sys-generate-id-64

Wrapper on lw6sys_generate_id_64.

4.16.332 c-lw6sys-get-config-file

C function exported to Guile: c-lw6sys-get-config-file

Wrapper on lw6sys_get_config_file.

4.16.333 c-lw6sys-get-cwd

C function exported to Guile: c-lw6sys-get-cwd

Wrapper on lw6sys_get_cwd.

4.16.334 c-lw6sys-get-cycle

C function exported to Guile: c-lw6sys-get-cycle

Wrapper on lw6sys_get_cycle.

4.16.335 c-lw6sys-get-data-dir

C function exported to Guile: c-lw6sys-get-data-dir

Wrapper on lw6sys_get_data_dir.

4.16.336 c-lw6sys-get-default-config-file

C function exported to Guile: c-lw6sys-get-default-config-file

Wrapper on lw6sys_get_default_config_file.

4.16.337 c-lw6sys-get-default-data-dir

C function exported to Guile: c-lw6sys-get-default-data-dir

Wrapper on lw6sys_get_default_data_dir.

4.16.338 c-lw6sys-get-default-log-file

C function exported to Guile: c-lw6sys-get-default-log-file

Wrapper on lw6sys_get_default_log_file.

4.16.339 c-lw6sys-get-default-map-dir

C function exported to Guile: c-lw6sys-get-default-map-dir

Wrapper on lw6sys_get_default_map_dir.

4.16.340 c-lw6sys-get-default-map-path

C function exported to Guile: c-lw6sys-get-default-map-path

Wrapper on lw6sys_get_default_map_path.

4.16.341 c-lw6sys-get-default-mod-dir

C function exported to Guile: c-lw6sys-get-default-mod-dir

Wrapper on lw6sys_get_default_mod_dir.

4.16.342 c-lw6sys-get-default-music-dir

C function exported to Guile: c-lw6sys-get-default-music-dir

Wrapper on lw6sys_get_default_music_dir.

4.16.343 c-lw6sys-get-default-music-path

C function exported to Guile: c-lw6sys-get-default-music-path

Wrapper on lw6sys_get_default_music_path.

4.16.344 c-lw6sys-get-default-prefix

C function exported to Guile: c-lw6sys-get-default-prefix

Wrapper on lw6sys_get_default_prefix.

4.16.345 c-lw6sys-get-default-script-file

C function exported to Guile: c-lw6sys-get-default-script-file

Wrapper on lw6sys_get_default_script_file.

4.16.346 c-lw6sys-get-default-user-dir

C function exported to Guile: c-lw6sys-get-default-user-dir

Wrapper on lw6sys_get_default_user_dir.

4.16.347 c-lw6sys-get-hostname

C function exported to Guile: c-lw6sys-get-hostname

Wrapper on lw6sys_get_hostname.

4.16.348 c-lw6sys-get-log-file

C function exported to Guile: c-lw6sys-get-log-file

Wrapper on lw6sys_get_log_file.

4.16.349 c-lw6sys-get-map-dir

C function exported to Guile: c-lw6sys-get-map-dir

Wrapper on lw6sys_get_map_dir.

4.16.350 c-lw6sys-get-map-path

C function exported to Guile: c-lw6sys-get-map-path

Wrapper on lw6sys_get_map_path.

4.16.351 c-lw6sys-get-memory-bazooka-eraser

C function exported to Guile: c-lw6sys-get-memory-bazooka-eraser

Wrapper on lw6sys_get_memory_bazooka_eraser.

4.16.352 c-lw6sys-get-memory-bazooka-size

C function exported to Guile: c-lw6sys-get-memory-bazooka-size

Wrapper on lw6sys_get_memory_bazooka_size.

4.16.353 c-lw6sys-get-mod-dir

C function exported to Guile: c-lw6sys-get-mod-dir

Wrapper on lw6sys_get_mod_dir.

4.16.354 c-lw6sys-get-music-dir

C function exported to Guile: c-lw6sys-get-music-dir

Wrapper on lw6sys_get_music_dir.

4.16.355 c-lw6sys-get-music-path

C function exported to Guile: c-lw6sys-get-music-path

Wrapper on lw6sys_get_music_path.

4.16.356 c-lw6sys-get-prefix

C function exported to Guile: c-lw6sys-get-prefix

Wrapper on lw6sys_get_prefix.

4.16.357 c-lw6sys-get-run-dir

C function exported to Guile: c-lw6sys-get-run-dir

Wrapper on lw6sys_get_run_dir.

4.16.358 c-lw6sys-get-script-file

C function exported to Guile: c-lw6sys-get-script-file

Wrapper on lw6sys_get_script_file.

4.16.359 c-lw6sys-get-timestamp

C function exported to Guile: c-lw6sys-get-timestamp

Wrapper on lw6sys_get_timestamp.

4.16.360 c-lw6sys-get-uptime

C function exported to Guile: c-lw6sys-get-uptime

Wrapper on lw6sys_get_uptime.

4.16.361 c-lw6sys-get-user-dir

C function exported to Guile: c-lw6sys-get-user-dir

Wrapper on lw6sys_get_user_dir.

4.16.362 c-lw6sys-get-username

C function exported to Guile: c-lw6sys-get-username

Wrapper on lw6sys_get_username.

4.16.363 c-lw6sys-getenv

C function exported to Guile: c-lw6sys-getenv

Wrapper on lw6sys_getenv.

4.16.364 c-lw6sys-getenv-prefixed

C function exported to Guile: c-lw6sys-getenv-prefixed

Wrapper on lw6sys_getenv_prefixed.

4.16.365 c-lw6sys-idle

C function exported to Guile: c-lw6sys-idle

Wrapper on lw6sys_idle.

4.16.366 c-lw6sys-log

C function exported to Guile: c-lw6sys-log

Wrapper on lw6sys_log.

4.16.367 c-lw6sys-log-get-level

C function exported to Guile: c-lw6sys-log-get-level

Wrapper on lw6sys_log_get_level.

4.16.368 c-lw6sys-log-set-dialog-timeout

C function exported to Guile: c-lw6sys-log-set-dialog-timeout

Wrapper on lw6sys_log_set_dialog_timeout.

4.16.369 c-lw6sys-log-set-level

C function exported to Guile: c-lw6sys-log-set-level

Wrapper on lw6sys_log_set_level.

4.16.370 c-lw6sys-megabytes-available

C function exported to Guile: c-lw6sys-megabytes-available

Wrapper on lw6sys_megabytes_available.

4.16.371 c-lw6sys-openmp-get-num-procs

C function exported to Guile: c-lw6sys-openmp-get-num-procs

Wrapper on lw6sys_openmp_get_num_procs.

4.16.372 c-lw6sys-path-concat

C function exported to Guile: c-lw6sys-path-concat

Wrapper on lw6sys_path_concat.

4.16.373 c-lw6sys-path-file-only

C function exported to Guile: c-lw6sys-path-file-only

Wrapper on lw6sys_path_file_only.

4.16.374 c-lw6sys-path-parent

C function exported to Guile: c-lw6sys-path-parent

Wrapper on lw6sys_path_parent.

4.16.375 c-lw6sys-path-split

C function exported to Guile: c-lw6sys-path-split

Wrapper on lw6sys_path_split.

4.16.376 c-lw6sys-set-memory-bazooka-eraser

C function exported to Guile: c-lw6sys-set-memory-bazooka-eraser

Wrapper on lw6sys_set_memory_bazooka_eraser.

4.16.377 c-lw6sys-set-memory-bazooka-size

C function exported to Guile: c-lw6sys-set-memory-bazooka-size

Wrapper on lw6sys_set_memory_bazooka_size.

4.16.378 c-lw6sys-signal-custom

C function exported to Guile: c-lw6sys-signal-custom

Wrapper on lw6sys_signal_custom.

4.16.379 c-lw6sys-signal-default

C function exported to Guile: c-lw6sys-signal-default

Wrapper on lw6sys_signal_default.

4.16.380 c-lw6sys-signal-poll-quit

C function exported to Guile: c-lw6sys-signal-poll-quit

Wrapper on lw6sys_signal_poll_quit.

4.16.381 c-lw6sys-signal-send-quit

C function exported to Guile: c-lw6sys-signal-send-quit

Wrapper on lw6sys_signal_send_quit.

4.16.382 c-lw6sys-sleep

C function exported to Guile: c-lw6sys-sleep

Wrapper on lw6sys_sleep.

4.16.383 c-lw6sys-snooze

C function exported to Guile: c-lw6sys-snooze

Wrapper on lw6sys_snooze.

4.16.384 c-lw6sys-url-canonize

C function exported to Guile: c-lw6sys-url-canonize

Wrapper on lw6sys_url_canonize.

4.16.385 c-lw6tsk-loader-get-stage

C function exported to Guile: c-lw6tsk-loader-get-stage

Wrapper on lw6tsk_loader_get_stage.

4.16.386 c-lw6tsk-loader-new

C function exported to Guile: c-lw6tsk-loader-new

Wrapper on lw6tsk_loader_new.

4.16.387 c-lw6tsk-loader-pop

C function exported to Guile: c-lw6tsk-loader-pop

Wrapper on lw6tsk_loader_pop.

4.16.388 c-lw6tsk-loader-push-gen

C function exported to Guile: c-lw6tsk-loader-push-gen

Wrapper on lw6tsk_loader_push_gen.

4.16.389 c-lw6tsk-loader-push-ldr

C function exported to Guile: c-lw6tsk-loader-push-ldr

Wrapper on lw6tsk_loader_push_ldr.


Previous: , Up: Reference   [Contents][Index]

4.17 Script hooks


Previous: , Up: Top   [Contents][Index]

5 C API

This chapter contains a description of all modules and a list of all documented C functions in the program. It contains many references and is self-generated from C comments using gdoc by Simon Josefsson.

In order to reduce the number of pages of printed output, this complete reference is, by default, disabled in printable versions of the documentation (PostScript, PDF). This is both to make the manual more readable and to avoid wasting paper. Think about the environment.

It is however available in the HTML version of the documentation, which you can read online on http://www.gnu.org/software/liquidwar6/manual/html_node/.

Additionnally, the following adresses contain various view on the source code, giving informations on all the internal and public C interfaces:


Next: , Up: C API   [Contents][Index]

5.1 libliquidwar6

5.1.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/index.html.

5.1.2 API

Function: void lw6_resize_callback (lw6gui_video_mode_t * video_mode)

video_mode: the new video mode

This callback is here because gfx needs to update the config when the screen is resized. But... we did not want to make gfx depend on cfg "directly". It’s cleaner to pass parameters with Scheme, in the long run, it should make things easier. So this callback is the solution. Another side effect is that this way there’s a tangible obvious trace of this updating of config status by the gfx module. Seeing it sticking out like a thumb isn’t a bad thing.

Return value: none

Function: void lw6_release ()

Functions which will call quit, free, destroy on whatever smob object that has threads and/or requires hardware ressources. This is to be called before the Guile interpreter ends. This is because when it garbage collects objects at the end of the program, it has no idea of what order to use when freeing objects. So if an object which uses another one in a thread is freed after the other is freed, you get a (rather unexplainabled if not warned) segfault.

Return value: none

Function: void lw6_exit ()

Sends a quit message and displays a newline.

Return value: none

Function: void lw6_set_ret (int ret)

ret: return value to set, 1 for success, 0 for failure

Sets the ret value for the script.

Return value: none

Function: int lw6_get_ret ()

Get the ret value for the script.

Return value: 1 if success, 0 if not.

Function: int lw6_fix_env (int argc, const char * [] argv)

argc: number of args as passed to main argv: array of strings as passed to main

Fixes environment variables (path related) so that program can find its requirements. This must be called early in the program flow (else other calls might fail).

Return value: 1 if success, 0 if failure

Function: int lw6_register_funcs_bot ()

Register the functions of the bot module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs ()

Register all the functions, make them callable from Guile. This is a very simple yet long and very usefull function, without it Guile has no knowledge of what LW6 is.

Return value: 1 on success, 0 if failed.

Function: extern void lw6_cns_handler (char * c_line)

c_line: the line typed by the user

This function will be called every time a message is typed on the console. It runs the given line in the current Guile environment.

Return value: none

Function: int lw6_register_funcs_cfg ()

Register the functions of the cfg module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_cli ()

Register the functions of the cli module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_cns ()

Register the functions of the cns module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_dsp ()

Register the functions of the dsp module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_gen ()

Register the functions of the gen module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_gfx ()

Register the functions of the gfx module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_gui ()

Register the functions of the gui module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_hlp ()

Register the functions of the hlp module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_img ()

Register the functions of the img module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_ker ()

Register the functions of the ker module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_ldr ()

Register the functions of the ldr module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_map ()

Register the functions of the map module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_net ()

Register the functions of the net module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_p2p ()

Register the functions of the p2p module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_pil ()

Register the functions of the pil module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_snd ()

Register the functions of the snd module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_srv ()

Register the functions of the srv module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_sys ()

Register the functions of the sys module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_register_funcs_tsk ()

Register the functions of the tsk module, make them callable from Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_init_global (int argc, const char * [] argv)

argc: number of args as passed to main

argv: array of strings as passed to main

Initializes global values to their defaults.

Return value: 1 on success, 0 if failed

Function: void lw6_quit_global ()

Frees global values. Will also garbage collect objects in case Guile failed to do it perfectly (or we failed to tell Guile how to do it). Important note: this function can only be called once in a program, usually at the end. If called twice, and typically, if *any* Guile code is run after it, the risk is that Guile code does not find objects that it should, or said differently, Guile might try to manipulate stuff that has been deleted without its being warned about it. In practice, libGC way of doing thing is usually a good thing, since it will from time to time keep objects in memory that shouldn’t, so there’s no point in changing that, but as we are pedantic in LW6 about the fact that everything at program exit must be perfectly freed, the problem arises. So well, only call this once at the end, else problem will show up, the usual form is a segfault on the delete callback, as when Guile finally runs its GC, the object does not exist any more.

Return value: none.

Function: int lw6_main (int argc, const char * [] argv)

argc: the argc parameter of the main function, that is, the number of command-line args.

argv: the argv parameter of the main function, that is, an array containing pointers on command-line args.

This function is directly called by main. This means by linking against libliquidwar6 and calling it, you would have a program that is almost exactly the "official" upstream liquidwar6 binary, except you can tweak it and have all the power to call whatever other functions you like, embed it. In short, everything the binary does, you can do it in your own binarn, by linking against the library and calling this function.

Return value: 1 if success, zero if failure. Note that this is the "standard" C / liquidwar6 way to proceed, but your main function should return 0 if success, else an error code. Typical use is "return !lw6_main(argc, argv);".

Function: int lw6_process_non_run_options (int argc, const char * [] argv, int * run_game)

argc: the number of command-line args, as passed to main

argv: an array of strings containing command-line args, as passed to main

run_game: a pointer to a boolean which will contain true (1) if the game must be launched, or false (0) if the option is such that game must be skipped. Example: –copyright, –help, ...

Return value: non-zero if success, 0 if error. The error can be, for instance, the test suite returning "no, tests were not OK".

Function: SCM lw6_make_scm_dsp (lw6dsp_backend_t * c_dsp)

c_dsp: the display object

Creates an SCM ’dsp’ object from C data.

Return value: the SCM object

Function: lw6dsp_backend_t * lw6_scm_to_dsp (SCM dsp)

dsp: the dsp to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’dsp’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_dsp_smob (lw6_dsp_smob_t * dsp_smob)

dsp_smob: the smob to free

Frees a dsp smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_snd (lw6snd_backend_t * c_snd)

c_snd: the sound object

Creates an SCM ’snd’ object from C data.

Return value: the SCM object

Function: lw6snd_backend_t * lw6_scm_to_snd (SCM snd)

snd: the snd to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’snd’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_snd_smob (lw6_snd_smob_t * snd_smob)

snd_smob: the smob to free

Frees a snd smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_map (lw6map_level_t * c_map)

c_map: the map object

Creates an SCM ’map’ object from C data.

Return value: the SCM object

Function: lw6map_level_t * lw6_scm_to_map (SCM map)

map: the map to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’map’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_map_smob (lw6_map_smob_t * map_smob)

map_smob: the smob to free

Frees a map smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_menu (lw6gui_menu_t * c_menu)

c_menu: the menu object

Creates an SCM ’menu’ object from C data.

Return value: the SCM object

Function: lw6gui_menu_t * lw6_scm_to_menu (SCM menu)

menu: the menu to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’menu’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_menu_smob (lw6_menu_smob_t * menu_smob)

menu_smob: the smob to free

Frees a menu smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_game_struct (lw6ker_game_struct_t * c_game_struct, SCM map)

c_game_struct: the game struct object

map: the map (SCM object) referenced

Creates an SCM ’game-struct’ object from C data. Passing the map object enables the garbage collector not to free the map until the game struct is freed.

Return value: the SCM object

Function: lw6ker_game_struct_t * lw6_scm_to_game_struct (SCM game_struct)

game_struct: the game_struct to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’game_struct’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_game_struct_smob (lw6_game_struct_smob_t * game_struct_smob)

game_struct_smob: the smob to free

Frees a game_struct smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_game_state (lw6ker_game_state_t * c_game_state, SCM game_struct)

c_game_state: the game state object

game_struct: the game struct (SCM object) referenced

Creates an SCM ’game_state’ object from C data. Passing game_struct enables the garbage collector not to free the game_struct until the game_state is freed.

Return value: the SCM object

Function: lw6ker_game_state_t * lw6_scm_to_game_state (SCM game_state)

game_state: the game_state to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’game_state’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_game_state_smob (lw6_game_state_smob_t * game_state_smob)

game_state_smob: the smob to free

Frees a game_state smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_pilot (lw6pil_pilot_t * c_pilot)

c_pilot: the pilot object

Creates an SCM ’pilot’ object from C data.

Return value: the SCM object

Function: lw6pil_pilot_t * lw6_scm_to_pilot (SCM pilot)

pilot: the pilot to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’pilot’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_pilot_smob (lw6_pilot_smob_t * pilot_smob)

pilot_smob: the smob to free

Frees a pilot smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_bot (lw6bot_backend_t * c_bot, SCM game_state, SCM pilot)

c_bot: the bot object

game_state: the game state

pilot: the pilot

Creates an SCM ’bot’ object from C data. Passing game_state and pilot enables the garbage collector not the free them until bot is freed.

Return value: the SCM object

Function: lw6bot_backend_t * lw6_scm_to_bot (SCM bot)

bot: the bot to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’bot’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_bot_smob (lw6_bot_smob_t * bot_smob)

bot_smob: the smob to free

Frees a bot smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_look (lw6gui_look_t * c_look)

c_look: the look object

Creates an SCM ’look’ object from C data.

Return value: the SCM object

Function: lw6gui_look_t * lw6_scm_to_look (SCM look)

look: the look to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’look’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_look_smob (lw6_look_smob_t * look_smob)

look_smob: the smob to free

Frees a look smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_loader (lw6tsk_loader_t * c_loader)

c_loader: the loader object

Creates an SCM ’loader’ object from C data.

Return value: the SCM object

Function: lw6tsk_loader_t * lw6_scm_to_loader (SCM loader)

loader: the loader to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’loader’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_loader_smob (lw6_loader_smob_t * loader_smob)

loader_smob: the smob to free

Frees a loader smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_db (lw6p2p_db_t * c_db)

c_db: the database object

Creates an SCM ’db’ object from C data.

Return value: the SCM object

Function: lw6p2p_db_t * lw6_scm_to_db (SCM db)

db: the db to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’db’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_db_smob (lw6_db_smob_t * db_smob)

db_smob: the smob to free

Frees a db smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_node (lw6p2p_node_t * c_node, SCM db)

c_node: the node object

db: the db (SCM object) referenced

Creates an SCM ’node’ object from C data. Passing db enables the garbage collector not to free db until node is freed.

Return value: the SCM object

Function: lw6p2p_node_t * lw6_scm_to_node (SCM node)

node: the node to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’node’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_node_smob (lw6_node_smob_t * node_smob)

node_smob: the smob to free

Frees a node smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: SCM lw6_make_scm_jpeg (lw6img_jpeg_t * c_jpeg)

c_jpeg: the database object

Creates an SCM ’jpeg’ object from C data.

Return value: the SCM object

Function: lw6img_jpeg_t * lw6_scm_to_jpeg (SCM jpeg)

jpeg: the jpeg to convert (SCM object)

Gets the internal C pointer corresponding to the scheme ’jpeg’ object.

Return value: a pointer, *not* a copy, must not be freed

Function: void lw6_free_jpeg_smob (lw6_jpeg_smob_t * jpeg_smob)

jpeg_smob: the smob to free

Frees a jpeg smob, we need a special function to do that as structures like assoc hold pointers to these objects and therefore need a proper callback when being destroyed.

Return value: none

Function: int lw6_register_smobs ()

Register all smobs to Guile.

Return value: 1 on success, 0 if failed.

Function: int lw6_test_register (int mode)

mode: test mode (bitmask)

Registers all tests for the lw6 module.

Return value: 1 if test is successfull, 0 on error.

Function: int lw6_test_run (int mode)

mode: test mode (bitmask)

Runs the liquidwar6 core module test suite, this will mostly test how Guile script integration works, loading a sample script and running it. It does not launch all the other sub modules tests.

Return value: 1 if test is successfull, 0 on error.


Next: , Previous: , Up: C API   [Contents][Index]

5.2 libbot

5.2.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/bot/index.html.

5.2.2 API

Function: int lw6bot_init (lw6bot_backend_t * backend, lw6bot_seed_t * seed)

backend: backend to use

seed: parameters required to build bot (game state, among other things)

Initializes a bot object. Must be performed before any other call. The seed is absolutely required, for a bot really needs to know what map/context it’s working on, including at creation time

Return value: 1 on success, 0 on failure.

Function: void lw6bot_quit (lw6bot_backend_t * backend)

backend: unitialize a bot backend

Closes a bot, but does not free all ressources.

Function: int lw6bot_next_move (lw6bot_backend_t * backend, int * x, int * y)

backend: bot to work on

x: next x position (out param)

y: next y position (out param)

Queries the bot for its next move, this is actually the one interesting function in the whole bot API.

Return value: 1 on success, 0 on failure.

Function: char * lw6bot_repr (const lw6bot_backend_t * backend)

backend: bot to represent

Gives a human readable representation of bot

Return value: dynamically allocated string.

Function: lw6sys_assoc_t * lw6bot_get_backends (int argc, const char * [] argv)

argc: argc, as passed to main

argv: argv, as passed to main

List available bot backends. The hash contains pairs with id and name for each backend. The id is the technical key you can use to load the backend, the name is something more readable you can display in an interface. The backend objects themselves are not instanciated by this (in fact, they are, but released on the fly) you need to load and initialize them afterwards.

Return value: hash containing id/name pairs.

Function: lw6bot_backend_t * lw6bot_create_backend (int argc, const char * [] argv, const char * name)

argc: argc, as passed to main

argv: argv, as passed to main

name: string containing bot key, typically got from lw6bot_get_backends

Creates a bot backend, this is just about loading the dynamic library if needed, and/or check bot engine is available, and connect to it. It does not perform initialization.

Return value: bot backend.

Function: void lw6bot_destroy_backend (lw6bot_backend_t * backend)

backend: bot backend to destroy

Frees the ressources associated to a bot, which must have been properly uninitialized before.

Return value: none.

Function: int lw6bot_test_register (int mode)

mode: test mode (bitmask)

Registers all tests for the libbot module.

Return value: 1 if test is successfull, 0 on error.

Function: int lw6bot_test_run (int mode)

mode: test mode (bitmask)

Runs the bot module test suite, testing most (if not all...) functions.

Return value: 1 if test is successfull, 0 on error.

Struct: lw6bot_backend_s

The bot backend is the first argument passed to any bot function, it contains reference to all the functions which can be used as well as a pointer on associated data. In OO, this would just be an object, with members and methods, using polymorphism through opaque pointers.

Member of lw6bot_backend_s: dl_handle

Type: lw6dyn_dl_handle_t *

Definition: lw6dyn_dl_handle_t* lw6bot_backend_s::dl_handle

Handle on dynamic library (if it makes sense).

Member of lw6bot_backend_s: bot_context

Type: void *

Definition: void* lw6bot_backend_s::bot_context

Bot specific data, what is behind this pointer really depends on the bot engine.

Member of lw6bot_backend_s: argc

Type: int

Definition: int lw6bot_backend_s::argc

The argc value passed to main.

Member of lw6bot_backend_s: argv

Type: const char **

Definition: const char** lw6bot_backend_s::argv

The argv value passed to main.

Member of lw6bot_backend_s: id

Type: u_int32_t

Definition: u_int32_t lw6bot_backend_s::id

The id of the object, this is non-zero and unique within one run session, incremented at each object creation.

Member of lw6bot_backend_s: seed

Type: lw6bot_seed_t

Definition: lw6bot_seed_t lw6bot_backend_s::seed

Parameters passed at initialization.

Member of lw6bot_backend_s: init

Type: void *(*

Definition: void*(* lw6bot_backend_s::init)(int argc, const char *argv[], lw6bot_data_t *data)

Pointer on lw6bot_init callback code.

Member of lw6bot_backend_s: quit

Type: void(*

Definition: void(* lw6bot_backend_s::quit)(void *bot_context)

Pointer on lw6bot_context callback code.

Member of lw6bot_backend_s: next_move

Type: int(*

Definition: int(* lw6bot_backend_s::next_move)(void *bot_context, int *x, int *y, lw6bot_data_t *data)

Pointer on lw6bot_next_move callback code.

Member of lw6bot_backend_s: repr

Type: char *(*

Definition: char*(* lw6bot_backend_s::repr)(void *bot_context, u_int32_t id)

Pointer on lw6bot_repr callback code.

Struct: lw6bot_data_s

Data used by a bot, those are essentially stable data passed as an argument plus changing data, that is, the game state.

Member of lw6bot_data_s: game_state

Type: const lw6ker_game_state_t *

Definition: const lw6ker_game_state_t* lw6bot_data_s::game_state

Game state the bot will have to base its reflexion upon. This not need be always the same game state, the pointer might change, but it should always refer to the same logical game, that is, at least, same struct.

Member of lw6bot_data_s: param

Type: lw6bot_param_t

Definition: lw6bot_param_t lw6bot_data_s::param

Constant parameters passed to the bot at creation.

Struct: lw6bot_param_s

Parameters usable by a bot engine. Those are the stable, fixed parameters passed at bot creation, they don’t change during the bot life.

Member of lw6bot_param_s: speed

Type: float

Definition: float lw6bot_param_s::speed

Speed of the bot, this is a value between 0.0f and 1.0f, 1 means normal speed, 0 is as slow as possible. Values over 1 will make the bot act/move faster than usual.

Member of lw6bot_param_s: iq

Type: int

Definition: int lw6bot_param_s::iq

IQ is supposed to reflect the cleverness of the bot. The default is 100 (this value is basically a percentage), 0 means just so stupid, and a high value, for instance 200, means very clever.

Member of lw6bot_param_s: cursor_id

Type: u_int16_t

Definition: u_int16_t lw6bot_param_s::cursor_id

The cursor ID, which is a 16-bit non-null integer.

Struct: lw6bot_seed_s

Parameters passed at bot creation, the only use for this is to simplify the protoype of the init function.

Member of lw6bot_seed_s: game_state

Type: const lw6ker_game_state_t *

Definition: const lw6ker_game_state_t* lw6bot_seed_s::game_state

Game state, that is, the level used, the fighters on it, the other cursors positions, and so on.

Member of lw6bot_seed_s: pilot

Type: lw6pil_pilot_t *

Definition: lw6pil_pilot_t* lw6bot_seed_s::pilot

This can be NULL, it’s a pilot object which can be used in some case, when, for instance, in dirty read mode, we want to read the level on the fly without syncing.

Member of lw6bot_seed_s: dirty_read

Type: int

Definition: int lw6bot_seed_s::dirty_read

The dirty read mode (between 0 and 2).

Member of lw6bot_seed_s: param

Type: lw6bot_param_t

Definition: lw6bot_param_t lw6bot_seed_s::param

Parameters given to the bot at creation.


Next: , Previous: , Up: C API   [Contents][Index]

5.3 mod-brute

5.3.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/bot/mod-brute/index.html.

5.3.2 API

Function: void mod_brute_is_GPL_compatible ()

Defined to tell mod_brute is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_brute_is_dlclose_safe ()

Defined to tell mod_brute has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_brute_get_pedigree ()

Returns the pedigree for mod-brute, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6bot_backend_t * mod_brute_create_backend ()

Creates a mod-brute backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.4 mod-follow

5.4.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/bot/mod-follow/index.html.

5.4.2 API

Function: void mod_follow_is_GPL_compatible ()

Defined to tell mod_follow is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_follow_is_dlclose_safe ()

Defined to tell mod_follow has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_follow_get_pedigree ()

Returns the pedigree for mod-follow, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6bot_backend_t * mod_follow_create_backend ()

Creates a mod-follow backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.5 mod-idiot

5.5.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/bot/mod-idiot/index.html.

5.5.2 API

Function: void mod_idiot_is_GPL_compatible ()

Defined to tell mod_idiot is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_idiot_is_dlclose_safe ()

Defined to tell mod_idiot has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_idiot_get_pedigree ()

Returns the pedigree for mod-idiot, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6bot_backend_t * mod_idiot_create_backend ()

Creates a mod-idiot backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.6 mod-random

5.6.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/bot/mod-random/index.html.

5.6.2 API

Function: void mod_random_is_GPL_compatible ()

Defined to tell mod_random is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_random_is_dlclose_safe ()

Defined to tell mod_random has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_random_get_pedigree ()

Returns the pedigree for mod-random, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6bot_backend_t * mod_random_create_backend ()

Creates a mod-random backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.7 libcfg

5.7.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cfg/index.html.

5.7.2 API

Function: int lw6cfg_parse_command_line (void * context)

context: opaque pointer on a context

Overwrites any existing option with command line args

Return value: 1 if success, 0 if error

Function: int lw6cfg_defaults (void * context)

context: opaque pointer on a context

Sets all values to their defaults.

Return value: 1 if success, 0 if error

Function: int lw6cfg_merge_env (void * cfg_context)

cfg_context: a context returned by lw6cfg_init

Overwrites any existing vale in the config with environment variables prefixed by LW6_.

Return value: 1 if successfull, 0 if error.

Function: int lw6cfg_load_exp (const char * user_dir, int * exp)

user_dir: the user directory

exp: the exp (out param)

Gets exp from file.

Return value: 1 on success, 0 on failure

Function: int lw6cfg_save_exp (const char * user_dir, int exp)

user_dir: the user directory

exp: the exp

Saves exp to file.

Return value: 1 on success, 0 on failure

Function: char * lw6cfg_format (const char * key, const char * value, lw6hlp_type_t type)

key: the key of the value to format

value: the value to format

type: the type of the value to format

Formats, converts, a given value to its cannonical representation. Booleans will be converted to true/false, strings containing integers will be stripped from junk, and so on. This is a performance killer but will ensure everything is correct.

Return value: a newly allocated string, containing the same as the input, but reformatted the pedantic way.

Function: char * lw6cfg_format_guess_type (const char * key, const char * value)

key: the key of the value to format

value: the value to format

Formats, converts, a given value to its cannonical representation. Booleans will be converted to true/false, strings containing integers will be stripped from junk, and so on. This is a performance killer but will ensure everything is correct. This function will automatically guess the type of the value from its description in the help system.

Return value: a newly allocated string, containing the same as the input, but reformatted the pedantic way.

Function: int lw6cfg_load (void * cfg_context, const char * filename)

cfg_context: a context returned by lw6cfg_init

filename: a file path, absolute or relative

Loads the given config file, and stores its values into the current context. Parameters which are both in the config file and given as command line parameters, will be taken from the command-line.

Return value: 1 if successfull, 0 if error.

Function: int lw6cfg_option_exists (void * context, const char * key)

context: context to query

key: key to search

Returns wether a key exists within context or not.

Return value: 1 if exists, 0 if not

Function: char * lw6cfg_get_option (void * context, const char * key)

context: context to query

key: key to search

Returns the current value for a given query, the returned value is always a string, typically the string one would pass on the command line or set in a config file

Return value: pointer to string, must be freed.

Function: void lw6cfg_set_option (void * context, const char * key, const char * value)

context: context to modify

key: key to search and change

value: new value

Sets a given key to the specified value, this is a string only function, pass the value you would pass on the command line or set in a config file.

Return value: none

Function: int lw6cfg_get_option_int (void * context, const char * key)

context: context to query

key: key to search

Returns an option as an integer. Note that this function does not know wether the parameter should really be an integer or not, so you can call it even on non-integer values, but of course results will have no real meaning.

Return value: option value converted to int

Function: void lw6cfg_set_option_int (void * context, const char * key, int value)

context: context to modify

key: key to search and change

value: new value

Set a config option to an integer value. Note that this function does not know wether the parameter should really be an integer or not, so you can call it even on non-integer values, at your own risk.

Return value: none.

Function: int lw6cfg_get_option_bool (void * context, const char * key)

context: context to query

key: key to search

Returns an option as a boolean. Note that this function does not know wether the parameter should really be a boolean or not, so you can call it even on non-boolean values, but of course results will have no real meaning.

Return value: option value converted to boolean

Function: void lw6cfg_set_option_bool (void * context, const char * key, int value)

context: context to modify

key: key to search and change

value: new value

Set a config option to a boolean value. Note that this function does not know wether the parameter should really be a boolean or not, so you can call it even on non-boolean values, at your own risk.

Return value: none.

Function: int lw6cfg_must_be_saved (const char * key)

key: key to test

Tells wether a key should be saved in the config file. Typically, some options you don’t want to savem such as the location of the config file itself. Most of those non-savable parameters are path-related. This does not mean no paths are saved in the config file.

Return value: 1 if must be saved, 0 if not

Function: int lw6cfg_save (void * cfg_context, const char * filename)

cfg_context: a context returned by lw6cfg_init

filename: a file path, absolute or relative

Save current options into the given config file. Before saving the file, all command line arguments will be read and will override current values. This means the saved file will contain values given as command line arguments.

Return value: 1 if successfull, 0 if error.

Function: void * lw6cfg_init (int argc, const char * [] argv)

argc: number of command line arguments, as given to main

argv: a list of command line arguments, as given to main

Initializes a config context object. This object is hidden behind an opaque void * pointer to avoid direct access to its elements.

Return value: an opaque pointer, must be freed with lw6cfg_quit.

Function: void lw6cfg_quit (void * cfg_context)

cfg_context: a context returned by lw6cfg_init

Frees a config cfg_context object. You must call this once you’re done with the context.

Return value: none.

Function: void lw6cfg_reset (int argc, const char * [] argv)

argc: number of command line arguments, as given to main

argv: a list of command line arguments, as given to main

Overwrites the config file with defaults. Use this to get rid of old configurations.

Function: int lw6cfg_test_register (int mode)

mode: test mode (bitmask)

Registers all tests for the libcfg module.

Return value: 1 if test is successfull, 0 on error.

Function: int lw6cfg_test_run (int mode)

mode: test mode (bitmask)

Runs the cfg module test suite, testing most (if not all...) functions.

Return value: 1 if test is successfull, 0 on error.

Function: char * lw6cfg_unified_get_value (int argc, const char * [] argv, char * key)

argc: number of command-line args, as passed to main

argv: arry of command-line args, as passed to main

key: the key to query

Unified "value" getter, which gets informations from environment variables, command line, and config file. The rules is that the command-line argument always has the last word. It will override any other value. Follows environment variables, which will be used if no command-line argument is supplied. Note that these are "LW6_" prefixed and uppercased environment variables as opposed to lowercased and "dash-separated" keys. Finally, if there’s no environment variable, nor any config-file corresponding entry, the value will be searched in the config file. If there’s no information in the config file, NULL is returned.

Return value: a string with the value. Can be NULL. Must be freed.

Function: char * lw6cfg_unified_get_user_dir (int argc, const char * [] argv)

argc: number of command-line args, as passed to main

argv: arry of command-line args, as passed to main

Gets the user dir, taking all parameters in account, that’s to say the "LW6_USER_DIR" env value, the "–user-dir" command-line paramater and the LW6DEF_USER_DIR config file entry.

Return value: the directory path, might be NULL, must be freed.

Function: char * lw6cfg_unified_get_log_file (int argc, const char * [] argv)

argc: number of command-line args, as passed to main

argv: arry of command-line args, as passed to main

Gets the log file, taking all parameters in account, that’s to say the "LW6_LOG_FILE" env value, the "–log-file" command-line paramater and the LW6DEF_LOG_FILE config file entry.

Return value: the directory path, might be NULL, must be freed.

Function: char * lw6cfg_unified_get_music_path (int argc, const char * [] argv)

argc: number of command-line args, as passed to main

argv: arry of command-line args, as passed to main

Gets the user dir, taking all parameters in account, that’s to say the "LW6_MUSIC_PATH" env value, the "–music-path" command-line paramater and the LW6DEF_MUSIC_PATH config file entry.

Return value: the directory path, might be NULL, must be freed.

Function: char * lw6cfg_unified_get_map_path (int argc, const char * [] argv)

argc: number of command-line args, as passed to main

argv: arry of command-line args, as passed to main

Gets the user dir, taking all parameters in account, that’s to say the "LW6_MAP_PATH" env value, the "–map-path" command-line paramater and the LW6DEF_MAP_PATH config file entry.

Return value: the directory path, might be NULL, must be freed.

Function: char * lw6cfg_xml_element (lw6hlp_type_t type)

type: type as an enum

Returns the string corresponding to a given type, suitable for use in XML files. For instance if you pass LW6HLP_TYPE_INT then you will obtain the string int (string of 3 chars containing i, n and t.

Return value: string, must not be freed.

Function: void lw6cfg_read_xml_int (const char * xml_key, const char * xml_value, const char * target_key, int * value)

xml_key: key found in XML file

xml_value: value found in XML file

target_key: key we’re searching for

value: the value if found (out param)

Tries to find a value in a key/value pair. If xml_key and target_key match, then will put the corresponding value (converted to int) in the value param. Typically, you would call this in a loop on every single entry found in an XML file, in an expat callback.

Return value: none.

Function: void lw6cfg_read_xml_bool (const char * xml_key, const char * xml_value, const char * target_key, int * value)

xml_key: key found in XML file

xml_value: value found in XML file

target_key: key we’re searching for

value: the value if found (out param)

Tries to find a value in a key/value pair. If xml_key and target_key match, then will put the corresponding value (converted to boolean) in the value param. Typically, you would call this in a loop on every single entry found in an XML file, in an expat callback.

Return value: none.

Function: void lw6cfg_read_xml_float (const char * xml_key, const char * xml_value, const char * target_key, float * value)

xml_key: key found in XML file

xml_value: value found in XML file

target_key: key we’re searching for

value: the value if found (out param)

Tries to find a value in a key/value pair. If xml_key and target_key match, then will put the corresponding value (converted to float) in the value param. Typically, you would call this in a loop on every single entry found in an XML file, in an expat callback.

Return value: none.

Function: void lw6cfg_read_xml_string (const char * xml_key, const char * xml_value, const char * target_key, char ** value)

xml_key: key found in XML file

xml_value: value found in XML file

target_key: key we’re searching for

value: the value if found (out param)

Tries to find a value in a key/value pair. If xml_key and target_key match, then will put the corresponding value (as a string) in the value param. Typically, you would call this in a loop on every single entry found in an XML file, in an expat callback.

Return value: none.

Function: void lw6cfg_read_xml_color (const char * xml_key, const char * xml_value, const char * target_key, lw6sys_color_8_t * value)

xml_key: key found in XML file

xml_value: value found in XML file

target_key: key we’re searching for

value: the value if found (out param)

Tries to find a value in a key/value pair. If xml_key and target_key match, then will put the corresponding value (converted to a color) in the value param. Typically, you would call this in a loop on every single entry found in an XML file, in an expat callback.

Return value: none.

Function: int lw6cfg_read_key_value_xml_file (const char * filename, lw6cfg_read_xml_callback_func_t callback_func, void * callback_data)

filename: full path of file to read

callback_func: callback function to be called on each element

callback_data: additionnal pointer passed to callback function

Will parse a file and call the given callback on each element. This is an over-simplified way to read XML file, in fact we just explain plain non-nested simple elements but this is exactly what LW config files are made of.

Return value: 1 on success, 0 on failure.

Function: void lw6cfg_write_xml_int (FILE * f, const char * key, int value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes an int entry into an opened XML file.

Return value: none.

Function: void lw6cfg_write_xml_bool (FILE * f, const char * key, int value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes a boolean entry into an opened XML file.

Return value: none.

Function: void lw6cfg_write_xml_float (FILE * f, const char * key, float value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes a float entry into an opened XML file.

Return value: none.

Function: void lw6cfg_write_xml_string (FILE * f, const char * key, const char * value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes a string entry into an opened XML file.

Return value: none.

Function: void lw6cfg_write_xml_color (FILE * f, const char * key, lw6sys_color_8_t value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes a color entry into an opened XML file.

Return value: none.

Function: void lw6cfg_write_xml_guess_type (FILE * f, const char * key, const char * value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes an entry into an opened XML file, will try and guess type from the internal help system, typically, if this is a standard config file entry (the one documented by the about command line function) it will pick up the right type. The reason not to use this all the times is that sometimes, one might to to store non-standard options, and additionnally, guessing the type does consume some CPU.

Return value: none.

Function: void lw6cfg_write_xml_guess_type_skip_same (FILE * f, const char * key, const char * value)

f: file to write data to (append mode)

key: key to write

value: value to write

Writes an entry into an opened XML file, will try and guess type from the internal help system, typically, if this is a standard config file entry (the one documented by the about command line function) it will pick up the right type. The reason not to use this all the times is that sometimes, one might to to store non-standard options, and additionnally, guessing the type does consume some CPU. Also, this function will write only values that are different from the default.

Return value: none.


Next: , Previous: , Up: C API   [Contents][Index]

5.8 libcli

5.8.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cli/index.html.

5.8.2 API

Function: int lw6cli_init (lw6cli_backend_t * backend)

backend: backend to use

Initializes a client backend. Must be performed before any other call.

Return value: 1 on success, 0 on failure

Function: void lw6cli_quit (lw6cli_backend_t * backend)

backend: unitialize a cli backend

Closes a cli, but does not free all ressources.

Function: int lw6cli_process_oob (lw6cli_backend_t * backend, lw6nod_info_t * node_info, lw6cli_oob_data_t * oob_data)

backend: backend to use

node_info: information on the current node

oob_data: data of the out-of-band request

Processes the required out-of-band tasks, this typically, for a client, includes broadcasting. Depending on parameters passed in oob_data, might actually do a broadcast or simply call a given host and see what’s the answer. A typicall exchange is PING then INFO and finally LIST. It’s the responsability of the client to take the OOB initiative and contact the server.

Return value: 1 on success, 0 on failure.

Function: lw6cnx_connection_t * lw6cli_open (lw6cli_backend_t * backend, const char * local_url, const char * remote_url, const char * remote_ip, int remote_port, const char * password, u_int64_t local_id, u_int64_t remote_id, int dns_ok, int network_reliability, lw6cnx_recv_callback_t recv_callback_func, void * recv_callback_data)

backend: backend to use

local_url: our local public url

remote_url: the remote url we want to connect to

remote_ip: remote IP address

remote_port: remote IP port

password: password to use (if needed)

local_id: our local id

remote_id: the remote id

dns_ok: wether the remote announced URL matches DNS information

network_reliability: network reliability (the highest, the better)

recv_callback_func: callback func to be called when data is received

recv_callback_data: pointer on additionnal data to pass to callback func

Opens a connection with a remote host. Be carefull with the implementation of recv_callback_func, it should be at least reentrant, and when it accesses shared data, use locks.

Return value: new object.

Function: void lw6cli_close (lw6cli_backend_t * backend, lw6cnx_connection_t * connection)

backend: backend to use

connection: connection to use

Closes a connection, this will free the connection object.

Return value: none.

Function: int lw6cli_send (lw6cli_backend_t * backend, lw6cnx_connection_t * connection, int64_t now, u_int32_t physical_ticket_sig, u_int32_t logical_ticket_sig, u_int64_t logical_from_id, u_int64_t logical_to_id, const char * message)

backend: backend to use

connection: connection to use

now: current timestamp

physical_ticket_sig: signature of physical sender

logical_ticket_sig: signature of logical sender

logical_from_id: id of logical sender

logical_to_id: id of logicial target

message: text of message to send

Sends a message to a peer over a given connection.

Return value: 1 on success, 0 on failure.

Function: int lw6cli_can_send (lw6cli_backend_t * backend, lw6cnx_connection_t * connection)

backend: backend to use

connection: connection to use

Tells wether a client connection can technically send messages. This does not garantee send will succeed, but if it’s not OK at this stage, it’s not even worth trying.

Return value: 1 if it can be used to send messages, 0 if not ready.

Function: void lw6cli_poll (lw6cli_backend_t * backend, lw6cnx_connection_t * connection)

backend: backend to use

connection: connection to use

Performs required duty on connection, depending on the backend, this can include sending messages and/or receiving them. Must be called on a regular basis.

Return value: none.

Function: char * lw6cli_repr (const lw6cli_backend_t * backend, lw6cnx_connection_t * connection)

backend: backend to use

connection: connection to represent

Gives a human readable representation of the connection.

Return value: dynamically allocated string.

Function: lw6cli_oob_t * lw6cli_oob_new (const char * public_url, lw6cli_verify_callback_func_t verify_callback_func, void * verify_callback_data)

public_url: the address of the distant server to test

verify_callback_func: a function which will be called when a node has been verified

verify_callback_data: additionnal data passed to the callback func

Create a new OOB structure, copying required objects. We need to make copies for this is for usage in a separate thread. The thread member is not set here since the right way to do things is first to set up data then to fire the thread.

Return value: new object

Function: void lw6cli_oob_free (lw6cli_oob_t * oob)

oob: the object to free

Frees an OOB structure.

Return value: none

Function: char * lw6cli_default_backends ()

Returns the list of the default cli backends.

Return value: comma separated string, must not be freed.

Function: lw6sys_assoc_t * lw6cli_get_backends (int argc, const char * [] argv)

argc: argc, as passed to main

argv: argv, as passed to main

List available cli backends. The hash contains pairs with id and name for each backend. The id is the technical key you can use to load the backend, the name is something more readable you can display in an interface. The backend objects themselves are not instanciated by this (in fact, they are, but released on the fly) you need to load and initialize them afterwards.

Return value: hash containing id/name pairs.

Function: lw6cli_backend_t * lw6cli_create_backend (int argc, const char * [] argv, const char * name)

argc: argc, as passed to main

argv: argv, as passed to main

name: string containing cli key, typically got from lw6cli_get_backends

Creates a cli backend, this is just about loading the dynamic library if needed, and/or check cli engine is available, and connect to it. It does not perform initialization.

Return value: cli backend.

Function: void lw6cli_destroy_backend (lw6cli_backend_t * backend)

backend: backend to destroy

Destroys a cli backend.

Return value: none.

Function: int lw6cli_test_register (int mode)

mode: test mode (bitmask)

Registers all tests for the libcli module.

Return value: 1 if test is successfull, 0 on error.

Function: int lw6cli_test_run (int mode)

mode: test mode (bitmask)

Runs the cli module test suite, testing most (if not all...) functions.

Return value: 1 if test is successfull, 0 on error.

Struct: lw6cli_backend_s

The cli backend is the first argument passed to any cli function, it contains reference to all the functions which can be used as well as a pointer on associated data. In OO, this would just be an object, with members and methods, using polymorphism through opaque pointers.

Member of lw6cli_backend_s: dl_handle

Type: lw6dyn_dl_handle_t *

Definition: lw6dyn_dl_handle_t* lw6cli_backend_s::dl_handle

Handle on dynamic library (if it makes sense).

Member of lw6cli_backend_s: cli_context

Type: void *

Definition: void* lw6cli_backend_s::cli_context

Cli specific data, what is behind this pointer really depends on the cli engine.

Member of lw6cli_backend_s: argc

Type: int

Definition: int lw6cli_backend_s::argc

The argc value passed to main.

Member of lw6cli_backend_s: argv

Type: const char **

Definition: const char** lw6cli_backend_s::argv

The argv value passed to main.

Member of lw6cli_backend_s: id

Type: u_int32_t

Definition: u_int32_t lw6cli_backend_s::id

The id of the object, this is non-zero and unique within one run session, incremented at each object creation.

Member of lw6cli_backend_s: name

Type: char *

Definition: char* lw6cli_backend_s::name

Module name.

Member of lw6cli_backend_s: properties

Type: lw6cnx_properties_t

Definition: lw6cnx_properties_t lw6cli_backend_s::properties

General backend properties.

Member of lw6cli_backend_s: init

Type: void *(*

Definition: void*(* lw6cli_backend_s::init)(int argc, const char *argv[], lw6cnx_properties_t *properties)

Pointer on lw6cli_init callback code.

Member of lw6cli_backend_s: quit

Type: void(*

Definition: void(* lw6cli_backend_s::quit)(void *cli_context)

Pointer on lw6cli_quit callback code.

Member of lw6cli_backend_s: process_oob

Type: int(*

Definition: int(* lw6cli_backend_s::process_oob)(void *cli_context, lw6nod_info_t *node_info, lw6cli_oob_data_t *oob_data)

Pointer on lw6cli_process_oob callback code.

Member of lw6cli_backend_s: open

Type: lw6cnx_connection_t *(*

Definition: lw6cnx_connection_t*(* lw6cli_backend_s::open)(void *cli_context, const char *local_url, const char *remote_url, const char *remote_ip, int remote_port, const char *password, u_int64_t local_id, u_int64_t remote_id, int dns_ok, int network_reliability, lw6cnx_recv_callback_t recv_callback_func, void *recv_callback_data)

Pointer on lw6cli_open callback code.

Member of lw6cli_backend_s: close

Type: void(*

Definition: void(* lw6cli_backend_s::close)(void *cli_context, lw6cnx_connection_t *connection)

Pointer on lw6cli_close callback code.

Member of lw6cli_backend_s: send

Type: int(*

Definition: int(* lw6cli_backend_s::send)(void *cli_context, lw6cnx_connection_t *connection, int64_t now, u_int32_t physical_ticket_sig, u_int32_t logical_ticket_sig, u_int64_t logical_from_id, u_int64_t logical_to_id, const char *message)

Pointer on lw6cli_send callback code.

Member of lw6cli_backend_s: can_send

Type: int(*

Definition: int(* lw6cli_backend_s::can_send)(void *cli_context, lw6cnx_connection_t *connection)

Pointer on lw6cli_can_send callback code.

Member of lw6cli_backend_s: poll

Type: void(*

Definition: void(* lw6cli_backend_s::poll)(void *cli_context, lw6cnx_connection_t *connection)

Pointer on lw6cli_poll callback code.

Member of lw6cli_backend_s: repr

Type: char *(*

Definition: char*(* lw6cli_backend_s::repr)(void *cli_context, lw6cnx_connection_t *connection)

Pointer on lw6cli_repr callback code.

Struct: lw6cli_oob_data_s

Holds the data for the process_oob function, this is merely a utility struct to simplify headers/

Member of lw6cli_oob_data_s: creation_timestamp

Type: int64_t

Definition: int64_t lw6cli_oob_data_s::creation_timestamp

Creation timestamp of the OOB request, this is used to know wether we have already timed out or not. This is not the node creation timestamp.

Member of lw6cli_oob_data_s: do_not_finish

Type: int

Definition: volatile int lw6cli_oob_data_s::do_not_finish

Flag used to force finish, for instance when we want to delete the object quickly and do not want to wait until a long polling-based network operation finishes completely.

Member of lw6cli_oob_data_s: public_url

Type: char *

Definition: char* lw6cli_oob_data_s::public_url

Public URL of the node, we need this at hand to serve it quickly to peers, and be able to perform basic checks.

Member of lw6cli_oob_data_s: verify_callback_func

Type: lw6cli_verify_callback_func_t

Definition: lw6cli_verify_callback_func_t lw6cli_oob_data_s::verify_callback_func

Pointer on a function which will verify if peer is OK, and act accordinlgy if it’s OK or not. Note that the callback function might be called pretty much anytime in the heavily multithreaded context of LW6 so it must be reentrant and have mutexes if needed. Indeed, it’s very likely to update some shared list of available nodes.

Member of lw6cli_oob_data_s: verify_callback_data

Type: void *

Definition: void* lw6cli_oob_data_s::verify_callback_data

Data passed to the verify_callback function.

Struct: lw6cli_oob_s

Structure containing both the thread running an OOB request and its data. It was advantagious to separate thoses two and not make the thread a permanent member of the OOB data struct, since it allows the actual OOB code to be totally unaware of the thread running it, which is, to some extent, safer.

Member of lw6cli_oob_s: thread

Type: lw6sys_thread_handler_t *

Definition: lw6sys_thread_handler_t* lw6cli_oob_s::thread

Pointer on thread running the OOB request.

Member of lw6cli_oob_s: data

Type: lw6cli_oob_data_t

Definition: lw6cli_oob_data_t lw6cli_oob_s::data

Data used by the OOB request.


Next: , Previous: , Up: C API   [Contents][Index]

5.9 mod-http

5.9.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cli/mod-http/index.html.

5.9.2 API

Function: void mod_http_is_GPL_compatible ()

Defined to tell mod_http is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_http_is_dlclose_safe ()

Defined to tell mod_http has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_http_get_pedigree ()

Returns the pedigree for mod-http, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6cli_backend_t * mod_http_create_backend ()

Creates a mod-http backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.10 mod-tcp

5.10.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cli/mod-tcp/index.html.

5.10.2 API

Function: void mod_tcp_is_GPL_compatible ()

Defined to tell mod_tcp is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_tcp_is_dlclose_safe ()

Defined to tell mod_tcp has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_tcp_get_pedigree ()

Returns the pedigree for mod-tcp, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6cli_backend_t * mod_tcp_create_backend ()

Creates a mod-tcp backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.11 mod-udp

5.11.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cli/mod-udp/index.html.

5.11.2 API

Function: void mod_udp_is_GPL_compatible ()

Defined to tell mod_udp is compatible with GNU General Public License. Of course it is. This function does nothing, but the fact it’s declared makes its GPL compatibility obvious. Having this declared is required.

Return value: none

Function: void mod_udp_is_dlclose_safe ()

Defined to tell mod_udp has no dlclose issue, once can safely call lt_dlclose on it when done with it, without risking any segfault. Some other LW6 modules/shared libraries do have this problem.

Return value: none

Function: lw6sys_module_pedigree_t * mod_udp_get_pedigree ()

Returns the pedigree for mod-udp, giving details about the module, including name, description, licence, date/time of compilation.

Return value: dynamically allocated object.

Function: lw6cli_backend_t * mod_udp_create_backend ()

Creates a mod-udp backend.

Return value: backend pointer.


Next: , Previous: , Up: C API   [Contents][Index]

5.12 libcns

5.12.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cns/index.html.

5.12.2 API

Function: void lw6cns_handler_install (lw6cns_callback_func_t callback)

callback: handler function.

Installs a console handler.

Return value: none.

Function: void lw6cns_handler_poll ()

Polling function for console, must be called on a regular basis.

Return value: none.

Function: void lw6cns_handler_remove ()

Remove console handler.

Return value: none.

Function: void lw6cns_history_add_if_needed (char * line)

line: line to add

Adds a line to the console history, won’t add it if it’s NULL or empty.

Return value: none.

Function: int lw6cns_console_support ()

Tells wether console is supported.

Return value: 1 if console can be enabled, 0 if not

Function: int lw6cns_term_support ()

Tells wether program is likely to have proper term (xterm, Linux console) support.

Return value: 1 if has validated TERM support, 0 if not

Function: int lw6cns_test_register (int mode)

mode: test mode (bitmask)

Registers all tests for the libcns module.

Return value: 1 if test is successfull, 0 on error.

Function: int lw6cns_test_run (int mode)

mode: test mode (bitmask)

Runs the cns module test suite, testing most (if not all...) functions.

Return value: 1 if test is successfull, 0 on error.


Next: , Previous: , Up: C API   [Contents][Index]

5.13 libcnx

5.13.1 Overview

View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/cnx/index.html.

5.13.2 API

Function: lw6cnx_connection_t * lw6cnx_connection_new (const char * local_url, const char * remote_url, const char * remote_ip, int remote_port, const char * password, u_int64_t local_id, u_int64_t remote_id, int dns_ok, int network_reliability, lw6cnx_recv_callback_t recv_callback_func</