ballz

package: ballz

title: ballz(6)

text:
# ballz(6)

## NAME
ballz - platform/puzzle game where you control a rolling ball

## SYNOPSIS
ballz

## DESCRIPTION
The game is a platformer with some puzzle elements. You take control of a ball which is genetically modifed by the British secret service. Your mission is to rescue captured British soldiers from a prison in Iran.

You can play the game with the keyboard.

Up

Jump

Control

Special

Shift

Special

## OPTIONS
No options.

## AUTHOR
ballz was written by Olof Naessen and Per Larsson.

This manual page was written by Sylvain Beucler <beuc@beuc.net>, for the Debian project (but may be used by others).


bastet

package: bastet

title: bastet(6)

summary: any falling bricks game clone with bastard block-choosing AI

text:
# bastet(6)

## NAME
bastet - any falling bricks game clone with "bastard" block-choosing AI

## SYNOPSIS
bastet

## DESCRIPTION
bastet (short for "bastard falling bricks game") is a any falling bricks game clone which tries to give you the worst possible block. Playing bastet can be a painful experience, especially if you usually make "canyons" and wait for the long I-shaped block.

## USAGE
bastet tries to conform as much as possible to the falling bricks game guidelines. We refer to those for the rules of the game. In the starting menu, you can configure the key bindings; the default ones are:

DOWN

moves the tetromino down (one single step)

LEFT

moves the tetromino left

RIGHT

moves the tetromino right

SPACE

rotates CW

UP

rotates CCW

ENTER

drops the tetromino as far down as possible (hard drop)

P

pauses the game

CTRL+C

exits the game without any further prompt

## PLAYING MODES
The game includes two playing modes. In the second one (harder), you do not get the preview of the next tetromino, and the algorithm is modified to take advantage of this.

## FILES
$(HOME)/.bastetrc User options

$(HOME)/.bastetscores User-specific high scores file (used only if the system high scores file is unavailable)

/var/games/bastet.scores2 System-wide high scores for bastet.

## OPTIONS
None.

## BUGS
Many.

## AUTHOR
Federico Poloni <f.poloni@gmx.com>


black-hole-solve

package: black-hole-solver

title: black-hole-solve(6)

text:
# black-hole-solve(6)

## NAME
black-hole-solve - Utility for solving Golf Solitaire, Black Hole Solitaire, and All in a Row Solitaire games.

## SYNOPSIS
black-hole-solve --game [golf|black_hole|all_in_a_row] /path/to/board.txt

## DESCRIPTION
black-hole-solve is a command line application that solves a single deal of Golf Solitaire, Black Hole Solitaire, or All in a Row Solitaire.

Also provided is a C library with an API.

## OPTIONS
See --help .

TODO FILL_IN

## EXAMPLE

```
    $ make_pysol_freecell_board.py -F -t 24 black_hole | \
        black-hole-solve --game black_hole -
```

## SEE ALSO
make_pysol_freecell_board.py(6)

## AUTHOR
Shlomi Fish, <http://www.shlomifish.org/> .


blockattack

package: blockattack

title: blockattack(6)

summary: a puzzle game inspired by Tetris Attack

text:
# blockattack(6)

## NAME
blockattack - a puzzle game inspired by Tetris Attack

## SYNOPSIS
blockattack [OPTION]...

## DESCRIPTION
Block Attack - Rise of the blocks 2.8.0

Block Attack - Rise of the Blocks is a puzzle/blockfall game inspired by Tetris Attack for the SNES.

www.blockattack.net

## OPTIONS
-h [ --help ]

Displays this message

--version

Display the version information

-c [ --config ] arg

Read a config file with the values. Can be given multiple times

--nosound

Disables the sound. Can be used if sound errors prevents you from starting

--priority

Causes the game to not sleep between frames.

--software-renderer

Asks SDL2 to use software renderer

--verbose-basic

Enables basic verbose messages

--verbose-game-controller

Enables verbose messages regarding controllers

--print-search-path

Prints the search path and quits

--no-auto-scale

Do not automatically auto scale

--always-sixteen-nine

Use 16:9 format even in Window mode

--puzzle-level-file arg

Sets the default puzzle file to load

--puzzle-single-level arg

Start the specific puzzle level directly

--bind-text-domain arg

Overwrites the bind text domain used for finding translations. Default: "/usr/local/share/blockattack/locale/"

--homepath arg

Set the home folder where settings are saved. The directory will be created if it does not exist. Default: "$HOME/.local/share/blockattack"

-m [ --mod ] arg

Loads a mod. Later mods have preference

## EXAMPLES
blockattack

Start the game normally

blockattack --nosound

Start the game without sound. Can be used if sound problems prevents the game from starting

blockattack --puzzle-level-file puzzle.levels --puzzle-single-level 3

Start the game with the default puzzles in level 3

blockattack --bind-text-domain /dev/null

Disables translations

## REPORTING BUGS
Report bugs to the issue tracker here: <https://github.com/blockattack/blockattack-game/issues>

## COPYRIGHT
Copyright © 2005-2022 Poul Sander License GPLv2+: GNU GPL version 2 <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html> or later <http://gnu.org/licenses/gpl.html>

This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.


bombardier

package: bombardier

title: bombardier(6)

summary: the GNU Bombing utility

text:
# bombardier(6)

## NAME
bombardier - the GNU Bombing utility

## SYNOPSIS
bombardier

## DESCRIPTION
bombardier is the GNU Bombing utility.

This was one of my favourite games on Commodore Plus 4 when I was I child. Your task is to bomb down cities. This can be done with a 3 character wide airplane, which can drop 3 character tall bombs to the ugly # based houses. If you can bomb down all of the houses you can land with your plane, and in this case the challenge will continue on the next city. Good luck!

## COMMANDS
space - drops a bomb

p - pauses the game

q - quits from the game

1..9 - sets the speed of the game

## FILES
/var/games/bombardier/bdscore

The shared best score file.

## AUTHORS
Gergely Risko <gergely@risko.hu>

## VERSION
Version 0.8.3 released on 2009-10-10

## BUGS
Should be reported to Debian BTS, http://bugs.debian.org/bombardier


boswars

package: boswars

title: boswars(6)

summary: futuristic real-time strategy game

text:
# boswars(6)

## NAME
boswars - futuristic real-time strategy game

## SYNOPSIS
boswars [OPTIONS]

## OPTIONS
-c file.lua

configuration start file (default stratagus.lua)

-d datapath

path to stratagus data

-e

Start editor

-h

Help shows this page

-l

Disable command log

-P port

Network port to use

-n server

Network server host preset

-L lag

Network lag in # frames (default 10 = 333ms)

-U update

Network update rate in # frames (default 5=6x per s)

-N name

Name of the player

-s sleep

Number of frames for the AI to sleep before it starts

-v mode

Video mode (0=default,1=640x480,2=800x600, 3=1024x768,4=1280x960,5=1600x1200)

-D

Video mode depth = pixel per point (for Win32/TNT)

-F

Full screen video mode

-S

Sync speed (100 = 30 frames/s)

-W

Windowed video mode

map is relative to StratagusLibPath=datapath, use ./map for relative to the current working directory.

## AUTHOR
boswars was written by the Bos Wars and Stratagus Project.

This manual page was written by Cyril Brulebois <cyril.brulebois@enst-bretagne.fr>, for the Debian project (and may be used by others).


adventure

package: bsd-games

title: adventure(6)

summary: an exploration game

text:
# adventure(6)

## NAME
adventure — an exploration game

## SYNOPSIS
adventure

[saved-file]

## DESCRIPTION
The object of the game is to locate and explore Colossal Cave, find the treasures hidden there, and bring them back to the building with you. The program is self-descriptive to a point, but part of the game is to discover its rules.

To terminate a game, enter “quit”; to save a game for later resumption, enter “suspend”.


arithmetic

title: arithmetic(6)

summary: quiz on simple arithmetic

text:
# arithmetic(6)

## NAME
arithmetic — quiz on simple arithmetic

## SYNOPSIS
arithmetic

[-o +-x/] [-r range]

## DESCRIPTION
arithmetic asks you to solve problems in simple arithmetic. Each question must be answered correctly before going on to the next. After every 20 problems, it prints the score so far and the time taken. You can quit at any time by typing the interrupt or end-of-file character.

The options are as follows:

-o

By default, arithmetic asks questions on addition of numbers from 0 to 10, and corresponding subtraction. By supplying one or more of the characters +-x/, you can ask for problems in addition, subtraction, multiplication, and division, respectively. If you give one of these characters more than once, that kind of problem will be asked correspondingly more often.

-r

