Next: Map hints.xml, Previous: Map parameters, Up: Reference

### 4.9 Map rules.xml

#### 4.9.1 color-conflict-mode

— Command-line option: `--color-conflict-mode=<value>`
— Environment variable: `LW6_COLOR_CONFLICT_MODE`
— XML key: `color-conflict-mode`

> Type: integer.

> 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.9.2 cursor-pot-init

— Command-line option: `--cursor-pot-init=<value>`
— Environment variable: `LW6_CURSOR_POT_INIT`
— XML key: `cursor-pot-init`

> Type: integer.

> 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.9.3 fighter-attack

— Command-line option: `--fighter-attack=<value>`
— Environment variable: `LW6_FIGHTER_ATTACK`
— XML key: `fighter-attack`

> Type: integer.

> 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.9.4 fighter-defense

— Command-line option: `--fighter-defense=<value>`
— Environment variable: `LW6_FIGHTER_DEFENSE`
— XML key: `fighter-defense`

> Type: integer.

> 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.9.5 fighter-new-health

— Command-line option: `--fighter-new-health=<value>`
— Environment variable: `LW6_FIGHTER_NEW_HEALTH`
— XML key: `fighter-new-health`

> Type: integer.

> 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.9.6 fighter-regenerate

— Command-line option: `--fighter-regenerate=<value>`
— Environment variable: `LW6_FIGHTER_REGENERATE`
— XML key: `fighter-regenerate`

> Type: integer.

> 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.9.7 max-cursor-pot

— Command-line option: `--max-cursor-pot=<value>`
— Environment variable: `LW6_MAX_CURSOR_POT`
— XML key: `max-cursor-pot`

> Type: integer.

> 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.9.8 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.

> 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.9.9 max-nb-cursors

— Command-line option: `--max-nb-cursors=<value>`
— Environment variable: `LW6_MAX_NB_CURSORS`
— XML key: `max-nb-cursors`

> Type: integer.

> Defines the maximum number of cursors who can enter the game. Really makes sense in network games. Default value is 26, the maximum.

#### 4.9.10 max-nb-servers

— Command-line option: `--max-nb-servers=<value>`
— Environment variable: `LW6_MAX_NB_SERVERS`
— XML key: `max-nb-servers`

> Type: integer.

> 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.9.11 max-nb-teams

— Command-line option: `--max-nb-teams=<value>`
— Environment variable: `LW6_MAX_NB_TEAMS`
— XML key: `max-nb-teams`

> Type: integer.

> Defines the maximum number of teams who can enter the game. Really makes sense in network games. Default value is 10, the maximum.

#### 4.9.12 max-round-delta

— Command-line option: `--max-round-delta=<value>`
— Environment variable: `LW6_MAX_ROUND_DELTA`
— XML key: `max-round-delta`

> Type: integer.

> 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.9.13 max-zone-size

— Command-line option: `--max-zone-size=<value>`
— Environment variable: `LW6_MAX_ZONE_SIZE`
— XML key: `max-zone-size`

> Type: integer.

> 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.9.14 moves-per-round

— Command-line option: `--moves-per-round=<value>`
— Environment variable: `LW6_MOVES_PER_ROUND`
— XML key: `moves-per-round`

> Type: integer.

> 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.9.15 nb-attack-tries

— Command-line option: `--nb-attack-tries=<value>`
— Environment variable: `LW6_NB_ATTACK_TRIES`
— XML key: `nb-attack-tries`

> Type: integer.

> 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.9.16 nb-defense-tries

— Command-line option: `--nb-defense-tries=<value>`
— Environment variable: `LW6_NB_DEFENSE_TRIES`
— XML key: `nb-defense-tries`

> Type: integer.

> 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.9.17 nb-move-tries

— Command-line option: `--nb-move-tries=<value>`
— Environment variable: `LW6_NB_MOVE_TRIES`
— XML key: `nb-move-tries`

> Type: integer.

> 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.9.18 respawn-team

— Command-line option: `--respawn-team=<value>`
— Environment variable: `LW6_RESPAWN_TEAM`
— XML key: `respawn-team`

> Type: integer.

> 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.9.19 round-delta

— Command-line option: `--round-delta=<value>`
— Environment variable: `LW6_ROUND_DELTA`
— XML key: `round-delta`

