xbattle

Synopsis

Description

Assign a team color and display to each player, and any number of options with argument where required. <color> can be a monochrome tone, -black -white -dark -light, or a color, -red -green -blue ; <display> is the name of the x display for each player. Command line arguments can be supplied in any order. For a quick introduction, go straight to the EXAMPLES section below. Also, see the tutorials supplied with the game, which are "csh" shell scripts that start up example games.

Options

USAGE: xbattle <args>
   -<c1>          <str>    color to display name <str>
   -<c1>_<c2>     <str>    colors to display name <str>
   -area                   troops proportional to area
   -attack                 allow use of attack key
   -armies        <int>    number of ordered armies
   -basemap                use map scheme, bases visible
   -bases         <int>    number of ordered bases
   -board         <int>    size of board (in cells, x=y)
   -boardx        <int>    width of board (in cells)
   -boardy        <int>    height of board (in cells)
   -border        <int>    border around board
   -bound                  allow drag-bounded vector sets
   -build         <int>    build cities with <int> segments
   -build_cost    <int>    cost to build city segment
   -build_limit   <int>    limit cities each side can build
   -color         <spec>   set RGB values for color <str>
   -color_inverse <spec>   set color <s1> inverse to <s2>
   -decay         <int>    make troops slowly die off
   -diamond                use diamond tiling
   -dig           [int]    [int] step terrain lowering
   -dig_cost      <int>    cost of each dig step
   -digin         <int>    provide entrenchment
   -disrupt                attacks break supply lines
   -draw          <int>    specify a troop drawing method
   -dump          <file>   dump configuration to <file>
   -edit          [file]   interactively edit xbattle board
   -erode                  make unused paths erode
   -erode_thresh  <int>    threshold for erosion
   -farms         <int>    troops slowly grow
   -fight         <int>    intensity of fighting
   -fill          [int]    [int] step terrain raising
   -fill_cost     <int>    cost of each fill step
   -forest        <int>    density of forest
   -forest_color  <spec>   RGB values for forest level
   -forest_tones  <int>    number of forest levels
   -grid                   show grid
   -guns          <int>    range of artillery
   -guns_cost     <int>    cost of each artillery shell
   -guns_damage   <int>    damage done by artillery shell
   -help                   print argument list
   -hex                    use hexagonal tiling
   -hidden                 invisible enemy vectors
   -hills         <int>    slope of hills
   -hill_color    <spec>   RGB values for hill level <int>
   -hill_tones    <int>    number of allowable hill levels
   -horizon       [int]    can't see enemy past [int] cells
   -load          [file]   load board from [file]
   -localmap               mapping with invisible terrain
   -manage                 managed control of commands
   -manpos                 manual positioning of board
   -map                    use basic map scheme
   -march         <int>    number of delays between marches
   -maxval        <int>    maximum cell troop capacity
   -militia       <int>    randomly distributed troops
   -move          <int>    speed of troop flow
   -nospigot      [int]    cease attack if outnumbered
   -octagon                use octagonal/square tiling
   -options       <file>   read xbattle options from <file>
   -opt_file.xbo           shorthand -options opt_file.xbo
   -overwrite              just use terrain from load file
   -para          <int>    range of paratroopers
   -para_cost     <int>    cost of each paratrooper
   -para_damage   <int>    invading strength of paratrooper
   -peaks         <int>    number of terrain peaks
   -peak_bias     <float>  peak distribution bias (0.0-2.0)
   -rbases        <int>    number of distributed bases
   -rbase_range   <int>    distance of rbase from enemy
   -repeat                 repeat of last mouse command
   -replay        [file]   replay stored game from [file]
   -reserve                allow reserve of troops
   -scuttle       [int]    enable city scuttling
   -scuttle_cost  <int>    cost of scuttle
   -sea           <int>    pervasiveness (+ levels) of sea
   -sea_block              use block-fills, not hue-fills
   -sea_color     <spec>   RGB values for sea level <int>
   -sea_tones     <int>    number of allowable sea levels
   -sea_value     <float>  darkness of seas for b/w games
   -seed          <int>    random number generator seed
   -speed         <int>    speed of updates
   -square        <int>    side length of cell
   -stipple       <spec>   set stipple (b/w) pattern
   -store         [file]   store game for later replay
   -towns         <int>    density of distributed towns
   -triangle               use triangular tiling
   -trough_bias   <float>  trough setting bias (0.0-2.0)
   -xpos          <int>    x position of board on display
   -ypos          <int>    y position of board on display
   -wrap                   wrapping around edges of board
        

Run-time command summary

Commands in gameboard

Commands in text area

Description

xbattle is a concurrent multi-player battle strategy game that captures the dynamics of a wide range of military situations. The game board is a matrix of game cells (such as squares or hexes) which can be occupied by troops of various colors or shades. The number of troops in a cell is indicated by the size of a colored troop circle (or square) within that cell. The troops are commanded by clicking the mouse near the edge of the cell in the direction that the movement is to take place. The command will be acknowledged by the appearance of a movement vector, and thereafter, in each update cycle, a certain proportion of the troops will move from the source cell to the destination cell until the source cell is exhausted. Movement vectors can be set in several directions at once, in which case the movement is divided evenly between the vector directions, and the command remains active until canceled. Thus a trail of circles can be set up as a supply line that will deliver troops steadily at its endpoint. The movement vector remains active even if the number of troops in that cell is zero, although the movement vector will then be displayed at half length. The game is concurrent, so that commands are given continuously by all players without waiting for turns.