If a range is supplied, arithmetic selects the numbers in its problems in the following way. For addition and multiplication, the numbers to be added or multiplied are between 0 and range, inclusive. For subtraction and division, both the required result and the number to divide by or subtract will be between 0 and range. (Of course, arithmetic will not ask you to divide by 0.) The default is 10.

When you get a problem wrong, arithmetic will remember the numbers involved, and will tend to select those numbers more often than others, in problems of the same sort. Eventually it will forgive and forget.

arithmetic cannot be persuaded to tell you the right answer. You must work it out for yourself.

## DIAGNOSTICS
“What?” if you get a question wrong. “Right!” if you get it right. “Please type a number.” if arithmetic doesn't understand what you typed.

## SEE ALSO
bc(1), dc(1)


atc

title: atc(6)

summary: air traffic controller game

text:
# atc(6)

## NAME
atc — air traffic controller game

## SYNOPSIS
atc

[-u?lstp] [-gf game name] [-r random seed]

## DESCRIPTION
atc lets you try your hand at the nerve wracking duties of the air traffic controller without endangering the lives of millions of travelers each year. Your responsibilities require you to direct the flight of jets and prop planes into and out of the flight arena and airports. The speed (update time) and frequency of the planes depend on the difficulty of the chosen arena.

## OPTIONS
-u

Print the usage line and exit.

-?

Same as -u.

-l

Print a list of available games and exit. The first game name printed is the default game.

-s

Print the score list (formerly the Top Ten list).

-t

Same as -s.

-p

Print the path to the special directory where atc expects to find its private files. This is used during the installation of the program.

-g game

Play the named game. If the game listed is not one of the ones printed from the -l option, the default game is played.

-f game

Same as -g.

-r seed

Set the random seed. The purpose of this flag is questionable.

## GOALS
Your goal in atc is to keep the game going as long as possible. There is no winning state, except to beat the times of other players. You will need to: launch planes at airports (by instructing them to increase their altitude); land planes at airports (by instructing them to go to altitude zero when exactly over the airport); and maneuver planes out of exit points.

Several things will cause the end of the game. Each plane has a destination (see information area), and sending a plane to the wrong destination is an error. Planes can run out of fuel, or can collide. Collision is defined as adjacency in all three dimensions. A plane leaving the arena in any other way than through its destination exit is an error as well.

Scores are sorted in order of the number of planes safe. The other statistics are provided merely for fun. There is no penalty for taking longer than another player (except in the case of ties).

Suspending a game is not permitted. If you get a talk message, tough. When was the last time an Air Traffic Controller got called away to the phone?

## THE DISPLAY
Depending on the terminal you run atc on, the screen will be divided into 4 areas. It should be stressed that the terminal driver portion of the game was designed to be reconfigurable, so the display format can vary depending on the version you are playing. The descriptions here are based on the ascii version of the game. The game rules and input format, however, should remain consistent. Control-L redraws the screen, should it become muddled.

### RADAR
The first screen area is the radar display, showing the relative locations of the planes, airports, standard entry/exit points, radar beacons, and ``lines'' which simply serve to aid you in guiding the planes.

Planes are shown as a single letter with an altitude. If the numerical altitude is a single digit, then it represents thousands of feet. Some distinction is made between the prop planes and the jets. On ascii terminals, prop planes are represented by a upper case letter, jets by a lower case letter.

Airports are shown as a number and some indication of the direction planes must be going to land at the airport. On ascii terminals, this is one of `^', `>', `<', and `v', to indicate north (0 degrees), east (90), west (270) and south (180), respectively. The planes will also take off in this direction.

Beacons are represented as circles or asterisks and a number. Their purpose is to offer a place of easy reference to the plane pilots. See THE DELAY COMMAND section below.

Entry/exit points are displayed as numbers along the border of the radar screen. Planes will enter the arena from these points without warning. These points have a direction associated with them, and planes will always enter the arena from this direction. On the ascii version of atc, this direction is not displayed. It will become apparent what this direction is as the game progresses.

Incoming planes will always enter at the same altitude: 7000 feet. For a plane to successfully depart through an entry/exit point, it must be flying at 9000 feet. It is not necessary for the planes to be flying in any particular direction when they leave the arena (yet).

### INFORMATION AREA
The second area of the display is the information area, which lists the time (number of updates since start), and the number of planes you have directed safely out of the arena. Below this is a list of planes currently in the air, followed by a blank line, and then a list of planes on the ground (at airports). Each line lists the plane name and its current altitude, an optional asterisk indicating low fuel, the plane's destination, and the plane's current command. Changing altitude is not considered to be a command and is therefore not displayed. The following are some possible information lines:

```
B4*A0: Circle @ b1
g7 E4: 225
```

The first example shows a prop plane named `B' that is flying at 4000 feet. It is low on fuel (note the `*'). Its destination is Airport #0. The next command it expects to do is circle when it reaches Beacon #1. The second example shows a jet named `g' at 7000 feet, destined for Exit #4. It is just now executing a turn to 225 degrees (South-West).

### INPUT AREA
The third area of the display is the input area. It is here that your input is reflected. See the INPUT heading of this manual for more details.

### AUTHOR AREA
This area is used simply to give credit where credit is due. :-)

## INPUT
A command completion interface is built into the game. At any time, typing `?' will list possible input characters. Typing a backspace (your erase character) backs up, erasing the last part of the command. When a command is complete, a return enters it, and any semantic checking is done at that time. If no errors are detected, the command is sent to the appropriate plane. If an error is discovered during the check, the offending statement will be underscored and a (hopefully) descriptive message will be printed under it.

The command syntax is broken into two parts: Immediate Only and Delayable commands. Immediate Only commands happen on the next update. Delayable commands also happen on the next update unless they are followed by an optional predicate called the Delay command.

In the following tables, the syntax [0-9] means any single digit, and ⟨dir⟩ refers to a direction, given by the keys around the `s' key: ``wedcxzaq''. In absolute references, `q' refers to North-West or 315 degrees, and `w' refers to North, or 0 degrees. In relative references, `q' refers to -45 degrees or 45 degrees left, and `w' refers to 0 degrees, or no change in direction.

All commands start with a plane letter. This indicates the recipient of the command. Case is ignored.

### IMMEDIATE ONLY COMMANDS
a [ cd+- ] number

Altitude: Change a plane's altitude, possibly requesting takeoff. `+' and `-' are the same as `c' and `d'. a number

Climb or descend to the given altitude (in thousands of feet).

ac number

Climb: relative altitude change.

ad number

Descend: relative altitude change.

m

Mark: Display in highlighted mode. Plane and command information is displayed normally.

i

Ignore: Do not display highlighted. Command is displayed as a line of dashes if there is no command.

u

Unmark: Same as ignore, but if a delayed command is processed, the plane will become marked. This is useful if you want to forget about a plane during part, but not all, of its journey.

### DELAYABLE COMMANDS
c [ lr ]

Circle: Have the plane circle. cl

Left: Circle counterclockwise.

cr

Right: Circle clockwise (default).

t [ l-r+LR ] [ dir ] or tt [ abe* ] number

Turn: Change direction. t<dir>

Turn to direction: Turn to the absolute compass heading given. The shortest turn will be taken.

tl [ dir ]

Left: Turn counterclockwise: 45 degrees by default, or the amount specified in ⟨dir⟩ (not to ⟨dir⟩.) `w' (0 degrees) is no turn. `e' is 45 degrees; `q' gives -45 degrees counterclockwise, that is, 45 degrees clockwise.

t- [ dir ]

Same as left.

tr [ dir ]

Right: Turn clockwise, 45 degrees by default, or the amount specified in ⟨dir⟩.

t+ [ dir ]

Same as right.

tL

Hard left: Turn counterclockwise 90 degrees.

tR

Hard right: Turn clockwise 90 degrees.

tt [abe*]

Towards: Turn towards a beacon, airport or exit. The turn is just an estimate.

tta number

Turn towards the given airport.

ttb number

Turn towards the specified beacon.

tte number

Turn towards an exit.

tt* number

Same as ttb.

### THE DELAY COMMAND
The Delay (a/@) command may be appended to any Delayable command. It allows the controller to instruct a plane to do an action when the plane reaches a particular beacon (or other objects in future versions).

ab number

Do the delayable command when the plane reaches the specified beacon. The `b' for ``beacon'' is redundant to allow for expansion. `@' can be used instead of `a'.

### MARKING, UNMARKING AND IGNORING
Planes are marked by default when they enter the arena. This means they are displayed in highlighted mode on the radar display. A plane may also be either unmarked or ignored. An ignored plane is drawn in unhighlighted mode, and a line of dashes is displayed in the command field of the information area. The plane will remain this way until a mark command has been issued. Any other command will be issued, but the command line will return to a line of dashes when the command is completed.