> Type: integer.

> 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.9.20 rounds-per-sec

— Command-line option: `--rounds-per-sec=<value>`
— Environment variable: `LW6_ROUNDS_PER_SEC`
— XML key: `rounds-per-sec`

> Type: integer.

> 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.9.21 side-attack-factor

— Command-line option: `--side-attack-factor=<value>`
— Environment variable: `LW6_SIDE_ATTACK_FACTOR`
— XML key: `side-attack-factor`

> Type: integer.

> 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.9.22 side-defense-factor

— Command-line option: `--side-defense-factor=<value>`
— Environment variable: `LW6_SIDE_DEFENSE_FACTOR`
— XML key: `side-defense-factor`

> Type: integer.

> 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.9.23 single-army-size

— Command-line option: `--single-army-size=<value>`
— Environment variable: `LW6_SINGLE_ARMY_SIZE`
— XML key: `single-army-size`

> Type: integer.

> 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.9.24 spread-thread

— Command-line option: `--spread-thread=<value>`
— Environment variable: `LW6_SPREAD_THREAD`
— XML key: `spread-thread`

> Type: integer.

> 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.9.25 spreads-per-round

— Command-line option: `--spreads-per-round=<value>`
— Environment variable: `LW6_SPREADS_PER_ROUND`
— XML key: `spreads-per-round`

> Type: integer.

> 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.9.26 start-blue-x

— Command-line option: `--start-blue-x=<value>`
— Environment variable: `LW6_START_BLUE_X`
— XML key: `start-blue-x`

> Type: integer.

> X start position for the blue team. This is a percentage of map width, value between 0 and 100.

#### 4.9.27 start-blue-y

— Command-line option: `--start-blue-y=<value>`
— Environment variable: `LW6_START_BLUE_Y`
— XML key: `start-blue-y`

> Type: integer.

> Y start position for the blue team. This is a percentage of map height, value between 0 and 100.

#### 4.9.28 start-cyan-x

— Command-line option: `--start-cyan-x=<value>`
— Environment variable: `LW6_START_CYAN_X`
— XML key: `start-cyan-x`

> Type: integer.

> X start position for the cyan team. This is a percentage of map width, value between 0 and 100.

#### 4.9.29 start-cyan-y

— Command-line option: `--start-cyan-y=<value>`
— Environment variable: `LW6_START_CYAN_Y`
— XML key: `start-cyan-y`

> Type: integer.

> Y start position for the cyan team. This is a percentage of map height, value between 0 and 100.

#### 4.9.30 start-green-x

— Command-line option: `--start-green-x=<value>`
— Environment variable: `LW6_START_GREEN_X`
— XML key: `start-green-x`

> Type: integer.

> X start position for the green team. This is a percentage of map width, value between 0 and 100.

#### 4.9.31 start-green-y

— Command-line option: `--start-green-y=<value>`
— Environment variable: `LW6_START_GREEN_Y`
— XML key: `start-green-y`

> Type: integer.

> Y start position for the green team. This is a percentage of map height, value between 0 and 100.

#### 4.9.32 start-lightblue-x

— Command-line option: `--start-lightblue-x=<value>`
— Environment variable: `LW6_START_LIGHTBLUE_X`
— XML key: `start-lightblue-x`

> Type: integer.

> X start position for the lightblue team. This is a percentage of map width, value between 0 and 100.

#### 4.9.33 start-lightblue-y

— Command-line option: `--start-lightblue-y=<value>`
— Environment variable: `LW6_START_LIGHTBLUE_Y`
— XML key: `start-lightblue-y`

> Type: integer.

> Y start position for the lightblue team. This is a percentage of map height, value between 0 and 100.

#### 4.9.34 start-magenta-x

— Command-line option: `--start-magenta-x=<value>`
— Environment variable: `LW6_START_MAGENTA_X`
— XML key: `start-magenta-x`

> Type: integer.

> X start position for the magenta team. This is a percentage of map width, value between 0 and 100.

#### 4.9.35 start-magenta-y

— Command-line option: `--start-magenta-y=<value>`
— Environment variable: `LW6_START_MAGENTA_Y`
— XML key: `start-magenta-y`

> Type: integer.

> Y start position for the magenta team. This is a percentage of map height, value between 0 and 100.