Team sides and players

The game is started from one display, and each player must play from a separate display, players being assigned to a color team by the command line option "-<color> <display>". The parameter <color> determines the color of the troops of that team, which can be either a monochrome tone like black, white, dark, light, or a true color like red, green, blue, although the true colors will appear on a monochrome monitor as either black or white with an identifying character in each troop marker which is the first letter of the color name. For instance, the team color "-red" would appear on a monochrome monitor as black with a letter "R" in the middle of each troop marker. The legal team color names can be selected from any color defined in the file /usr/lib/X11/rgb.txt which includes such bizarre entries as "LavenderBlush", "MistyRose", "PapayaWhip" as well as the standard "red", "green", "blue" and "black" and "white" etc. Alternatively, colors can be defined individually in the default file (.xbattle), an option file (see OPTIONS section below), or in the command line itself using the "-color <str> <r> <g> <b>" option. With this option, the color is given by <str>, and the red green and blue components by <r>, <g>, and <b> respectively, in the range (0-255). A black and white pattern can be assigned to correspond to color name <str> via the "-stipple <str> 8 x <hex>" option, where the binary breakdown of each of eight hex numbers (in form like "0xa4") specifies one of the eight rows of the pattern.

By default, xbattle supports the colors "dark", "light", "gator", "brick", which appear as bitmap textures on monochrome monitors, allowing monochrome players to have six distinguishable team colors. A number of people can be assigned to the same team by repeating the color for different displays, for example "-red display1 -red display2", and each member of the team will be able to command any troops of that team. The <display> argument designates the name of the display on which the team of that color is playing, so each player must be given a color and a display. Display names can be found with the unix command "who", which will list display names for users in the last column like (cnsxk:0.0). The system console is always designated unix:0.0. The display name can be modified for remote games, for example the terminal cnsxk:0.0 on park.bu.edu (email address of machine "park") is designated cnsxk.bu.edu:0.0 . XBattle recognizes :0.0 as the default (screen zero on the display), so the :0.0 may be omitted from the display name. XBattle also recognizes a special display name "me", which means the display from which the program is started. When playing between color and monochrome displays the colors can be specified more exactly by concatenating a color name with a monochrome name, for example "-red_white" (color first), which would display that team as red on color monitors and white on monochrome monitors. All command line flags and arguments for the game can be given in any order as long as the argument directly follows its flag, and most arguments are scaled to range from 1 to 10, with 5 being the default value. It is also possible to set different game parameters for the different displays, so that the game can be biased to favor a less experienced player (see BIASED GAMES below).

Options

A large number of command line options are available to define the parameters of the game. In essence, xbattle is many thousands of games rolled into one. The options can be presented in any order, and may be typed in with the command line, or they can be stored in an options file (default filename = default.xbo), or some can be stored and others added to the command line. The format for the options file is exactly the same as the format for the command line except that in the file each option (plus argument, where applicable) is placed on a separate line. So, for example, the game...

   xbattle -black me -white cnsxk:0.0 -armies 4 -farms 5
            -attack

could also be played with the command...

   xbattle -black me -white cnsxk:0.0 -options myoptions.xbo

or alternatively with the shorthand version...

   xbattle -black me -white cnsxk:0.0 -myoptions.xbo

where the file myoptions.xbo consists of the lines...

   -armies 4
   -farms 5
   -attack

If the specified options file cannot be found in the current directory, xbattle will search the default xbo directory DEFAULT_XBO_DIR, which can be specified at compile time in the makefile.

XBattle checks for the presence of the default file ~/.xbattle, in which options can be set in advance, saving the trouble of having to set them at run time or include an options files. The default file is typically used to set up commands which are used in nearly every game at a particular site. Thus a typical default file might contain color (and black and white) definitions, cell size, artillery damage, and the like. Option files, on the other hand, are typically used to define specific scenarios involving unique combinations of command line arguments. Conflicting commands in the default and options file are resolved in favor of the options file.

Troops

Initial troop allocation is controlled by several command options, including -bases <n>, -rbases <n>, -armies <n> and -militia <n>. Armies and militia are troops on the gameboard, whereas bases which are indicated by circles on the gameboard, provide a steady supply of troops. The -bases option allocates <n> bases to each team, symmetrically arranged on the game board, whereas -rbases <n> arranges them randomly (which works well with the -horizon option). The minimum distance between enemy bases (in cells) can optionally be set using the -rbase_range <n> command. Note that large values of <n> may not allow any valid rbase allocation, in which case xbattle will exit with an error message. The -armies option allocates <n> armies (full troop cells) symmetrically arrayed, whereas -militia <n> scatters militia of random strengths to random locations, with a probabilistic density of <n>. At least one of these four options is required to provide initial troops for the game, and they may be used in arbitrary combinations.

Resupply