An unmarked plane is treated the same as an ignored plane, except that it will automatically switch to marked status when a delayed command has been processed. This is useful if you want to forget about a plane for a while, but its flight path has not yet been completely set.

As with all of the commands, marking, unmarking and ignoring will take effect at the beginning of the next update. Do not be surprised if the plane does not immediately switch to unhighlighted mode.

### EXAMPLES
atlab1

Plane A: turn left at beacon #1

cc

Plane C: circle

gtte4ab2

Plane G: turn towards exit #4 at beacon #2

ma+2

Plane M: altitude: climb 2000 feet

stq

Plane S: turn to 315

xi

Plane X: ignore

## OTHER INFORMATION

- Jets move every update; prop planes move every other update.

- All planes turn at most 90 degrees per movement.

- Planes enter at 7000 feet and leave at 9000 feet.

- Planes flying at an altitude of 0 crash if they are not over an airport.

- Planes waiting at airports can only be told to take off (climb in altitude).

- Pressing return (that is, entering an empty command) will perform the next update immediately. This allows you to ``fast forward'' the game clock if nothing interesting is happening.

## NEW GAMES
The Game_List file lists the currently available play fields. New field description file names must be placed in this file to be playable. If a player specifies a game not in this file, his score will not be logged.

The game field description files are broken into two parts. The first part is the definition section. Here, the four tunable game parameters must be set. These variables are set with the syntax:

variable = number;

Variable may be one of: update, indicating the number of seconds between forced updates; newplane, indicating (about) the number of updates between new plane entries; width, indicating the width of the play field; or height, indicating the height of the play field.

The second part of the field description files describes the locations of the exits, the beacons, the airports and the lines. The syntax is as follows:

```

```

beacon:

(x y) ... ;

airport:

(x y direction) ... ;

exit:

(x y direction) ... ;

line:

[ (x1 y1) (x2 y2) ] ... ;

For beacons, a simple x, y coordinate pair is used (enclosed in parenthesis). Airports and exits require a third value, which is one of the directions wedcxzaq. For airports, this is the direction that planes must be going to take off and land, and for exits, this is the direction that planes will be going when they enter the arena. This may not seem intuitive, but as there is no restriction on direction of exit, this is appropriate. Lines are slightly different, since they need two coordinate pairs to specify the line endpoints. These endpoints must be enclosed in square brackets.