#### 4.9.36 start-orange-x

— Command-line option: `--start-orange-x=<value>`
— Environment variable: `LW6_START_ORANGE_X`
— XML key: `start-orange-x`

> Type: integer.

> X start position for the orange team. This is a percentage of map width, value between 0 and 100.

#### 4.9.37 start-orange-y

— Command-line option: `--start-orange-y=<value>`
— Environment variable: `LW6_START_ORANGE_Y`
— XML key: `start-orange-y`

> Type: integer.

> Y start position for the orange team. This is a percentage of map height, value between 0 and 100.

#### 4.9.38 start-pink-x

— Command-line option: `--start-pink-x=<value>`
— Environment variable: `LW6_START_PINK_X`
— XML key: `start-pink-x`

> Type: integer.

> X start position for the pink team. This is a percentage of map width, value between 0 and 100.

#### 4.9.39 start-pink-y

— Command-line option: `--start-pink-y=<value>`
— Environment variable: `LW6_START_PINK_Y`
— XML key: `start-pink-y`

> Type: integer.

> Y start position for the pink team. This is a percentage of map height, value between 0 and 100.

#### 4.9.40 start-position-mode

— Command-line option: `--start-position-mode=<value>`
— Environment variable: `LW6_START_POSITION_MODE`
— XML key: `start-position-mode`

> Type: integer.

> Defines how teams or set up on the map at game startup. 0, the default, 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.9.41 start-purple-x

— Command-line option: `--start-purple-x=<value>`
— Environment variable: `LW6_START_PURPLE_X`
— XML key: `start-purple-x`

> Type: integer.

> X start position for the purple team. This is a percentage of map width, value between 0 and 100.

#### 4.9.42 start-purple-y

— Command-line option: `--start-purple-y=<value>`
— Environment variable: `LW6_START_PURPLE_Y`
— XML key: `start-purple-y`

> Type: integer.

> Y start position for the purple team. This is a percentage of map height, value between 0 and 100.

#### 4.9.43 start-red-x

— Command-line option: `--start-red-x=<value>`
— Environment variable: `LW6_START_RED_X`
— XML key: `start-red-x`

> Type: integer.

> X start position for the red team. This is a percentage of map width, value between 0 and 100.

#### 4.9.44 start-red-y

— Command-line option: `--start-red-y=<value>`
— Environment variable: `LW6_START_RED_Y`
— XML key: `start-red-y`

> Type: integer.

> Y start position for the red team. This is a percentage of map height, value between 0 and 100.

#### 4.9.45 start-yellow-x

— Command-line option: `--start-yellow-x=<value>`
— Environment variable: `LW6_START_YELLOW_X`
— XML key: `start-yellow-x`

> Type: integer.

> X start position for the yellow team. This is a percentage of map width, value between 0 and 100.

#### 4.9.46 start-yellow-y

— Command-line option: `--start-yellow-y=<value>`
— Environment variable: `LW6_START_YELLOW_Y`
— XML key: `start-yellow-y`

> Type: integer.

> Y start position for the yellow team. This is a percentage of map height, value between 0 and 100.

#### 4.9.47 total-armies-size

— Command-line option: `--total-armies-size=<value>`
— Environment variable: `LW6_TOTAL_ARMIES_SIZE`
— XML key: `total-armies-size`

> Type: integer.

> 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.9.48 total-time

— Command-line option: `--total-time=<value>`
— Environment variable: `LW6_TOTAL_TIME`
— XML key: `total-time`

> Type: integer.

> 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.9.49 vertical-move

— Command-line option: `--vertical-move=<value>`
— Environment variable: `LW6_VERTICAL_MOVE`
— XML key: `vertical-move`

> Type: integer.

> 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.9.50 x-polarity

— Command-line option: `--x-polarity=<value>`
— Environment variable: `LW6_X_POLARITY`
— XML key: `x-polarity`

> Type: integer.

> 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.9.51 y-polarity

— Command-line option: `--y-polarity=<value>`
— Environment variable: `LW6_Y_POLARITY`
— XML key: `y-polarity`

> Type: integer.

> 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.9.52 z-polarity

— Command-line option: `--z-polarity=<value>`
— Environment variable: `LW6_Z_POLARITY`
— XML key: `z-polarity`

> Type: integer.

> 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.