The bases created by the -bases or -rbases produce a steady supply of fresh troops. The bases can be occupied by an opposing team, with the troops produced by such bases are always the color of the occupying force. The capture of all bases thus becomes the strategic objective of the game. This arrangement simulates desert warfare, as long and tenuous supply lines develop between the base and the battle areas. Another form of resupply is provided by the command option "-towns <n>". This produces a number of smaller unoccupied supply sources scattered randomly over the game board at a density determined by the argument <n>, and with random rates of troop production, indicated by the radius of the circle on the game board. Towns must be occupied by a team to begin producing troops. This option simulates yet a larger scale of operation as the combatants battle to occupy the towns. A more distributed form of resupply is evoked by the command option "-farms <n>" whereby every cell of the game board will produce troops as soon as it is occupied, at a rate proportional to the argument <n>, and the strategic objective becomes the occupation of the largest areas of the gameboard. This option simulates a yet larger scale of operation and requires complex management of resources to concentrate the distributed resources and deliver them to the battle front. In large scale scenarios additional realism may be added by using the "-decay <n>" option whereby the troop strength in all troop cells decays constantly in proportion to the value of the decay argument. This reflects the fact that armies constantly consume resources even while they are idle, and an army without constant resupply will wither away. With the decay option, a set of bases, towns or farms can only support armies of limited size, and the armies will dynamically grow or shrink until they reach that size. Since this number includes the troops that make up the supply line, the fighting power of an army diminishes with the length of the supply line. The default decay value is zero, i.e. no decay. All the resupply options can be used in any combination. The "-erode <n>" command doesn't affect resuply, per se, but it does effect the movement vectors through which troops flow by causing them to erode away as they grow older. All movement vectors in a cell will be unset at a random time not to be less than <n> update cycles, with probability of erosion for each subsequent cycle determined by the "-erode_thresh <m>" argument, where <m> is the percentage chance of erosion.

Enhanced movement commands