All statements are semi-colon (;) terminated. Multiple item statements accumulate. Each definition must occur exactly once, before any item statements. Comments begin with a hash (#) symbol and terminate with a newline. The coordinates are between zero and width-1 and height-1 inclusive. All of the exit coordinates must lie on the borders, and all of the beacons and airports must lie inside of the borders. Line endpoints may be anywhere within the field, so long as the lines are horizontal, vertical or exactly diagonal.

### FIELD FILE EXAMPLE

```
# This is the default game.

update = 5;
newplane = 5;
width = 30;
height = 21;

exit:		( 12  0 x ) ( 29  0 z ) ( 29  7 a ) ( 29 17 a )
		(  9 20 e ) (  0 13 d ) (  0  7 d ) (  0  0 c ) ;

beacon:		( 12  7 ) ( 12 17 ) ;

airport:	( 20 15 w ) ( 20 18 d ) ;

line:		[ (  1  1 ) (  6  6 ) ]
		[ ( 12  1 ) ( 12  6 ) ]
		[ ( 13  7 ) ( 28  7 ) ]
		[ ( 28  1 ) ( 13 16 ) ]
		[ (  1 13 ) ( 11 13 ) ]
		[ ( 12  8 ) ( 12 16 ) ]
		[ ( 11 18 ) ( 10 19 ) ]
		[ ( 13 17 ) ( 28 17 ) ]
		[ (  1  7 ) ( 11  7 ) ] ;
```

## FILES
Files are kept in a special directory. See the OPTIONS section for a way to print this path out. It is normally /usr/share/bsd-games//atc.

This directory contains the file Game_List, which holds the list of playable games, as well as the games themselves.

The scores are kept in /var/games//atc_score.

## AUTHOR
Ed James, UC Berkeley: edjames@ucbvax.berkeley.edu, ucbvax!edjames

This game is based on someone's description of the overall flavor of a game written for some unknown PC many years ago, maybe.

## BUGS
The screen sometimes refreshes after you have quit.


backgammon

title: backgammon(6)

summary: the game of backgammon

text:
# backgammon(6)

## NAME
backgammon — the game of backgammon

teachgammon — learn to play backgammon

## SYNOPSIS
backgammon

[-] [-nrwb] [-pr] [-pw] [-pb] [-t term] [-s file]

teachgammon

## DESCRIPTION
This program lets you play backgammon against the computer or against a "friend". All commands are only one letter, so you don't need to type a carriage return, except at the end of a move. The program is mostly self-explanatory, so that a question mark (?) will usually get some help. If you answer `y' when the program asks if you want the rules, you will get text explaining the rules of the game, some hints on strategy, instructions on how to use the program, and a tutorial consisting of a practice game against the computer. A description of how to use the program can be obtained by answering `y' when it asks if you want instructions.

The possible arguments for backgammon (most are unnecessary but some are very convenient) consist of:

-n

don't ask for rules or instructions

-r

player is red (implies n)

-w

player is white (implies n)

-b

two players, red and white (implies n)

-pr

print the board before red's turn

-pw

print the board before white's turn

-pb

print the board before both player's turn

-t term

terminal is type term, uses /usr/share/misc/termcap

-s file

recover previously saved game from file

Any unrecognized arguments are ignored. An argument of a lone `-' gets a description of possible arguments.

If term has capabilities for direct cursor movement (see termcap(5)) backgammon ``fixes'' the board after each move, so the board does not need to be reprinted, unless the screen suffers some horrendous malady. Also, any `p' option will be ignored. (The `t' option is not necessary unless the terminal type does not match the entry in the /usr/share/misc/termcap data base.)

## QUICK REFERENCE
When the program prompts by typing only your color, type a space or carriage return to roll, or

d

to double

p

to print the board

q

to quit

s

to save the game for later

When the program prompts with 'Move:', type

p

to print the board

q

to quit

s

to save the game

or a move, which is a sequence of

s-f

move from s to f

s/r

move one man on s the roll r separated by commas or spaces and ending with a newline. Available abbreviations are s-f1-f2

means s-f1,f1-f2

s/r1r2

means s/r1,s/r2

Use b for bar and h for home, or 0 or 25 as appropriate.

## AUTHOR
Alan Char

## FILES
/usr/bin/teachgammon

rules and tutorial

/usr/share/misc/termcap

terminal capabilities

## BUGS
The program's strategy needs much work.


battlestar

title: battlestar(6)

summary: a tropical adventure game

text:
# battlestar(6)

## NAME
battlestar — a tropical adventure game

## SYNOPSIS
battlestar

[-r] [saved-file]

## DESCRIPTION
battlestar is an adventure game in the classic style. However, it's slightly less of a puzzle and more a game of exploration. There are a few magical words in the game, but on the whole, simple English should suffice to make one's desires understandable to the parser.

## THE SETTING
In the days before the darkness came, when battlestars ruled the heavens...

```
Three He made and gave them to His daughters,
Beautiful nymphs, the goddesses of the waters.
One to bring good luck and simple feats of wonder,
Two to wash the lands and churn the waves asunder,
Three to rule the world and purge the skies with thunder.
```

In those times great wizards were known and their powers were beyond belief. They could take any object from thin air, and, uttering the word ‘su’ could disappear.

In those times men were known for their lust for gold and desire to wear fine weapons. Swords and coats of mail were fashioned that could withstand a laser blast.

But when the darkness fell, the rightful reigns were toppled. Swords and helms and heads of state went rolling across the grass. The entire fleet of battlestars was reduced to a single ship.

## SAMPLE COMMANDS

```
take	---	take an object
drop	---	drop an object

wear	---	wear an object you are holding
draw	---	carry an object you are wearing

put on	---	take an object and wear it
take off --	draw an object and drop it

throw  <object> <direction>

!	<shell esc>
```

## IMPLIED OBJECTS

```
>-: take watermelon
watermelon:
Taken.
>-: eat
watermelon:
Eaten.
>-: take knife and sword and apple, drop all
knife:
Taken.
broadsword:
Taken.
apple:
Taken.
knife:
Dropped.
broadsword:
Dropped.
apple:
Dropped.
>-: get
knife:
Taken.
```

Notice that the "shadow" of the next word stays around if you want to take advantage of it. That is, saying "take knife" and then "drop" will drop the knife you just took.

## SCORE & INVEN
The two commands “score” and “inven” will print out your current status in the game.

## SAVING A GAME
The command “save” will save your game in a file called .Bstar in your home directory by default. You can recover a saved game by using the -r option when you start up the game, or by giving the name of the saved file as an argument. Save files will be saved to and restored from your home directory unless a path is specified - i.e., “battlestar -r savedgame” will look for savedgame in your home directory, but “battlestar -r ./savedgame” will look in the current directory. “battlestar -r” will look for the default file, .Bstar in your home directory.

## DIRECTIONS
The compass directions N, S, E, and W can be used if you have a compass. If you don't have a compass, you'll have to say R, L, A, or B, which stand for Right, Left, Ahead, and Back. Directions printed in room descriptions are always printed in R, L, A, and B relative directions.

## HISTORY
I wrote Battlestar in 1979 in order to experiment with the niceties of the C Language. Most interesting things that happen in the game are hardwired into the code, so don't send me any hate mail about it! Instead, enjoy art for art's sake!

## AUTHOR
David Riggle

## INSPIRATION & ASSISTANCE

- Chris Guthrie

- Peter Da Silva

- Kevin Brown

- Edward Wang

- Ken Arnold & Company

## BUGS
Countless.

## FAN MAIL
Send to edward%ucbarpa@berkeley.arpa, chris%ucbcory@berkeley.arpa, riggle.pa@xerox.arpa.


bcd

title: bcd(6)

text:
# bcd(6)

## NAME
bcd, ppt, morse — reformat input as punch cards, paper tape or morse code

## SYNOPSIS
bcd

[string ...]

ppt

[-d|string ...]

morse

[-ds string ...]

## DESCRIPTION
The bcd, ppt and morse commands read the given input and reformat it in the form of punched cards, paper tape or morse code respectively. Acceptable input are command line arguments or the standard input.

Available option:

-s

The -s option for morse produces dots and dashes rather than words.

-d

Decode ppt output, or morse output consisting of dots and slashes (as generated by using the -s option).

## SEE ALSO
ISO 1681:1973: Information processing--Unpunched paper cards--Specification.

ISO 1682:1973: Information processing--80 columns punched paper cards--Dimensions and location of rectangular punched holes.

ECMA-10: ECMA Standard for Data Interchange on Punched Tape.

ITU-T Recommendation F.1: Operational provisions for the international public telegram service, Division B, I. Morse code.


boggle

title: boggle(6)

summary: word search game

text:
# boggle(6)

## NAME
boggle — word search game

## SYNOPSIS
boggle

[-bd] [-s seed] [-t time] [-w length] [+ [+]] [boardspec]

## DESCRIPTION
The object of boggle is to find as many words as possible on the Boggle board within the three minute time limit. A Boggle board is a four by four arrangement of Boggle cubes, each side of each cube displaying a letter of the alphabet or `qu'. Words are formed by finding a sequence of cubes (letters) that are in the game's dictionary. The (N+1)th cube in the word must be horizontally, vertically, or diagonally adjacent to the Nth cube. Cubes cannot be reused. Words consist solely of lower case letters and must be at least 3 letters long.

Command line flags can be given to change the rules of the game.

-b

Run boggle in batch mode. A boardspec must also be given. The dictionary is read from stdin and a list of words appearing in boardspec is printed to stdout.

-d

Enable debugging output.

-s seed

Specify a seed seed other than the time of day.

-t time

Set the time limit for each game from the default 3 minutes to time seconds.

-w length

Change the minimum word length from 3 letters to length.

+

This flag allows a cube to be used multiple times, but not in succession.

++

This flag allows the same cubes to be considered adjacent to itself.

boardspec

A starting board position can be specified on the command line by listing the board left to right and top to bottom.

Help is available during play by typing ‘?’. More detailed information on the game is given there.

## BUGS
If there are a great many words in the cube the final display of the words may scroll off of the screen. (On a 25 line screen about 130 words can be displayed.)

No word can contain a ‘q’ that is not immediately followed by a ‘u’.

When using the + or ++ options the display of words found in the board doesn't indicate reused cubes.

## AUTHOR
Boggle is a trademark of Parker Brothers.

Barry Brachman

Dept. of Computer Science

University of British Columbia


bsd-fbg

title: bsd-fbg(6)

summary: a falling block game

text:
# bsd-fbg(6)

## NAME
bsd-fbg — a falling block game

## SYNOPSIS
bsd-fbg

[-ps] [-k keys] [-l level]

## DESCRIPTION
The bsd-fbg command runs a display-based game which must be played on a CRT terminal. The object is to fit the shapes together forming complete rows, which then vanish. When the shapes fill up to the top, the game ends. You can optionally select a level of play, or custom-select control keys.

The default level of play is 2.

The default control keys are as follows:

j

move left

k

rotate 1/4 turn counterclockwise

l

move right

⟨space⟩

drop

p

pause

q

quit

The options are as follows:

-k

The default control keys can be changed using the -k option. The keys argument must have the six keys in order, and, remember to quote any space or tab characters from the shell. For example:

bsd-fbg -l 2 -k 'jkl pq'

will play the default games, i.e. level 2 and with the default control keys. The current key settings are displayed at the bottom of the screen during play.

-l

Select a level of play.

-s

Display the top scores.

-p

Switch on previewing of the shape that will appear next.

## PLAY
At the start of the game, a shape will appear at the top of the screen, falling one square at a time. The speed at which it falls is determined directly by the level: if you select level 2, the blocks will fall twice per second; at level 9, they fall 9 times per second. (As the game goes on, things speed up, no matter what your initial selection.) When this shape “touches down” on the bottom of the field, another will appear at the top.

You can move shapes to the left or right, rotate them counterclockwise, or drop them to the bottom by pressing the appropriate keys. As you fit them together, completed horizontal rows vanish, and any blocks above fall down to fill in. When the blocks stack up to the top of the screen, the game is over.

## SCORING
You get one point for every block you fit into the stack, and one point for every space a block falls when you hit the drop key. (Dropping the blocks is therefore a good way to increase your score.) Your total score is the product of the level of play and your accumulated points -- 200 points on level 3 gives you a score of 600. Each player gets at most one entry on any level, for a total of nine scores in the high scores file. Players who no longer have accounts are limited to one score. Also, scores over 5 years old are expired. The exception to these conditions is that the highest score on a given level is always kept, so that following generations can pay homage to those who have wasted serious amounts of time.

The score list is produced at the end of the game. The printout includes each player's overall ranking, name, score, and how many points were scored on what level. Scores which are the highest on a given level are marked with asterisks “*”.

## FILES
/var/games/bsd-fbg.scores

high score file

## BUGS
The higher levels are unplayable without a fast terminal connection.

## AUTHORS
Adapted from a 1989 International Obfuscated C Code Contest winner by Chris Torek and Darren F. Provine.

Manual adapted from the original entry written by Nancy L. Tinkham and Darren F. Provine.

Code for previewing next shape added by Hubert Feyrer in 1999.


caesar

title: caesar(6)

summary: decrypt caesar ciphers

text:
# caesar(6)

## NAME
caesar, rot13 — decrypt caesar ciphers

## SYNOPSIS
caesar

[rotation]

## DESCRIPTION
The caesar utility attempts to decrypt caesar ciphers using English letter frequency statistics. caesar reads from the standard input and writes to the standard output.

The optional numerical argument rotation may be used to specify a specific rotation value.

The frequency (from most common to least) of English letters is as follows:

ETAONRISHDLFCMUGPYWBVKXJQZ

Their frequencies as a percentage are as follows:

E(13), T(10.5), A(8.1), O(7.9), N(7.1), R(6.8), I(6.3), S(6.1), H(5.2), D(3.8), L(3.4), F(2.9), C(2.7), M(2.5), U(2.4), G(2), P(1.9), Y(1.9), W(1.5), B(1.4), V(.9), K(.4), X(.15), J(.13), Q(.11), Z(.07).

Rotated postings to USENET and some of the databases used by the fortune(6) program are rotated by 13 characters.


canfield

title: canfield(6)

summary: the solitaire card game canfield

text:
# canfield(6)

## NAME
canfield, cfscores — the solitaire card game canfield

## SYNOPSIS
canfield

cfscores

[-a] [user]

## DESCRIPTION
If you have never played solitaire before, it is recommended that you consult a solitaire instruction book. In Canfield, tableau cards may be built on each other downward in alternate colors. An entire pile must be moved as a unit in building. Top cards of the piles are available to be played on foundations, but never into empty spaces.

Spaces must be filled from the stock. The top card of the stock also is available to be played on foundations or built on tableau piles. After the stock is exhausted, tableau spaces may be filled from the talon and the player may keep them open until he wishes to use them.

Cards are dealt from the hand to the talon by threes and this repeats until there are no more cards in the hand or the player quits. To have cards dealt onto the talon the player types ‘ht’ for his move. Foundation base cards are also automatically moved to the foundation when they become available.

The command ‘c’ causes canfield to maintain card counting statistics on the bottom of the screen. When properly used this can greatly increase one's chances of winning.

The rules for betting are somewhat less strict than those used in the official version of the game. The initial deal costs $13. You may quit at this point or inspect the game. Inspection costs $13 and allows you to make as many moves as possible without moving any cards from your hand to the talon. (The initial deal places three cards on the talon; if all these cards are used, three more are made available.) Finally, if the game seems interesting, you must pay the final installment of $26. At this point you are credited at the rate of $5 for each card on the foundation; as the game progresses you are credited with $5 for each card that is moved to the foundation. Each run through the hand after the first costs $5. The card counting feature costs $1 for each unknown card that is identified. If the information is toggled on, you are only charged for cards that became visible since it was last turned on. Thus the maximum cost of information is $34. Playing time is charged at a rate of $1 per minute.

With no arguments, the program cfscores prints out the current status of your canfield account. If a user name is specified, it prints out the status of their canfield account. If the -a flag is specified, it prints out the canfield accounts for all users that have played the game since the database was set up.

## FILES
/usr/bin/canfield

the game itself

/usr/bin/cfscores

the database printer

/var/games//cfscores

the database of scores

## BUGS
It is impossible to cheat.

## AUTHORS
Originally written: Steve Levine.

Further random hacking by: Steve Feldman, Kirk McKusick, Mikey Olson, and Eric Allman.


cribbage

title: cribbage(6)

summary: the card game cribbage

text:
# cribbage(6)

## NAME
cribbage — the card game cribbage

## SYNOPSIS
cribbage

[-eqr]

## DESCRIPTION
cribbage plays the card game cribbage, with the program playing one hand and the user the other. The program will initially ask the user if the rules of the game are needed – if so, it will print out the appropriate section from According to Hoyle with more(1).

cribbage options include:

-e

When the player makes a mistake scoring his hand or crib, provide an explanation of the correct score. (This is especially useful for beginning players.)

-q

Print a shorter form of all messages – this is only recommended for users who have played the game without specifying this option.

-r

Instead of asking the player to cut the deck, the program will randomly cut the deck.

cribbage first asks the player whether he wishes to play a short game ( “once around”, to 61) or a long game ( “twice around”, to 121). A response of ‘s’ will result in a short game, any other response will play a long game.

At the start of the first game, the program asks the player to cut the deck to determine who gets the first crib. The user should respond with a number between 0 and 51, indicating how many cards down the deck is to be cut. The player who cuts the lower ranked card gets the first crib. If more than one game is played, the loser of the previous game gets the first crib in the current game.

For each hand, the program first prints the player's hand, whose crib it is, and then asks the player to discard two cards into the crib. The cards are prompted for one per line, and are typed as explained below.

After discarding, the program cuts the deck (if it is the player's crib) or asks the player to cut the deck (if it's its crib); in the latter case, the appropriate response is a number from 0 to 39 indicating how far down the remaining 40 cards are to be cut.

After cutting the deck, play starts with the non-dealer (the person who doesn't have the crib) leading the first card. Play continues, as per cribbage, until all cards are exhausted. The program keeps track of the scoring of all points and the total of the cards on the table.

After play, the hands are scored. The program requests the player to score his hand (and the crib, if it is his) by printing out the appropriate cards (and the cut card enclosed in brackets). Play continues until one player reaches the game limit (61 or 121).

A carriage return when a numeric input is expected is equivalent to typing the lowest legal value; when cutting the deck this is equivalent to choosing the top card.

Cards are specified as rank followed by suit. The ranks may be specified as one of: ‘a’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’, ‘t’, ‘j’, ‘q’, and ‘k’, or alternatively, one of: ‘ace’, ‘two’, ‘three’, ‘four’, ‘five’, ‘six’, ‘seven’, ‘eight’, ‘nine’, ‘ten’, ‘jack’, ‘queen’, and ‘king’. Suits may be specified as: ‘s’, ‘h’, ‘d’, and ‘c’, or alternatively as: ‘spades’, ‘hearts’, ‘diamonds’, and ‘clubs’. A card may be specified as: “⟨rank⟩ ⟨suit⟩”, or: “⟨rank⟩ of ⟨suit⟩”. If the single letter rank and suit designations are used, the space separating the suit and rank may be left out. Also, if only one card of the desired rank is playable, typing the rank is sufficient. For example, if your hand was “2H, 4D, 5C, 6H, JC, and KD” and it was desired to discard the king of diamonds, any of the following could be typed: ‘k’, ‘king’, ‘kd’, ‘k d’, ‘k of d’, ‘king d’, ‘king of d’, ‘k diamonds’, ‘k of diamonds’, ‘king diamonds’, ‘king of diamonds’.

## FILES
/usr/bin/cribbage

/var/games//criblog

/usr/share/bsd-games//cribbage.instr

## AUTHORS
Earl T. Cohen wrote the logic. Ken Arnold added the screen oriented interface.


dab

title: dab(6)

summary: Dots and Boxes game

text:
# dab(6)

## NAME
dab — Dots and Boxes game

## SYNOPSIS
dab

[-aw] [-n ngames] [-p ⟨c|h⟩⟨c|h⟩] [xdim [ydim]]

## DESCRIPTION
dab is a game where each player tries to complete the most boxes. A turn consists of putting one border of a box; the player setting the fourth and final border of a box gets the point for the box and has another turn.

The keys used are the vi keys: k for up, j for down, h for left, and l for right. To switch between even and odd rows, use one of the following keys: u (diagonal right up), y (diagonal left up), b (diagonal left down), n (diagonal right down); ⟨space⟩ sets a new border, CTRL-L and CTRL-R redraw the screen, and q quits the game.

Support options are:

-a

Don't use the alternate character set.

-n ngames

ngames games will be played. (Especially useful in -p cc mode.)

-p ⟨c|h⟩⟨c|h⟩

Select which of the two players is a human or a computer. The first argument is the first player; c stands for computer and h for human.

-w

Wait for a character press between games.

xdim and ydim define the size of the board in the x and y dimensions.

## AUTHORS
Christos Zoulas ⟨christos@NetBSD.org⟩

## SEE ALSO
Elwyn R. Berlekamp, The Dots and Boxes Game: Sophisticated Child's Play, A K Peters, 2000, http://www.akpeters.com/book.asp?bID=111.


go-fish

title: go-fish(6)

summary: play

text:
# go-fish(6)

## NAME
go-fish — play “Go Fish”

## SYNOPSIS
go-fish

[-p]

## DESCRIPTION
go-fish is the game “Go Fish”, a traditional children's card game.

The computer deals the player and itself seven cards, and places the rest of the deck face-down (figuratively). The object of the game is to collect “books”, or all of the members of a single rank. For example, collecting four 2's would give the player a “book of 2's”.

The options are as follows:

-p

Professional mode.

The computer makes a random decision as to who gets to start the game, and then the computer and player take turns asking each other for cards of a specified rank. If the asked player has any cards of the requested rank, they give them up to the asking player. A player must have at least one of the cards of the rank they request in their hand. When a player asks for a rank of which the other player has no cards, the asker is told to “Go Fish!”. Then, the asker draws a card from the non-dealt cards. If they draw the card they asked for, they continue their turn, asking for more ranks from the other player. Otherwise, the other player gets a turn.

When a player completes a book, either by getting cards from the other player or drawing from the deck, they set those cards aside and the rank is no longer in play.

The game ends when either player no longer has any cards in their hand. The player with the most books wins.

go-fish provides instructions as to what input it accepts.

## BUGS
The computer cheats only rarely.


gomoku

title: gomoku(6)

summary: game of 5 in a row

text:
# gomoku(6)

## NAME
gomoku — game of 5 in a row

## SYNOPSIS
gomoku

[-bcdu] [-D debugfile] [inputfile]

## DESCRIPTION
gomoku is a two player game where the object is to get 5 in a row horizontally, vertically or diagonally on a 19 by 19 grid. By convention, black always moves first. With no arguments, gomoku will display a playing board and prompt for moves from the user. Valid moves are a letter for the column and a number for the row of an empty board location. Entering ``quit" or ``resign" will end the game. You can save the current state of the game by entering ``save" and supplying a file name when prompted. The optional file inputfile can be used to restore a saved game.

The options are:

-b

This option sets background mode. Input moves are read from standard input, the computer picks a move, and prints it to standard output. The first input line should be either ``black" or ``white" to specify whether gomoku has the first move or not respectively. This option was intended for game tournaments where a referee program handles the board display and pits one program against another.

-c

Computer versus computer. gomoku will play a game against itself. This is mostly used for testing.

-d

Print debugging information. Repeating this option more than once yields more detailed information.

-D debugfile

Print the debug information to debugfile instead of to the standard output.

-u

User versus user. This is mostly used for testing.

## AUTHOR
Ralph Campbell

## ACKNOWLEDGEMENTS
The board display routines were based on the goref program written by Peter Langston.


hack

title: hack(6)

summary: exploring The Dungeons of Doom

text:
# hack(6)

## NAME
hack — exploring The Dungeons of Doom

## SYNOPSIS
hack

[-d directory] [-n] [-u playername]

hack

[-d directory] [-s] [-X] [playername ...]

## DESCRIPTION
hack is a display oriented dungeons & dragons-like game. Both display and command structure resemble rogue. (For a game with the same structure but entirely different display - a real cave instead of dull rectangles - try Quest.)

To get started you really only need to know two commands. The command ? will give you a list of the available commands and the command / will identify the things you see on the screen.

To win the game (as opposed to merely playing to beat other people's high scores) you must locate the Amulet of Yendor which is somewhere below the 20th level of the dungeon and get it out. Nobody has achieved this yet and if somebody does, he will probably go down in history as a hero among heroes.

When the game ends, either by your death, when you quit, or if you escape from the caves, hack will give you (a fragment of) the list of top scorers. The scoring is based on many aspects of your behavior but a rough estimate is obtained by taking the amount of gold you've found in the cave plus four times your (real) experience. Precious stones may be worth a lot of gold when brought to the exit. There is a 10% penalty for getting yourself killed.

The administration of the game is kept in the directory specified with the -d option, or, if no such option is given, in the directory specified by the environment variable HACKDIR, or, if no such variable exists, in the current directory. This same directory contains several auxiliary files such as lockfiles and the list of topscorers and a subdirectory save where games are saved. The game administrator may however choose to install hack with a fixed playing ground, usually /var/games/hack.

The -n option suppresses printing of the news.

The -u playername option supplies the answer to the question "Who are you?". When playername has as suffix one of -T, -S, -K, -F, -C, or -W, then this supplies the answer to the question "What kind of character ... ?".

The -s option will print out the list of your scores. It may be followed by arguments -X where X is one of the letters C, F, K, S, T, W to print the scores of Cavemen, Fighters, Knights, Speleologists, Tourists or Wizards. It may also be followed by one or more player names to print the scores of the players mentioned.

## AUTHORS
Jay Fenlason (+ Kenny Woodland, Mike Thome and Jon Payne) wrote the original hack, very much like rogue (but full of bugs).

Andries Brouwer continuously deformed their sources into the current version - in fact an entirely different game.

## FILES
hack

The hack program.

data, rumors

Data files used by hack.

help, hh

Help data files.

record

The list of topscorers.

save

A subdirectory containing the saved games.

bones_dd

Descriptions of the ghost and belongings of a deceased adventurer.

xlock.dd

Description of a dungeon level.

safelock

Lock file for xlock.

record_lock

Lock file for record.

## ENVIRONMENT
USER or LOGNAME

Your login name.

HOME

Your home directory.

SHELL

Your shell.

TERM

The type of your terminal.

HACKPAGER, PAGER

Pager used instead of default pager.

MAIL

Mailbox file.

MAILREADER

Reader used instead of default (probably /usr/bin/mail).

HACKDIR

Playground.

HACKOPTIONS

String predefining several hack options (see help file).

Several other environment variables are used in debugging (wizard) mode, like GENOCIDED, INVENT, MAGIC and SHOPTYPE.

## BUGS
Probably infinite. Mail complaints to mcvax!aeb .


hangman

title: hangman(6)

summary: computer version of the game hangman

text:
# hangman(6)

## NAME
hangman — computer version of the game hangman

## SYNOPSIS
hangman

[-d wordlist] [-m minlen]

## DESCRIPTION
In hangman, the computer picks a word from the on-line word list and you must try to guess it. The computer keeps track of which letters have been guessed and how many wrong guesses you have made on the screen in a graphic fashion.

## OPTIONS
-d

Use the specified wordlist instead of the default one named below.

-m

Set the minimum word length to use. The default is 6 letters.

## FILES
/usr/share/dict/words

On-line word list

## AUTHORS
Ken Arnold


hunt

title: hunt(6)

summary: a multi-player multi-terminal game

text:
# hunt(6)

## NAME
hunt — a multi-player multi-terminal game

## SYNOPSIS
hunt

[-bcfmqSs] [-n name] [-t team] [-p port] [-w message] [host]

## DESCRIPTION
The object of the game hunt is to kill off the other players. There are no rooms, no treasures, and no monsters. Instead, you wander around a maze, find grenades, trip mines, and shoot down walls and players. The more players you kill before you die, the better your score is. If the -m flag is given, you enter the game as a monitor (you can see the action but you cannot play).

hunt normally looks for an active game on the local network; if none is found, it starts one up on the local host. The location of the game may be specified by giving the host argument. This presupposes that a hunt game is already running on that host, see huntd(6) for details on how to set up a game on a specific host. If more than one game if found, you may pick which game to play in.

If the -q flag is given, hunt queries the local network (or specific host) and reports on all active games found. This is useful for shell startup scripts, e.g., csh(1)'s .login.

The player name may be specified on the command line by using the -n option.

The -c, -s, and -f options are for entering the game cloaked, scanning, or flying respectively.

The -b option turns off beeping when you reach the typeahead limit.

The -t option aids team playing by making everyone else on one's team appear as the team name. A team name is a single digit to avoid conflicting with other characters used in the game.

The -p port option allows the rendezvous port number to be set. This is a useful way for people playing on dialup lines to avoid playing with people on 9600 baud terminals.

The -w message option is the only way to send a message to everyone else's screen when you start up. It is most often used to say “eat slime death - NickD's coming in”.

When you die and are asked if you wish to re-enter the game, there are other answers than just yes or no. You can also reply with a w for write a message before continuing or o to change how you enter the game (cloaked, scanning, or flying).

To be notified automatically when a hunt starts up, add your login to the hunt-players mailing list (see huntd(6)).

## PLAYING HINTS
hunt only works on CRT (vdt) terminals with at least 24 lines, 80 columns, and cursor addressing. The screen is divided in to 3 areas. On the right hand side is the status area. It shows damage sustained, charges remaining, who's in the game, who's scanning (the “*” in front of the name), who's cloaked (the “+” in front of the name), and other players' scores. The rest of the screen is taken up by your map of the maze. The 24th line is used for longer messages that don't fit in the status area.

hunt uses the same keys to move as vi(1) does, i.e., h, j, k, and l for left, down, up, right respectively. To change which direction you're facing in the maze, use the upper case version of the movement key (i.e., HJKL). You can only fire or throw things in the direction you're facing. Other commands are:

f or 1

Fire a bullet (Takes 1 charge)

g or 2

Throw grenade (Takes 9 charges)

F or 3

Throw satchel charge (Takes 25 charges)

G or 4

Throw bomb (Takes 49 charges)

5

Throw big bomb (Takes 81 charges)

6

Throw even bigger bomb (Takes 121 charges)

7

Throw even more big bomb (Takes 169 charges)

8

Throw even more bigger bomb (Takes 225 charges)

9

Throw very big bomb (Takes 289 charges)

0

Throw very, very big bomb (Takes 361 charges)

@

Throw biggest bomb (Takes 441 charges)

o

Throw small slime (Takes 5 charges)

O

Throw big slime (Takes 10 charges)

p

Throw bigger slime (Takes 15 charges)

P

Throw biggest slime (Takes 20 charges)

s

Scan (show where other players are) (Takes 1 charge)

c

Cloak (hide from scanners) (Takes 1 charge)

^L

Redraw screen

q

Quit

The symbols on the screen are:

-|+

walls

/\

diagonal (deflecting) walls

\#

doors (dispersion walls)

;

small mine

g

large mine

:

bullet

o

grenade

O

satchel charge

@

bomb

s

small slime

$

big slime

><^v

you facing right, left, up, or down

}{i!

other players facing right, left, up, or down

*

explosion

\|/

-*-

grenade and large mine explosion

/|\

Other helpful hints:

- You can only fire in the direction you are facing.

- You can only fire three shots in a row, then the gun must cool off.

- Shots move 5 times faster than you do.

- To stab someone, you face that player and move at them.

- Stabbing does 2 points worth of damage and shooting does 5 points.

- Slime does 5 points of damage each time it hits.

- You start with 15 charges and get 5 more every time a player enters or re-enters.

- Grenade explosions cover a 3 by 3 area, each larger bomb cover a correspondingly larger area (ranging from 5 by 5 to 21 by 21). All explosions are centered around the square the shot hits and do the most damage in the center.

- Slime affects all squares it oozes over. The number of squares is equal to the number of charges used.

- One small mine and one large mine is placed in the maze for every new player. A mine has a 2% probability of tripping when you walk forward on to it; 50% when going sideways; 95% when backing up. Tripping a mine costs you 5 points or 10 points respectively. Defusing a mine is worth 1 charge or 9 charges respectively.

- You cannot see behind you.

- Cloaking consumes 1 ammo charge per 20 of your moves.

- Scanning consumes 1 ammo charge per (20 × the number of players) of other player moves.

- Turning on cloaking turns off scanning — turning on scanning turns off cloaking.

- When you kill someone, you get 2 more damage capacity points and 2 damage points get taken away.

- Maximum typeahead is 5 characters.

- A shot destroys normal (i.e., non-diagonal, non-door) walls.

- Diagonal walls deflect shots and change orientation.

- Doors disperse shots in random directions (up, down, left, right).

- Diagonal walls and doors cannot be destroyed by direct shots but may be destroyed by an adjacent grenade explosion.

- Slime goes around walls, not through them.

- Walls regenerate, reappearing in the order they were destroyed. One percent of the regenerated walls will be diagonal walls or doors. When a wall is generated directly beneath a player, he is thrown in a random direction for a random period of time. When he lands, he sustains damage (up to 20 percent of the amount of damage already sustained); i.e., the less damage he had, the more nimble he is and therefore less likely to hurt himself on landing.

- Every 30 deaths or so, a “?” will appear. It is a wandering bomb which will explode when it hits someone, or when it is slimed.

- If no one moves, everything stands still.

- The environment variable HUNT is checked to get the player name. If you don't have this variable set, hunt will ask you what name you want to play under. If you wish to set other options than just your name, you can enumerate the options as follows: setenv HUNT name=Sneaky,team=1,cloak,mapkey=zoFfGg1f2g3F4G

sets the player name to Sneaky, sets the team to one, sets the enter game attribute to cloaked, and the maps z to o, F to f, G to g, 1 to f, 2 to g, 3 to F, and 4 to G. The mapkey option must be last. Other options are: scan, fly, nobeep, port=string, host=string, and message=string, which correspond to the command line options. String options cannot contain commas since commas are used to separate options.

- It's a boring game if you're the only one playing.

Your score is the decayed average of the ratio of number of kills to number of times you entered the game and is only kept for the duration of a single session of hunt.

hunt normally drives up the load average to be approximately (number_of_players + 0.5) greater than it would be without a hunt game executing.

## STATISTICS
The -S option fetches the current game statistics. The meaning of the column headings are as follows:

score

the player's last score

ducked

how many shots a player ducked

absorb

how many shots a player absorbed

faced

how many shots were fired at player's face

shot

how many shots were fired at player

robbed

how many of player's shots were absorbed

missed

how many of player's shots were ducked

slimeK

how many slime kills player had

enemy

how many enemies were killed how many friends were killed (self and same team)

deaths

how many times player died

still

how many times player died without typing in any commands

saved

how many times a shot/bomb would have killed player if he hadn't ducked or absorbed it.

## SEE ALSO
huntd(6)

## AUTHORS
Conrad Huang, Ken Arnold, and Greg Couch;

University of California, San Francisco, Computer Graphics Lab

## ACKNOWLEDGEMENTS
We thank Don Kneller, John Thomason, Eric Pettersen, Mark Day, and Scott Weiner for providing endless hours of play-testing to improve the character of the game. We hope their significant others will forgive them; we certainly don't.

## BUGS
To keep up the pace, not everything is as realistic as possible.


huntd

title: huntd(6)

summary: hunt daemon, back-end for hunt game

text:
# huntd(6)

## NAME
huntd — hunt daemon, back-end for hunt game

## SYNOPSIS
huntd

[-s] [-p port]

## DESCRIPTION
huntd controls the multi-player hunt(6) game. When it starts up, it tries to notify all members of the hunt-players mailing list (see sendmail(8)) by faking a talk(1) request from user “Hunt Game”.

The -s option is for running huntd forever (server mode). This is similar to running it under the control of inetd(8) (see below), but it consumes a process table entry when no one is playing.

The -p option changes the UDP port number used to rendezvous with the player process and thus allows for private games of hunt. This option turns off the notification of players on the hunt-players mailing list.

### INETD
To run huntd from inetd(8), you'll need to put the hunt service in /etc/services:

```
hunt 26740/udp		# multi-player/multi-host mazewars
```

and add the following line to /etc/inetd.conf:

```
hunt dgram udp wait nobody /usr/sbin/huntd huntd
```

Do not use any of the command line options; if you want inetd(8) to start up huntd on a private port, change the port listed for hunt in /etc/services.

## NETWORK RENDEZVOUS
When hunt(6) starts up, it broadcasts on the local area net (using the broadcast address for each interface) to find a hunt game in progress. If a huntd hears the request, it sends back the port number for the hunt process to connect to. Otherwise, the hunt process starts up a huntd on the local machine and tries to rendezvous with it.

## SEE ALSO
talk(1), hunt(6), sendmail(8)

## AUTHORS
Conrad Huang, Ken Arnold, and Greg Couch;

University of California, San Francisco, Computer Graphics Lab


mille

title: mille(6)

summary: play Mille Bornes

text:
# mille(6)

## NAME
mille - play Mille Bornes

## SYNOPSIS
mille [ file ]

## DESCRIPTION
Mille plays a two-handed game reminiscent of the Parker Brother's game of Mille Bornes with you. The rules are described below. If a file name is given on the command line, the game saved in that file is started.

When a game is started up, the bottom of the score window will contain a list of commands. They are:

P

Pick a card from the deck. This card is placed in the `P' slot in your hand.

D

Discard a card from your hand. To indicate which card, type the number of the card in the hand (or “P” for the just-picked card) followed by a <RETURN> or <SPACE>. The <RETURN or <SPACE> is required to allow recovery from typos which can be very expensive, like discarding safeties.

U

Use a card. The card is again indicated by its number, followed by a <RETURN> or <SPACE>.

O

Toggle ordering the hand. By default off, if turned on it will sort the cards in your hand appropriately. This is not recommended for the impatient on slow terminals.

Q

Quit the game. This will ask for confirmation, just to be sure. Hitting <DELETE> (or <RUBOUT>) is equivalent.

S

Save the game in a file. If the game was started from a file, you will be given an opportunity to save it on the same file. If you don't wish to, or you did not start from a file, you will be asked for the file name. If you type a <RETURN> without a name, the save will be terminated and the game resumed.

R

Redraw the screen from scratch. The command ^L (control `L') will also work.

W

Toggle window type. This switches the score window between the startup window (with all the command names) and the end-of-game window. Using the end-of-game window saves time by eliminating the switch at the end of the game to show the final score. Recommended for hackers and other miscreants.

If you make a mistake, an error message will be printed on the last line of the score window, and a bell will beep.

At the end of each hand or game, you will be asked if you wish to play another. If not, it will ask you if you want to save the game. If you do, and the save is unsuccessful, play will be resumed as if you had said you wanted to play another hand/game. This allows you to use the “S” command to reattempt the save.

## AUTHOR
Ken Arnold

(The game itself is a product of Parker Brothers, Inc.)

## SEE ALSO
curses(3X), Screen Updating and Cursor Movement Optimization: A Library Package, Ken Arnold

## CARDS
Here is some useful information. The number in parentheses after the card name is the number of that card in the deck:

```
Hazard	Repair	Safety

Out of Gas (2)	Gasoline (6)	Extra Tank (1)
Flat Tire (2)	Spare Tire (6)	Puncture Proof (1)
Accident (2)	Repairs (6)	Driving Ace (1)
Stop (4)	Go (14)	Right of Way (1)
Speed Limit (3)	End of Limit (6)

25 - (10), 50 - (10), 75 - (10), 100 - (12), 200 - (4)
```

## RULES
Object: The point of this game is to get a total of 5000 points in several hands. Each hand is a race to put down exactly 700 miles before your opponent does. Beyond the points gained by putting down milestones, there are several other ways of making points.

Overview: The game is played with a deck of 101 cards. Distance cards represent a number of miles traveled. They come in denominations of 25, 50, 75, 100, and 200. When one is played, it adds that many miles to the player's trip so far this hand. Hazard cards are used to prevent your opponent from putting down Distance cards. They can only be played if your opponent has a Go card on top of the Battle pile. The cards are Out of Gas, Accident, Flat Tire, Speed Limit, and Stop. Remedy cards fix problems caused by Hazard cards played on you by your opponent. The cards are Gasoline, Repairs, Spare Tire, End of Limit, and Go. Safety cards prevent your opponent from putting specific Hazard cards on you in the first place. They are Extra Tank, Driving Ace, Puncture Proof, and Right of Way, and there are only one of each in the deck.

Board Layout: The board is split into several areas. From top to bottom, they are: SAFETY AREA (unlabeled): This is where the safeties will be placed as they are played. HAND: These are the cards in your hand. BATTLE: This is the Battle pile. All the Hazard and Remedy Cards are played here, except the Speed Limit and End of Limit cards. Only the top card is displayed, as it is the only effective one. SPEED: The Speed pile. The Speed Limit and End of Limit cards are played here to control the speed at which the player is allowed to put down miles. MILEAGE: Miles are placed here. The total of the numbers shown here is the distance traveled so far.

Play: The first pick alternates between the two players. Each turn usually starts with a pick from the deck. The player then plays a card, or if this is not possible or desirable, discards one. Normally, a play or discard of a single card constitutes a turn. If the card played is a safety, however, the same player takes another turn immediately.

This repeats until one of the players reaches 700 points or the deck runs out. If someone reaches 700, they have the option of going for an Extension, which means that the play continues until someone reaches 1000 miles.

Hazard and Remedy Cards: Hazard Cards are played on your opponent's Battle and Speed piles. Remedy Cards are used for undoing the effects of your opponent's nastiness.

Go (Green Light) must be the top card on your Battle pile for you to play any mileage, unless you have played the Right of Way card (see below).

Stop is played on your opponent's Go card to prevent them from playing mileage until they play a Go card.

Speed Limit is played on your opponent's Speed pile. Until they play an End of Limit they can only play 25 or 50 mile cards, presuming their Go card allows them to do even that.

End of Limit is played on your Speed pile to nullify a Speed Limit played by your opponent.

Out of Gas is played on your opponent's Go card. They must then play a Gasoline card, and then a Go card before they can play any more mileage.

Flat Tire is played on your opponent's Go card. They must then play a Spare Tire card, and then a Go card before they can play any more mileage.

Accident is played on your opponent's Go card. They must then play a Repairs card, and then a Go card before they can play any more mileage.

Safety Cards: Safety cards prevent your opponent from playing the corresponding Hazard cards on you for the rest of the hand. It cancels an attack in progress, and always entitles the player to an extra turn.

Right of Way prevents your opponent from playing both Stop and Speed Limit cards on you. It also acts as a permanent Go card for the rest of the hand, so you can play mileage as long as there is not a Hazard card on top of your Battle pile. In this case only, your opponent can play Hazard cards directly on a Remedy card other than a Go card.

Extra Tank When played, your opponent cannot play an Out of Gas on your Battle Pile.

Puncture Proof When played, your opponent cannot play a Flat Tire on your Battle Pile.

Driving Ace When played, your opponent cannot play an Accident on your Battle Pile.

Distance Cards: Distance cards are played when you have a Go card on your Battle pile, or a Right of Way in your Safety area and are not stopped by a Hazard Card. They can be played in any combination that totals exactly 700 miles, except that you cannot play more than two 200 mile cards in one hand. A hand ends whenever one player gets exactly 700 miles or the deck runs out. In that case, play continues until neither someone reaches 700, or neither player can use any cards in their hand. If the trip is completed after the deck runs out, this is called Delayed Action.

Coup Fourre: This is a French fencing term for a counter-thrust move as part of a parry to an opponent's attack. In current French colloquial language it means a sneaky, underhanded blow. In Mille Bornes, it is used as follows: If an opponent plays a Hazard card, and you have the corresponding Safety in your hand, you play it immediately, even before you draw. This immediately removes the Hazard card from your Battle pile, and protects you from that card for the rest of the game. This gives you more points (see “Scoring” below).

Scoring: Scores are totaled at the end of each hand, whether or not anyone completed the trip. The terms used in the Score window have the following meanings:

Milestones Played: Each player scores as many miles as they played before the trip ended.

Each Safety: 100 points for each safety in the Safety area.

All 4 Safeties: 300 points if all four safeties are played.

Each Coup Fourre: 300 points for each Coup Fourre accomplished.

The following bonus scores can apply only to the winning player.

Trip Completed: 400 points bonus for completing the trip to 700 or 1000.

Safe Trip: 300 points bonus for completing the trip without using any 200 mile cards.

Delayed Action: 300 points bonus for finishing after the deck was exhausted.

Extension: 200 points bonus for completing a 1000 mile trip.

Shut-Out: 500 points bonus for completing the trip before your opponent played any mileage cards.

Running totals are also kept for the current score for each player for the hand (Hand Total), the game (Overall Total), and number of games won (Games).


mpoly

title: mpoly(6)

summary: Monopoly game

text:
# mpoly(6)

## NAME
mpoly — Monopoly game

## SYNOPSIS
mpoly

[file]

## DESCRIPTION
mpoly is reminiscent of the Parker Brother's game Monopoly, and monitors a game between 1 to 9 users. It is assumed that the rules of Monopoly are known. The game follows the standard rules, with the exception that, if a property goes up for auction and there are only two solvent players, no auction is held and the property remains unowned. mpoly The game, in effect, lends the player money, so it is possible to buy something which you cannot afford. However, as soon as a person goes into debt, he must “fix the problem”, i.e., make himself solvent, before play can continue. If this is not possible, the player's property reverts to his debtee, either a player or the bank. A player can resign at any time to any person or the bank, which puts the property back on the board, unowned.

Any time that the response to a question is a string, e.g., a name, place or person, you can type ‘?’ to get a list of valid answers. It is not possible to input a negative number, nor is it ever necessary.

A Summary of Commands:

quit

quit game: This allows you to quit the game. It asks you if you're sure.

print

print board: This prints out the current board. The columns have the following meanings (column headings are the same for the where, own holdings, and holdings commands):

Name

The first ten characters of the name of the square.

Own

The number of the owner of the property.

Price

The cost of the property (if any).

Mg

This field has a ‘*’ in it if the property is mortgaged.

\#

If the property is a Utility or Railroad, this is the number of such owned by the owner. If the property is land, this is the number of houses on it.

Rent

Current rent on the property. If it is not owned, there is no rent.

where

where players are: Tells you where all the players are. A ‘*’ indicates the current player.

own holdings

List your own holdings, i.e., money, get-out-of-jail-free cards, and property.

holdings

holdings list: Look at anyone's holdings. It will ask you whose holdings you wish to look at. When you are finished, type ‘done’.

mortgage

mortgage property: Sets up a list of mortgageable property, and asks which you wish to mortgage.

unmortgage

unmortgage property: Unmortgage mortgaged property.

buy

buy houses: Sets up a list of monopolies on which you can buy houses. If there is more than one, it asks you which you want to buy for. It then asks you how many for each piece of property, giving the current amount in parentheses after the property name. If you build in an unbalanced manner (a disparity of more than one house within the same monopoly), it asks you to re-input things.

sell

sell houses: Sets up a list of monopolies from which you can sell houses. It operates in an analogous manner to buy.

card

card for jail: Use a get-out-of-jail-free card to get out of jail. If you're not in jail, or you don't have one, it tells you so.

pay

pay for jail: Pay $50 to get out of jail, from whence you are put on Just Visiting. Difficult to do if you're not there.

trade

This allows you to trade with another player. It asks you whom you wish to trade with, and then asks you what each wishes to give up. You can get a summary at the end, and, in all cases, it asks for confirmation of the trade before doing it.

resign

Resign to another player or the bank. If you resign to the bank, all property reverts to its virgin state, and get-out-of-jail-free cards revert to the deck.

save

save game: Save the current game in a file for later play. You can continue play after saving, either by adding the file in which you saved the game after the mpoly command, or by using the restore command (see below). It will ask you which file you wish to save it in, and, if the file exists, confirm that you wish to overwrite it.

restore

restore game: Read in a previously saved game from a file. It leaves the file intact.

roll

Roll the dice and move forward to your new location. If you simply hit the ⟨RETURN⟩ key instead of a command, it is the same as typing roll.

## AUTHOR
Ken Arnold

## FILES
/usr/share/bsd-games//monop-cards.pck

Chance and Community Chest cards

## BUGS
No command can be given an argument instead of a response to a query.


number

title: number(6)

summary: convert Arabic numerals to English

text:
# number(6)

## NAME
number — convert Arabic numerals to English

## SYNOPSIS
number

[-l] [number ...]

## DESCRIPTION
The number utility prints the English equivalent of the number to the standard output, with each 10^3 magnitude displayed on a separate line. If no argument is specified, number reads lines from the standard input.

The options are as follows:

-l

Display the number on a single line.

## BUGS
Although number understand fractions, it doesn't understand exponents.