With the option "-repeat" you can repeat the last command using the right mouse. If for example your last command to a cell consisted of a "move up" command by clicking near the top edge of the cell, you can now command other cells to also move up by clicking in those cells with the right mouse. That way you no longer have to aim your click exactly at the top side of those cells, but can click the right mouse anywhere in that cell, which saves time. This command is supported in biased games - i.e. it can be set for one team but not another. Commands can be made to apply to more than one cell with the option "-bound". This is achieved by defining a bounding rectangle within which the command is valid. For instance, to command a block of cells to all move up simultaneously, you place your mouse near the top edge of a cell (may be unoccupied, or enemy occupied) and press the button (setting the command "go up", then you drag the mouse to another game cell where you release the button. The start and end cells of the mouse drag define the opposite corners of a rectangle within which all the game cells occupied by your troops receive the command "go up". The "-attack" option makes quick, multiple front attacks possible. By issuing an "a" command in an enemy cell, all adjacent friendly troops will automatically alter their movement vectors so as to attack the enemy cell, and only that cell. The "-reserve" option allows a player to define a level of reserves to remain in the cell despite any movement vectors. For instance a reserve level of 5 would ensure that the cell will maintain a reserve of 50% capacity, and movement out of that cell will only occur with troops in excess of the reserve level. This is extremely useful when a supply line must pass through a strategically important part of the board. The reserve level is set in a particular game cell by pointing to that cell with the mouse and striking a number key, "1" for 10% reserves, "2"for 20% reserves, and so forth up to "9" for 90% reserves.

With the option "-march <n>", troops may be commanded to march in a particular direction and to continue in that direction without further commands. March commands are activated with shift left or shift middle mouse button. For example, if you click near the top edge of a cell with "shift left mouse", the troops will begin to march up, and on arrival in the next cell they will transfer the march command to that cell so that they will continue marching upwards to the next cell, and so forth. If a marching column encounters hostile forces the march command is canceled and the column stops. To prevent marching columns from traveling much faster than manually commanded troops, the march argument <n> defines the number of game update cycles that the troops must wait in each new cell before marching on to the next cell, so that "-march 1" will result in a fast march, whereas "-march 10" will be slow. The "march command" is indicated on the game board by a double command vector (looks like an "=" sign) in the appropriate direction, and the march command is always passed on to the head of the column. March commands may be set in cells that are NOT occupied by your troops, and will be activated when a marching column arrives in that cell. This allows you to define turns in the path of the marching column to avoid obstacles. A "stop march" command may also be set to program the marching column to stop in that cell. This is achieved by clicking "shift left mouse" in the center of that cell, and will be displayed as an empty box in that cell. When set with the left mouse, the march vector is overwritten on to existing command vectors encountered in the march path, whereas when set with the middle mouse the march vector removes and replaces existing command vectors. March commands are canceled by clicking on the cell without the shift key. March commands may be set in cells that are beyond the visible horizon in the normal way , and will appear as a double vector in that cell so long as that cell is not a "sea" cell. If the target cell contains invisible enemy troops, then the march command vectors will appear initially, but disappear again as soon as the enemy is approached close enough to be visible. March commands are specific to the team that sets them, and different march commands may be set by different teams in the same game cell. The double command vectors are visible only to the team that sets them.

Game play

Whenever troops of different colors occupy the same game cell, a battle ensues, indicated by concentric markers of the two colors, and a "crossed swords" (X) symbol. During battle, one or both sides can incur losses according to a random nonlinear function that disproportionately favors the more numerous troops. The steepness of the nonlinearity, i.e. the advantage given to the more numerous side, is controlled by the -fight parameter. A small value will produce lengthy drawn out battles which favor a defensive strategy, whereas a large value produces quick decisive battles where the random element is more significant, favoring an offensive strategy even against superior odds. In the absence of the -fight option, the default value of 5 is used. The -fight parameter is also automatically modulated by the game speed parameter (-speed) in order to slow down battles in fast games and vice versa. Since only 1/3 of the troops can enter a cell in each update cycle (with the default -move 5), attackers of a full cell are always outnumbered initially, unless a coordinated attack is launched from three sides simultaneously. The -move argument thus has a significant influence on the efficacy of an attack. The -disrupt option dictates that when a game cell comes under attack, all its command vectors are immediately canceled, breaking supply lines which must be repaired by hand after the attack. In other words, there can be no movement under fire, and even small forces can be used to provide covering fire to "pin down" a larger force, at least until they are counter-attacked and eliminated. A side effect of this option is that when an attacking cell is counterattacked, both cells attempt to cancel each other's movement, i.e. to interrupt the attack. The cell that is updated next will prevail, canceling the command vector of the other cell. Since the game cells are updated in a random sequence, there is no telling which cell will prevail, and the commander must click repeatedly to renew the command vector in order to press home the attack under opposition. This simulates the tactical situation where a commander must personally intervene to ensure the maximal effort is applied at the most critical points of the battle. The "-seed <n>" option simply sets the seed of the random number generator to <n>, which is useful for recreating scenarios. By default the random number generator is seeded with a combination of the system time and process ID number --- a more-or-less random number.

In each update cycle some fraction of the troops in a game cell move to adjacent cells indicated by the command vectors. The default fraction is 1/3, so that in each successive cycle, 1/3 of the remaining troops move out of the cell until it is empty. That fraction is adjusted with the -move argument, 1 for less movement, and 10 for more movement. The option -digin <n> simulates the time and effort required for troops to dig in and build fortifications. This is achieved by reducing the rate of flow of troops into a cell as it fills up to capacity, so that to achieve a really full troop cell the men must dig in and settle down to accommodate the last arrivals. The argument <n> modulates the strength of this effect, from 1 to 10 for small to large. The maximum number of troops which can occupy a single cell is set via -maxval <n>. Note that for octagonal tiling only, the some cells (the square ones) will have different maxvals.

The -nospigot [n] option causes troops to automatically cease attacks when they are highly outnumbered, preventing the "spigoting" (perhaps "siphoning" would be more appropriate) which can empty whole supply lines into needless slaughter. Neighboring supply lines are shut off whenever the troops in a cell are outnumbered by a ratio given by the argument to the nospigot command.

Board configuration

The dimensions of the game board can be tailored via the -boardx <n> and -boardy <n> options which set the horizontal and vertical board dimensions, in terms of cells. The -board <n> option creates a square board. The dimension of each cell, in pixels, is set by the -cell <n> option. The xbattle window border can be set with -border <n>, while the initial x and y position of the game board can be set with -xpos <n> and -ypos <n> respectively. The -manpos option allows each player to position his or her window interactively (does not work with all window managers). A grid indicating the borders of each cell is established via the -grid command (the default), and can be eliminated via the negative command -no_grid. Game play wraps around the edged of the board if the -wrap option is invoked, although certain tiling schemes require even or odd board dimensions for wrap to work properly in both the horizontal and vertical directions. Troop markers are scaled by area (proportional to number), rather than diameter, if the -area option is used.

Tiling methods

A number of different tiling methods are available in xbattle, each of which employs cells of a different shape. Square cells in a rectangular grid are used for the -square option (the default). Hexagonal cells are used with the -hex option. The -diamond option results in a square tiling, tilted by 45 degrees. A tiling consisting of two orientations of equilateral triangles is invoked with the -triangle option. The -octagon option results in a tiling consisting of a combination of regular octagons and small squares. Since different cell shapes have different neighborhoods, troop movement in the different tilings can have a very different feel, and may take some getting used to.

Drawing methods

The method of drawing and erasing troops and terrain is defined via the -draw <n> option, where the argument indicates one of five distinct techniques, of varying speed and flicker. They are: Method 0: Erase the cell by drawing a circle the color of the terrain, then redraw the cell contents. This is the method employed in xbattle versions before 5.3. Although simple and fast, the onscreen erasing and redrawing often results in annoying flicker. METHOD 1: Erase and redraw cells as for method 0, but do the whole process on a backing store pixmap, then copy the cell to the window. The copy from the pixmap to the window adds some overhead, but flicker is completely eliminated. METHOD 2: Copy a blank cell from pixmap storage to a working pixmap, draw the cell contents, then copy the cell to the window. This method exchanges the cell erase of method 1 for a pixmap-to-pixmap copy operation to also provide flicker-free game animation. Unfortunately this method only works for square tilings, since only rectangular cells can be perfectly extracted during X-Window copy operations. METHOD 3: Copy the cell from the window to a pixmap (along with a little surround for non-square cells), erase with a circle, redraw the contents, and then copy the cell back to the window. Like method 0, but with two extra copy operations and no flicker. METHOD 4: Copy the cell from the window to a pixmap, erase the contents (including terrain) via an AND operation, draw the terrain via an OR operation, draw the cell contents, and copy back to the window. This method is fabulously complex, but has the advantage of being the only of the above method which redraws the entire cell contents, including terrain. Method 0 is still the default. With any reasonably fast-drawing machine, methods 1, 2, and 3 should provide quick enough animation. Method 4 is a bit cumbersome. Which of the methods is the fastest depends on how fast the source machine is at drawing circles and at copying rectangles. Due to the buffering of X Window drawing commands, even method 0 provides reasonably good results since the cell erases often never appear on the screen before the cell redraw.

Guns and paratroops

The command option -guns <n> enables the key 'g' to be used to control artillery, which can be shot from any occupied game cell. The range and direction of the shot are determined by the position of the cursor in the game cell relative to the center of the cell --- near center for short range and near the edge for long range, as modulated by the argument <n>. Every shell costs a number of troops from the source cell equal to the argument of -guns_cost <n> (default: 2), and destroys a number of troops at the destination cell equal to the argument of -guns_damage <n> (default: 1). The fall of shot is indicated by the brief appearance of a little dot of the attacker's color. With the -horizon option the fall of shot may not be visible for long range shots, although invisible enemy troops will be destroyed where the shell falls. Artillery can damage both friend and foe, so it must be used with caution. Paratroops are enabled by the option -para <n>, and are launched similarly to artillery using the 'p' key. The cost of dropping a number of troops equal to the argument of -para_damage <n> (default: 1) at the destination cell is equal to the argument of -para_cost <n> (default: 3). The drop zone is indicated by the brief appearance of a parachute symbol. When used with the -manage option, artillery and paratroops can be deployed continuously with the 'G' and 'P' keys instead of the 'g' and 'p' keys. This will initiate a continuous barrage that will only stop when the source cell is exhausted, but will recommence when it is resupplied. The managed command is indicated by the letters "GUN" or "PAR" in the source cell, and can be canceled with either the 'c' key, or by giving the source cell a movement command.

Terrain

The command option -hills <n> initializes random hills which restrict movement when going from low to high elevation, and enhance movement from high to low, but do not affect movement on the level. The elevation is indicated by the shade of gray, light for high and dark for low on monochrome, and brownish for high and greenish for low on color displays. The argument controls the amount of energy gained and lost on hills, i.e. the steepness. Hills provide a tactical advantage when attacking downhill. With very steep hills (-hills 9) movement from very low to very high elevation (a cliff) is virtually impossible. The number of discrete elevation levels is set via the -hill_tones <n> option. On color monitors, the hill hues can be tailored via the -hill_color <n> <red> <green> <blue>, where <n> specifies the elevation index (from 0 to hill_tones-1) to be changed to the RGB triplet. The color of unspecified elevation indices are linearly interpolated based on specified indices.

The command option -forest <n> initializes random forests which restrict movement within the forest, but do not affect movement from thin to thick forest. On both color and monochrome displays, thick forest is dark, and thin is light. Forest may not be used in conjunction with hills. When transitioning from one forest thickness to another, the movement is determined by the destination cell, not the source cell, so that troops deployed within a forest but at the boundary have a tactical advantage over those deployed outside the boundary. As for hills, the number of distinct forest densities is specified via the -forest_tones <n> option, with colors being specified by the -forest_color <n> <red> <green> <blue> option.

The command option -sea <n> generates randomly distributed bodies of water, whose prevalence is determined by the argument <n>. Such bodies of water cannot be crossed by infantry. A small value creates scattered ponds and lakes, which influences the tactical deployment of troops, whereas a large value creates a maze-like pattern of fjords or rivers which isolate blocks of land into islands which can only be taken by paratroops. On monochrome monitors water appears dark mottled grey, and on color monitors it appears as various shades of blue. Like hills, seas have elevation (depths), the number of which is controlled via the -sea_tones <n> option, with colors determined by the -sea_color <n> <red> <green> <blue> option. Besides looking nice, sea depths are useful when playing with the -dig and -fill options (see the TERRAIN MODIFICATIONS section). On monochrome monitors, the option -sea_value <float> determines the blackness of the shallowest sea, expressed as a fraction. For backwards compatibility, sea depths can also be indicated by the size of the sea marker if the -sea_block option is invoked.

Hills (and forest and seas) are created by a complex terrain generation algorithm which bases elevations (or densities, in the case of forests) on a number of fixed points, as specified by the -peaks <n> option. Based on these <n> points with randomly determined position and elevation, the elevation of the rest of the game cells is determined via a non-linear interpolation process. The -peak_bias <float> option determines how hill elevations and forest densities will be distributed --- 0.0 yields generally low-elevation terrain, with spire-like mountains, while 2.0 yields generally high-elevation terrain, with deep ravines. The default value of 1.0 results in pleasantly contoured terrain. Similarly, the -trough_bias <float> option controls the distribution of sea depths.

Terrain modification

The command options -dig [n] and -fill [n] allow run time modification of the terrain by digging hills and seas down to lower elevation or filling them up to higher elevation. This allows the construction and breaching of defensive fortifications. The cost of these operations (in troops) is determined by the -dig_cost <n> and -fill_cost <n> options. The operations are accomplished by positioning the mouse on the friendly cell and striking the "d" key (for dig) or the "f" key (for fill). With the -sea option, -dig <n> and -fill <n> can be supplied with an argument which specifies the number of sea depths (see also -sea_tones). Since it is impossible to occupy a sea cell to fill it, filling seas is accomplished by setting the command vector as if to move into the sea, and then pressing "f". Likewise for digging a sea deeper. For all other fill and dig operations the troop cell may not have any command vectors set.

The -build <n> and -scuttle [n] options allow the building and destruction of bases (or towns). The costs of these operations (in troops) are determined by -build_cost <n> and -scuttle_cost <n>. When the mouse is positioned on a friendly cell and the "b" key is pressed, the troops are exchanged for a 1/<n> fraction of a base, displayed as an arc segment. Thus <n> building commands are required to produce a functional base. When the capture of a base by the enemy seems inevitable, it is often advisable to scuttle the base to prevent it falling into enemy hands. Scuttling is performed by positioning the mouse on the base and pressing the "s" key. If the build option is not enabled, this reduces the size (and production capacity) of that base by one scuttle unit for each scuttle_cost of troops expended, where a scuttle unit is defined by the argument of the scuttle option (default: 5). Usually, several keystrokes are required to complete the destruction. When used in conjunction with the -build option, instead of reducing the size of the base, each scuttle operation removes a section (arc segment) of the base, at a troop cost indicated by the -scuttle_cost <n> option. A base will not produce troops if even a single segment is missing, although of course it is less expensive to repair (with "b" build) a base with fewer segments missing.

As with -guns and -para, the -dig, -fill, and -build options (but not the -scuttle option) can be "managed" with the -manage option, which allows a player to issue a single command to initiate a sequence of repeated dig, fill, or build operations using the keys 'D', 'F', and 'B' respectively. The managed operation will continue until the task is done, as long as the cell is resupplied. The managed operation will be indicated by the letters "DIG", "FIL" or "BLD" respectively in the managed cell. Managed operation can be canceled with the 'c' key, or by issuing a movement command to the cell.

Visibility

The command option -horizon [n] restricts the view of enemy troop deployment to within <n> cells of any friendly troops. Horizon can be called with no argument, in which case the default <n> = 2 is used. Intelligence of more remote regions can be gathered by use of paratroops. The command option -hidden (no arguments) makes the command vectors of the enemy invisible at any range. The command option -map is similar to -horizon except that it restricts your view of geographical objects as well as enemy troops, although it will "remember" any terrain that you have seen once, as if you had mapped that information. The -basemap option maps bases and towns as it does the terrain --- once you see them, they're remembered. The option -localmap maps only the local area around your troops, and features disappear as you move away again.

Store and replay

The -store <file> option allows you to store enough information about the visual progress of the game to reconstruct it later with -replay <file> option. When -replay is used, all other command options are ignored except the -<color> <display> options, which can be used to send the replay to other displays. When doing so, only the <display> portion of the option is used, the <color> is ignored. So, if you play a game with many command line parameters and several displays with the argument -store <file>, after the game you can repeat the same command line but just change -store to -replay, and the game will be replayed on the displays of all the original combatants. When xbattle is called with the -replay option alone, the default display will be "me". If store or replay are called without a file name, the default name "xbattle.xba" will be used. In the replay, the view restrictions of the -horizon option are deactivated, i.e. all enemy troops are visible. The replay action can be paused or resumed by typing any key, and can be interrupted with either control-c or control-q.

Game state saving, loading, and editing

The game state can be saved at any point during the game with the control-p key. This creates a file called "xbattle.xbt", or the name given with the argument -dump <filename>, which represents the state of the game board at the time of saving. Future games can be started from the saved game state with the command option "-load <file>" where <file> is optional if the file name is "xbattle.xbt". If the specified load file cannot be found in the current directory, xbattle will search the default xbt directory DEFAULT_XBT_DIR, which can be specified at compile time in the makefile. Note that most game parameters ARE NOT STORED. Only terrain features (forest, hills, seas, towns etc.) and troop deployment. This means that if you were playing with -farms, -decay, and -guns then you will have to type them in if you want them for the new game. The terrain and boardsize of the saved map file will override all terrain and boardsize arguments when loaded. Troop and town/base producing options (such as -militia, -towns, and -rbases) will add new features on top of the loaded game state. If the -overwrite option is issued, only the terrain and cities from the loaded game will be used --- no troops will appear. This is useful for repeating games with interesting terrains with different troop configurations.

Game boards can be created or modified with the -edit function, which is called with the command option "-edit <file>" where <file> is optional if the file name is "xbattle.xbt". With this option, no game is played, but instead, the mouse and key commands control the features of the map to be edited. To edit an existing file, use "-edit <file>" and type "l" when the editor comes up. This will load the file named in the edit argument. To save that file, type "d" and the file will be saved to the same file name. No provision is made for saving to a different file name. When using the edit mode, the command line arguments must reflect the number and color of players to be used, and the sea, forest or hills options if they will be required. For example, to create a map called "mymap.xbt" with three color teams and seas, could use the command "xbattle -edit mymap.xbt -sea 7 -white me -black you -dark you". Note the use of the special display "you", which is a dummy display name used as a place holder for the black and dark colors. The interactive commands are as follows:

   left button:    lower terrain by one notch (sea lowest)
   middle button:  raise terrain by one notch
   right button:   toggle between lowest and mid terrain

   c:    create city (growth = 100)
   t:    create town (growth = 80)
   v:    create village (growth = 60)
   k:    increase size of city by 5 percent
   j:    decrease size of city by 5 percent
   s:    scuttle city - remove 36 degrees of arc
   b:    build city - add 36 degrees of arc

   0-9:  create troop marker with troops of current color
   [:    decrease troops by 1
   ]:    increase troops by 1
   r:    increment current color
   f:    change color of existent troop marker
   d:    dump board with name <filename>
   l:    load board with name <filename>
   q:    quit

With the -edit option, the -overwrite option has a slightly different function. Rather than suppress the display of troops, as it does when combined with -load option, the -overwrite option causes default terrain to be generated for editing. Note that boards created with during the edit process are stored in reduced format, whereas boards saved during game play are stored in standard format, which includes more information about each cell, at the cost of about 15 times more storage space. Standard format files can also be edited.

Interactive commands (mouse and keyboard)

Movement commands are performed with the left and middle mouse buttons, to direct the command vector. A click in the center of the game cell clears all command vectors; a click near an edge sets the vector in that direction, and a click near a corner sets the two adjacent vectors. The left mouse toggles command vectors while the middle mouse clears existing vectors and sets a new vector (An alternative command system is available, see COMPILATION OPTIONS below). The right mouse is used to repeat the last used command (with -repeat option). The keyboard is interpreted differently depending on whether the mouse is positioned on the gameboard or on the text area below. On the gameboard, the the keys control-s and control-q pause and resume the game respectively. The 'z' key cancels all command vectors to the cell containing the cursor (like a click in the center of the cell). The key control-p saves the current game to a map file (see Saving Game State commands below). There are also a variety of keyboard commands available with different options, to control special functions on the gameboard. These keystrokes are described in detail with the description of the appropriate options (see -guns, -para, -build, -scuttle, -fill, -dig, -reserve). In the text area below the keyboard, the keys control-c and control-q both exit the player from the game, although the game continues among the remaining players until they also quit, and the key control-w also exits the player, but allows him or her to continue watching as the other players play on. The rest of the keyboard is used for communication between participants through text lines. This is especially useful when playing between remote sites- each team has its own text line, and the color of the text matches the color of the team. The control-g key rings the bell on all displays, which can be used to draw attention to a new message. All keyboard commands can be reconfigured by changing the pairings in the keyboard.h file and recompiling.

Biased games

The game can be biased to favor a less experienced player, or for any other reason, in the following way. In the normal syntax, the command line argument "-<color>" is immediately followed by the "<display>" argument, for example "-black me". It is possible to define command line options that are specific to only one display with the syntax "-<color> { <options> } <display>" where <options> refers to a list of command line options as before, but is included in a set of braces between the team color and the display (note the spaces on either side of the braces). For example,

   xbattle -black { -fight 10 } me -white { -fight 5 } cnsxk

where black (on display "me") has the advantage of greater firepower than white (on display "cnsxk"). Not all options can be biased, specifically options that control the global behavior of the game, such as -speed, -hex, and -board. Note also that if you are using player specific and global options, the global options MUST be listed first, otherwise they will overwrite the play specific options. For example,

   xbattle -black { -fight 10 } me -white cnsxk -fight 5

will result in a fight 5 for both players. In order to achieve the desired result, the command line must be...

  xbattle  -fight 5 -black { -fight 10 } me -white cnsxk

where the local option overwrites only the black team's fight value.

Extensions

A great deal of effort has been made in the design of this game to make it as simple and modular as possible. Please send any interesting variations or extensions to lesher@cns.bu.edu.

Examples

Here are some example games to give an idea of the variability of the parameters. The first example is a simple symmetrical game between "me" in black on my own display, and a white opponent on the display "cnsxk:0.0". The troops will be rapidly exhausted in this small skirmish.

   xbattle -black me -white cnsxk:0.0 -armies 4

The next example adds bases, which will produce a much prolonged conflict involving long supply lines between the front and the bases, much like desert warfare. One conflict in this battle represents a skirmish like the entire game of the previous example. In this example black is playing on the display cnsxk:0.0, and white is on the system console. Note that the extension ":0.0" can be omitted.

   xbattle -black cnsxk -white unix -armies 4 -bases 2

The next example is a game with militia scattered around initially, that have to race to occupy the towns and link up with their compatriots before they can eliminate the enemy. This is a dynamic scenario requiring tactical and strategic skill and fast reflexes. In this example black is playing on cnsxk:0.0 while white is playing on the system console of the remote machine thalamus.bu.edu.

   xbattle -black cnsxk -white thalamus.bu.edu -towns 2
           -militia 2 -hills 7

Here is a favorite around B.U. where the land is broken up by many bodies of water creating isolated islands, and view of the enemy is restricted to nearby cells, resulting in lots of surprises. Paratroops can be used for reconnaissance by launching them into unknown sectors, and they must be used in conjunction with heavy artillery barrages for airborne assaults from one landmass to the next. In this example the color display will show cyan and red teams, while the monochrome monitor will show white and black teams respectively. The decay option prevents huge armies from building up at the end of the game, and the -store option is used to store this game to the file "xbattle.xba".

   xbattle -cyan_white thalamus:0.0 -red_black cnsxk
           -rbases 5 -sea 8 -guns 4 -para 4 -horizon 2
           -decay 3 -store xbattle.xba

Now, the previous stored game is replayed to the original displays by repeating the original command line except that -store is changed to -replay. This is convenient if you have command line editing facilities.

   xbattle -cyan_white thalamus:0.0 -red_black cnsxk
           -rbases 5 -sea 8 -guns 4 -para 4 -horizon
           -replay xbattle.xba

With -replay, all arguments are actually ignored except the displays, so you could achieve exactly the same result with the simpler command

   xbattle -black thalamus:0.0 -black cnsxk -replay

where the -black argument flags the subsequent argument as a displayname, but is otherwise ignored, i.e. any color name would suffice. The filename for -replay is omitted, so that the default file name "xbattle.xba" is used.

The next example illustrates the use of the options file, xbos/tribal.xbo, to set up a game including, decay, seas, farms, militia, and many other options.

   xbattle -black me -white thalamus -options xbos/tribal.xbo

Options files can also be read in individually for the two players, as in the following example...

   xbattle -options game.xbo -black me
           -white { -options xbos/weak.xbo } thalamus

This results in a biased game where both black and white receive the options defined in game.xbo, and white receives some specific handicaps defined in weak.xbo. For example, weak.xbo could define 2 rbases instead of 5, horizon of 1 instead of 2, and lower movement and fighting values. Since these options overwrite existing options in game.xbo, the command line arguments may NOT be typed in arbitrary order. Global options must be defined before they are overwritten by the specific options to the white team.

Sample .xbo and .xbt files

To provide some idea of the range of gameplay available with xbattle, a number of option files (.xbo extension) and dump files (.xbt extension) are provided with the xbattle 5.4.1 release in the "xbos" and "xbts" subdirectories, respectively. These are listed below, along with very brief descriptions.

   tribal.xbo       mad scramble, every man for himself
   skirmish.xbo     intrigue, espionage, plotting

   demo.xbo         demo which includes ALL options

   atlas.xbo        standard atlas terrain/color scheme
   desert.xbo       mountainous desert terrain/color scheme
   io.xbo           Io-like terrain/color scheme
   space.xbo        space-like terrain/color scheme    
   tropical.xbo     tropical islands terrain/color scheme
   tundra.xbo       tundra-like terrain/color scheme

   castle.xbt       moated fortress with villages
   natural.xbt      natural streams, lakes, and hills

Playing tips

The first thing you must learn is to click quickly and accurately on the game cells. Do not focus your attention on one region of the board, but scan the whole board frequently. Look at the big picture- capture the towns that will support each other, especially a well positioned cluster of big towns. Eliminate all enemy troops from your rear, and advance outwards, preferably from a corner, with a well supplied front. Travel in convoy for speed and efficiency in safe regions, especially if you are playing with -decay, but fan out near the enemy to provide alternate routes to a broad front (click on the corner to open two command vectors simultaneously). Avoid head-on assaults on the enemy, but rather dig in and wait for him to attack while you try to turn his flank and cut off his supplies to the front, or concentrate at his weakest points. When advancing, try to attack weak cells with strong ones to gain maximum advantage, and be alert for losing battles of your weak cells pouring into a strong enemy cell, which will drain your resources until you cancel the attack and build up reserves. If however you are fighting a delaying action, or retreating under fire then you should attack strong enemy cells with your weak ones on a broad front to conserve resources. This is particularly effective with the -disrupt option. Always try to attack a cell from two or more sides, and build up sufficient strength before launching an attack on a strong cell. Always consider the "manufacturing capacity" of the enemy, i.e. the number and size of bases and towns, as the one with the most capacity will eventually win. Watch out for single enemy commandos near your unprotected bases, especially when playing with paratroops, and use such commandos to good effect against an inattentive opponent. You can keep a base fortified while sending troops to the front by use of recurrent connections, going in loops or in both directions, or by establishing dead-end branches along the supply line to accumulate local reserves. You should always have a few strong reserves near your base when playing with -horizon or -para, to ensure against surprise attacks. When playing with horizon and paratroops use the paratroops to gather intelligence from beyond the horizon. When playing with paratroops or artillery, you can create a network of recurrent connections near the bases that will provide protection by automatically sending troops into parts of the net that are knocked out.

Compilation options

Certain other game options or alternatives are allowed at compile time by editing the file "constant.h" and setting certain global flags to FIXED_TRUE or FIXED_FALSE, before compiling the program. The flag FIXED_UNIX should be set to FIXED_FALSE if you will be running on a non-unix platform. On unix systems the select() function is used to enhance efficiency and reduce computer load. The FIXED_INVERT flag may be set to FIXED_FALSE if you do not like the appearance of the inverted command vector within the troop cell. The FIXED_VARMOUSE option may be set to FIXED_TRUE if you would like the mouse operations to be redefined so that the left mouse adds command vectors, and the middle mouse subtracts such vectors. The flag FIXED_PAUSE may be set to FIXED_FALSE to disable the ability to pause and resume the game with control-s and control-q. The FIXED_SHOWFLOW flag in extern.h may be set to FIXED_FALSE to make the displayed command vectors remain at full length even when the troop strength is zero. The flag FIXED_NEWCOLORMAP can be set to FIXED_TRUE to create a private color map for the game, useful when the default color map is full. The flag FIXED_MULTITEXT can be set to FIXED_FALSE, whereby instead of having a single text line for each player, two text lines are shared by all the players. The flag FIXED_MULTIFLUSH can be set to FIXED_TRUE, whereby command vectors appear immediately after the command is given, although performance is noticeably impaired. If a player repeatedly "nukes" the whole game when he is losing, you can set FIXED_FATAL_RECOVER to FIXED_TRUE in constant.h to enable this option. User may choose between FIXED_USE_LONGJMP and FIXED_USE_PROCEDURE methods if FIXED_FATAL_RECOVER is set true. The former uses the c commands setjmp() and longjmp(). The latter uses a normal procedure call to recover. Recommended use of LONGJMP. After 20 fatal errors program kicks out, as a failsafe. WARNING players use FATAL_RECOVER at their own risk. If the flag FIXED_TIMER is set set to FIXED_TRUE, the elapsed time from game startup will be displayed in the lower left hand corner of the screen, within the text pane. If FIXED_UNIX is set to FIXED_FALSE, the timer will not work.

Bugs

When the system is slow, there is a noticeable time lag between the mouse positioning and the keystroke registration, so that a keystroke for a cell pointed to by the mouse might be actually recorded in the next cell the mouse moves to. Similarly, a shifted mouse click (as for paratroops) might be delayed so that by the time it is processed the shift key is no longer being depressed, and it is recorded as an unshifted mouse click (as for artillery). Under such circumstances, avoid issuing rapid command sequences. Remote play is extremely difficult. When a {player specific option} is followed by a universal option, the former is overwritten by the latter, so the { player specific option } should always follow the universal option.

Authors

Greg Lesher (lesher@cns.bu.edu), Steve Lehar (slehar@park.bu.edu), and some sections of code from Mark Lauer (elric@basser.cs.su.oz.au). Helpful suggestions, bug reports, and ideas were gratefully received from numerous contributors from all over the world.