figlet

title: figlet(6)

text:
# figlet(6)

## NAME
FIGlet - display large characters made up of ordinary screen characters

## SYNOPSIS
figlet [ -cklnoprstvxDELNRSWX ] [ -d fontdirectory ]

[ -f fontfile ] [ -m layoutmode ]

[ -w outputwidth ] [ -C controlfile ]

[ -I infocode ] [ message ]

## DESCRIPTION
FIGlet prints its input using large characters (called ``FIGcharacters'')made up of ordinary screen characters (called ``sub-characters''). FIGlet output is generally reminiscent of the sort of ``signatures'' many people like to put at the end of e-mail and UseNet messages. It is also reminiscent of the output of some banner programs, although it is oriented normally, not sideways.

FIGlet can print in a variety of fonts, both left-to-right and right-to-left, with adjacent FIGcharacters kerned and ``smushed'' together in various ways. FIGlet fonts are stored in separate files, which can be identified by the suffix ``.flf''. In systems with UTF-8 support FIGlet may also support TOIlet ``.tlf'' fonts. Most FIGlet font files will be stored in FIGlet's default font directory.

FIGlet can also use ``control files'', which tell it to map certain input characters to certain other characters, similar to the Unix tr command. Control files can be identified by the suffix ``.flc''. Most FIGlet control files will be stored in FIGlet's default font directory.

You can store FIGlet fonts and control files in compressed form. See COMPRESSED FONTS.

## USAGE
Just start up FIGlet (type ``figlet'') and then type whatever you want. Alternatively, pipe a file or the output of another command through FIGlet, or put input on the command line after the options. See EXAMPLES for other things to do.

## OPTIONS
FIGlet reads command line options from left to right, and only the last option that affects a parameter has any effect. Almost every option has an inverse, so that, for example, if FIGlet is customized with a shell alias, all the options are usually still available.

Commonly-used options are -f, -c, -k, -t, -p and -v.

-f fontfile

Select the font. The .flf suffix may be left off of fontfile, in which case FIGlet automatically appends it. FIGlet looks for the file first in the default font directory and then in the current directory, or, if fontfile was given as a full pathname, in the given directory. If the -f option is not specified, FIGlet uses the font that was specified when it was compiled. To find out which font this is, use the -I3 option.

-d fontdirectory

Change the default font directory. FIGlet looks for fonts first in the default directory and then in the current directory. If the -d option is not specified, FIGlet uses the directory that was specified when it was compiled. To find out which directory this is, use the -I2 option.

-c

-l

-r

-x

These options handle the justification of FIGlet output. -c centers the output horizontally. -l makes the output flush-left. -r makes it flush-right. -x (default) sets the justification according to whether left-to-right or right-to-left text is selected. Left-to-right text will be flush-left, while right-to-left text will be flush-right. (Left-to-right versus right-to-left text is controlled by -L, -R and -X.)

-t

-w outputwidth

These options control the outputwidth, or the screen width FIGlet assumes when formatting its output. FIGlet uses the outputwidth to determine when to break lines and how to center the output. Normally, FIGlet assumes 80 columns so that people with wide terminals won't annoy the people they e-mail FIGlet output to. -t sets the outputwidth to the terminal width. If the terminal width cannot be determined, the previous outputwidth is retained. -w sets the outputwidth to the given integer. An outputwidth of 1 is a special value that tells FIGlet to print each non-space FIGcharacter, in its entirety, on a separate line, no matter how wide it is.

-p

-n

These options control how FIGlet handles newlines. -p puts FIGlet into ``paragraph mode'', which eliminates some unnecessary line breaks when piping a multi-line file through FIGlet. In paragraph mode, FIGlet treats line breaks within a paragraph as if they were merely blanks between words. (Specifically, -p causes FIGlet to convert any newline which is not preceded by a newline and not followed by a space character into a blank.) -n (default) puts FIGlet back to normal, in which every newline FIGlet reads causes it to produce a line break.

-D

-E

-D switches to the German (ISO 646-DE) character set. Turns `[', `\' and `]' into umlauted A, O and U, respectively. `{', `|' and `}' turn into the respective lower case versions of these. `~' turns into s-z. -E turns off -D processing. These options are deprecated, which means they probably will not appear in the next version of FIGlet.

-C controlfile

-N

These options deal with FIGlet controlfiles. A controlfile is a file containing a list of commands that FIGlet executes each time it reads a character. These commands can map certain input characters to other characters, similar to the Unix tr command or the FIGlet -D option. FIGlet maintains a list of controlfiles, which is empty when FIGlet starts up. -C adds the given controlfile to the list. -N clears the controlfile list, cancelling the effect of any previous -C. FIGlet executes the commands in all controlfiles in the list. See the file figfont.txt, provided with FIGlet, for details on how to write a controlfile.

-s

-S

-k

-W

-o

These options control how FIGlet spaces the FIGcharacters that it outputs. -s (default) and -S cause ``smushing''. The FIGcharacters are displayed as close together as possible, and overlapping sub-characters are removed. Exactly which sub-characters count as ``overlapping'' depends on the font's layoutmode, which is defined by the font's author. -k causes ``kerning''. As many blanks as possible are removed between FIGcharacters, so that they touch, but the FIGcharacters are not smushed. -W makes FIGlet display all FIGcharacters at their full width, which may be fixed or variable, depending on the font. The difference between -s and -S is that -s will not smush a font whose author specified kerning or full width as the default layoutmode, whereas -S will attempt to do so.

If there is no information in the font about how to smush, or if the -o option is specified, then the FIGcharacters are ``overlapped''. This means that after kerning, the first subcharacter of each FIGcharacter is removed. (This is not done if a FIGcharacter contains only one subcharacter.)

-m layoutmode

Specifies an explicit layoutmode between 1 and 63. Smushmodes are explained in figfont.txt, which also provides complete information on the format of a FIGlet font. For the sake of backward compatibility with versions of FIGlet before 2.2, -m0 is equivalent to -k, -m-1 is equivalent to -W, and -m-2 is equivalent to -s. The -m switch is normally used only by font designers testing the various layoutmodes with a new font.

-v

-I infocode

These options print various information about FIGlet, then exit. If several of these options are given on the command line, only the last is executed, and only after all other command-line options have been dealt with. -v prints version and copyright information, as well as a ``Usage: ...'' line. -I prints the information corresponding to the given infocode in a consistent, reliable (i.e., guaranteed to be the same in future releases) format. -I is primarily intended to be used by programs that use FIGlet. infocode can be any of the following.

-1 Normal operation (default).

This infocode indicates that FIGlet should operate normally, not giving any informational printout, printing its input in the selected font.

0 Version and copyright.

This is identical to -v.

1 Version (integer).

This will print the version of your copy of FIGlet as a decimal integer. The main version number is multiplied by 10000, the sub-version number is multiplied by 100, and the sub-sub-version number is multiplied by 1. These are added together, and the result is printed out. For example, FIGlet 2.2 will print ``20200'' , version 2.2.1 will print ``20201''. Similarly, version 3.7.2 would print ``30702''. These numbers are guaranteed to be ascending, with later versions having higher numbers. Note that the first major release of FIGlet, version 2.0, did not have the -I option.

2 Default font directory.

This will print the default font directory. It is affected by the -d option.

3 Font.

This will print the name of the font FIGlet would use. It is affected by the -f option. This is not a filename; the ``.flf'' suffix is not printed.

4 Output width.

This will print the value FIGlet would use for outputwidth, the number of columns wide FIGlet assumes the screen is. It is affected by the -w and -t options.

5 Supported font formats.

This will list font formats supported by FIGlet . Possible formats are ``flf2'' for FIGfont Version 2 .flf files and ``tlf2'' for TOIlet .tlf files.

If infocode is any other positive value, FIGlet will simply exit without printing anything.

-L

-R

-X

These options control whether FIGlet prints left-to-right or right-to-left. -L selects left-to-right printing. -R selects right-to-left printing. -X (default) makes FIGlet use whichever is specified in the font file. Once the options are read, if there are any remaining words on the command line, they are used instead of standard input as the source of text. This feature allows shell scripts to generate large letters without having to dummy up standard input files.

An empty argument, obtained by two sequential quotes, results in a line break.

## EXAMPLES
To use FIGlet with its default settings, simply type

```
example% figlet
```

and then type whatever you like. To change the font, use the -f option, for example,

```
example% figlet -f script
```

Use the -c option if you would prefer centered output:

```
example% figlet -c
```

We have found that the most common use of FIGlet is making up large text to be placed in e-mail messages. For this reason, FIGlet defaults to 80 column output. If you are using a wider terminal, and would like FIGlet to use the full width of your terminal, use the -t option:

```
example% figlet -t
```

If you don't want FIGlet to smush FIGcharacters into each other, use the -k option:

```
example% figlet -k
```

If figlet gets its input from a file, it is often a good idea to use -p:

```
example% figlet -p < myfile
```

Of course, the above can be combined:

```
example% figlet -ptk -f shadow < anotherfile
example% figlet -cf slant
```

Finally, if you want to have FIGlet take the input from the command line instead of a file:

```
example% figlet Hello world
```

### Other Things to Try
On many systems nice effects can be obtained from the lean font by piping it through tr. Some you might want to try are the following:

```
example% figlet -f lean | tr ' _/' ' ()'
example% figlet -f lean | tr ' _/' './\\'
example% figlet -f lean | tr ' _/' ' //'
example% figlet -f lean | tr ' _/' '/  '
```

Similar things can be done with the block font and many of the other FIGlet fonts.

## COMPRESSED FONTS
You can compress the fonts and controlfiles using the zip archiving program. Place only one font or controlfile in each archive, and rename the archive file (which will have a name ending in .zip) back to .flf or .flc as the case may be. If you don't rename the file appropriately, FIGlet won't be able to find it.

FIGlet does not care what the filename within the .zip archive is, and will process only the first file.

The .zip format was chosen because tools to create and manipulate it are widely available for free on many platforms.

## THE STANDARD FONTS
Here are a few notes about some of the fonts provided with FIGlet. You can get many other font from the Web site

http://www.figlet.org/ This location should also contain the latest version of FIGlet and other related utilities.

The font standard is the basic FIGlet font, used when no other font is specified. (This default can be changed when FIGlet is compiled on your system.) The controlfiles 8859-2, 8859-3, 8859-4, and 8859-9 are provided for interpreting those character sets, also known as ISO Latin-2 through Latin-5 respectively. The character set 8859-1 (ISO Latin-1) is FIGlet's default and requires no special controlfile.

Closely related are the fonts slant, shadow, small, smslant (both small and slanted), smshadow, (both small and shadowed), and big. These fonts support only Latin-1, except that big supports Greek FIGcharacters as well; the controlfiles frango (for Greek text written in Latin characters, so-called ``frangovlakhika''), and 8859-7 (for mixed Latin/Greek text) are provided.

The ivrit font is a right-to-left font including both Latin and Hebrew FIGcharacters; the Latin characters are those of the standard font. The available controlfiles are ilhebrew, which maps the letters you get by typing on a U.S. keyboard as if it were a Hebrew keyboard; ushebrew, which makes a reasonable mapping from Latin letters to Hebrew ones; and 8859-8, which supports mixed Latin/Hebrew text. Warning: FIGlet doesn't support bidirectional text, so everything will come out right-to-left, even Latin letters.

The fonts terminal, digital, and bubble output the input character with some decoration around it (or no decoration, in the case of terminal). The characters coded 128 to 159, which have varying interpretations, are output as-is. You can use the appropriate controlfiles to process Latin-2, Latin-3, or Latin-4 (but not Latin-5) text, provided your output device has screen or printer fonts that are appropriate for these character sets.

Two script fonts are available: script, which is larger than standard, and smscript, which is smaller.

The font lean is made up solely of `/' and `_' sub-characters; block is a straight (non-leaning) version of it.

The font mini is very small, and especially suitable for e-mail signatures.

The font banner looks like the output of the banner program; it is a capitals and small capitals font that doesn't support the ISO Latin-1 extensions to plain ASCII. It does, however, support the Japanese katakana syllabary; the controlfile uskata maps the upper-case and lower-case Latin letters into the 48 basic katakana characters, and the controlfile jis0201 handles JIS 0201X (JIS-Roman) mixed Latin and katakana text. Furthermore, the banner font also supports Cyrillic (Russian) FIGcharacters; the controlfile 8859-5 supports mixed Latin and Cyrillic text, the controlfile koi8r supports the popular KOI8-R mapping of mixed text, and the controlfile moscow supports a sensible mapping from Latin to Cyrillic, compatible with the moscow font (not supplied).

The fonts mnemonic and safemnem support the mnemonic character set documented in RFC 1345. They implement a large subset of Unicode (over 1800 characters) very crudely, using ASCII-based mnemonic sequences, and are good for getting a quick look at UTF-8 unicode files, using the controlfile utf8.

## ENVIRONMENT
FIGLET_FONTDIR

If $FIGLET_FONTDIR is set, its value is used as a path to search for font files.

## FILES
file.flf

FIGlet font file

file.flc

FIGlet control file

## DIAGNOSTICS
FIGlet's diagnostics are intended to be self-explanatory. Possible messages are

```
Usage: ...
Out of memory
Unable to open font file
Not a FIGlet 2 font file
Unable to open control file
Not a FIGlet 2 control file
"-t" is disabled, since ioctl is not fully implemented.
```

This last message is printed when the -t option is given, but the operating system in use does not include the system call FIGlet uses to determine the terminal width.

FIGlet also prints an explanatory message if the -F option is given on the command line. The earlier version of FIGlet, version 2.0, listed the available fonts when the -F option was given. This option has been removed from FIGlet 2.1. It has been replaced by the figlist script, which is part of the standard FIGlet package.

## ORIGIN
``FIGlet'' stands for ``Frank, Ian and Glenn's LETters''. Inspired by Frank's .sig, Glenn wrote (most of) it, and Ian helped.

Most of the standard FIGlet fonts were inspired by signatures on various UseNet articles. Since typically hundreds of people use the same style of letters in their signatures, it was often not deemed necessary to give credit to any one font designer.

## BUGS
Very little error checking is done on font and control files. While FIGlet tries to be forgiving of errors, and should (hopefully) never actually crash, using an improperly-formatted file with FIGlet will produce unpredictable output.

FIGlet does not handle format characters in a very intelligent way. A tab character is converted to a blank, and vertical-tab, form-feed and carriage-return are each converted to a newline. On many systems, tabs can be handled better by piping files through expand before piping through FIGlet.

FIGlet output is quite ugly if it is displayed in a proportionally-spaced font. I suppose this is to be expected.

Please report any errors you find in this man page or the program to <info@figlet.org>

## WEBSITE AND MAILING LIST
You can get many fonts which are not in the basic FIGlet package from the Web site http://www.figlet.org/ It should also contain the latest version of FIGlet and other utilities related to FIGlet.

There is a mailing list for FIGlet for general discussions about FIGlet and a place where you can ask questions or share ideas with other FIGlet users. It is also the place where we will publish news about new fonts, new software updates etc.

To subscribe or unsubscribe from the FIGlet mailing list, please send email to figlet-subscribe@figlet.org or figlet-unsubscribe@figlet.org or visit the following web page: http://www.figlet.org/mailman/listinfo/figlet

## AUTHORS
Glenn Chappell did most of the work. You can e-mail him but he is not an e-mail fanatic; people who e-mail Glenn will probably get answers, but if you e-mail his best friend:

Ian Chai, who is an e-mail fanatic, you'll get answers, endless conversation about the mysteries of life, invitations to join some 473 mailing lists and a free toaster. (Well, ok, maybe not the free toaster.)

Frank inspired this whole project with his .sig, but don't e-mail him; he's decidedly an un-e-mail-fanatic.

Gilbert "The Mad Programmer" Healton added the -A option for version 2.1.1. This option specified input from the command line; it is still allowed, but has no effect.

John Cowan added the -o, -s, -k, -S, and -W options, and the support for Unicode mapping tables, ISO 2022/HZ/Shift-JIS/UTF-8 input, and compressed fonts and control files. He also revised this documentation, with a lot of input from Paul Burton.

Claudio Matsuoka added the support for .tlf files for version 2.2.4 and performs random hacks and bugfixes.

As a fan of FIGlet, Christiaan Keet revised the official FIGlet documentation and set up the new FIGlet website at http://www.figlet.org/ (and the corresponding ftp://ftp.figlet.org/pub/figlet/)

## SEE ALSO
figlist(6), chkfont(6), showfigfonts(6), toilet(1)


figlist

package: figlet

title: figlist(6)

summary: lists figlet fonts and control files

text:
# figlist(6)

## NAME
figlist - lists figlet fonts and control files

## SYNOPSIS
figlist [ -d directory ]

## DESCRIPTION
Lists all fonts and control files in figlet's default font directory. Replaces "figlet -F", which was removed from figlet version 2.1.

## EXAMPLES
To use figlist with its default settings, simply type

example% figlist

To list all the font and control files in /usr/share/fonts/figlet

example% figlist -d /usr/share/fonts/figlet

## AUTHORS
figlist was written by Glenn Chappell <ggc@uiuc.edu>

This manual page was written by Jonathon Abbott for the Debian Project.

## SEE ALSO
figlet(6), chkfont(6), showfigfonts(6)

branch: sisyphus


showfigfonts

title: showfigfonts(6)

summary: prints a list of available figlet fonts

text:
# showfigfonts(6)

## NAME
showfigfonts - prints a list of available figlet fonts

## SYNOPSIS
showfigfonts [ -d directory ] [ word ]

## DESCRIPTION
Prints a list of available figlet fonts, along with a sample of each font. If directory is given, lists fonts in that directory; otherwise uses the default font directory. If word is given, prints that word in each font; otherwise prints the font name.

## EXAMPLES
To use showfigfonts with its default settings, simply type

example% showfigfonts

To print all the fonts in /usr/share/fonts/figlet

example% showfigfonts -d /usr/share/fonts/figlet

To print the word foo using all available fonts

example% showfigfonts foo

## AUTHORS
showfigfonts was written by Glenn Chappell <ggc@uiuc.edu>

This manual page was written by Jonathon Abbott for the Debian Project.

## SEE ALSO
figlet(6), chkfont(6), figlist(6)


fillets

package: fillets-ng

title: fillets(6)

text:
# fillets(6)

## NAME
fillets - puzzle game about witty fish saving the world sokoban style

## SYNOPSIS
fillets [options]

## DESCRIPTION
Fish Fillets is strictly a puzzle game. The goal in every of the seventy levels is always the same: find a safe way out. The fish utter witty remarks about their surroundings, the various inhabitants of their underwater realm quarrel among themselves or comment on the efforts of your fish. The whole game is accompanied by quiet, comforting music.

There is an excellent in game tutorial available, so you can start playing right away.

## OPTIONS
-h, --help

Show summary of options.

-v, --version

Show version of program.

-c, --config

Show config variables and values.

fullscreen=<boolean>

Turn fullscreen on/off.

Default: fullscreen=0

lang=

ISO 639 2-letter code (for ex.: en, cs, fr, de)

see http://www.w3.org/WAI/ER/IG/ert/iso639.htm

Default: lang=LC_MESSAGES

loglevel=<number>

Loglevel uses same numbers as syslog.

for ex.: 3 for ERROR, 4 for WARNING, 6 for INFO, 7 for DEBUG

Default: loglevel=6

show_steps=<boolean>

Show step counter in level.

Default: show_steps=0

sound=<boolean>

Turn sound on/off.

Default: sound=1

speech=

ISO 639 2-letter code (for ex.: en, cs, fr, de)

see http://www.w3.org/WAI/ER/IG/ert/iso639.htm

Default: same as lang

subtitles=<boolean>

Show subtitles in level.

Default: subtitles=1

systemdir=<path>

Path to game data.

userdir=<path>

Path to game data.

Default: userdir=$HOME/.fillets-ng

volume_sound=<number>

Sound volume in percentage.

Default: volume_sound=90

volume_music=<number>

Music volume in percentage.

Default: volume_music=50

worldmap=<path>

Relative path to worldmap file.

Useful for external levels.

Default: worldmap=script/worldmap.lua

## USAGE
Up, down, left and right arrow keys control the current fish.

Use space bar to switch between the fish.

restart level - Backspace

undo - -

help - F1

save game - F2

load game - F3

show/hide level move counter - F5

show/hide subtitles - F6

game menu - F10

toggle fullscreen - F11

increase game speed - hold down Shift

Find more information in the "How to Play" html manual listed below.

## SEE ALSO
/usr/share/doc/fillets-ng/html/manual.html

http://fillets.sf.net

## AUTHORS
Fish Fillets - Next Generation was written by

Ivo Danihelka <ivo@danihelka.net>

- main developer

- developed new game engine

Pavel Danihelka <fillets@danihelka.net>

- webmaster, level data, documentation

Frederic Panico <fratloev@yahoo.fr>

- French translation

Ronny Standtke <Ronny.Standtke@gmx.de>

- German translation

Simone Cociancich <simone.coch@tin.it>

- Italian translation

Przemek Bojczuk <przemek@bojczuk.pl>

- Polish translation

César Catrián C. <ccatrian@eml.cc>

- Spanish translation

Astrid de Wijn

- Dutch translation

Damyan Ivanov <divanov@creditreform.bg>

- Bulgarian translation

Olov Gustavsson <olov.gustavsson@bredband.net>

- Swedish translation

Marko Burjek <email4marko[at]gmail[dot]com>

- Slovenian translation

Ricardo Faria <rickybrag@gmail.com>

- Brazilian Portuguese translation

Leonid Myravjev <lemy@bk.ru>

- Russian translation

ALTAR interactive <info@altarinteractive.com>

- developed original game in 1998 (for Win32)

- released code and data under GNU/GPL in 03/2004

This manual page was written for the Debian distribution because the original program did not have a manual page.

This manual page was written by fabian linzberger <e@lefant.net>, for the Debian project (but may be used by others).


flare

package: flare-engine

title: flare(6)

summary: action role-playing engine

text:
# flare(6)

## NAME
flare - action role-playing engine

## SYNOPSIS
flare [options]

## DESCRIPTION
FLARE (short for Free Libre Action Roleplaying Engine) is a single-player, 2D-isometric action role-playing engine. It uses simple file formats (INI-style config files) for most of the game data, allowing anyone to easily modify game contents.

## OPTIONS
--help

Prints a description of command line flags.

--version

Prints the release version.

--data-path=path

Specifies an exact path to look for mod data.

--debug-event

Prints verbose hardware input information.

--renderer=renderer

Specifies the rendering backend to use. The default is 'sdl_hardware'. Also available is 'sdl', which is a software-based renderer.

--no-audio

Disables sound effects and music.

--mods=mod,...

Starts the game with only these mods enabled.

--load-slot=slot

Loads a save slot by numerical index.

--load-script=script

Execute's a script upon loading a saved game. The script path is mod-relative.

## FILES
The engine settings and key bindings are stored in

$XDG_CONFIG_HOME/flare/

$HOME/.config/flare/

The game data is stored in

$XDG_DATA_HOME/flare/

$HOME/.local/share/flare/

## AVAILABILITY
For more information about the FLARE engine, visit http://flarerpg.org


flobopuyo

package: flobopuyo

title: flobopuyo(6)

summary: A clone of the Japanese PuyoPuyo game

text:
# flobopuyo(6)

## NAME
flobopuyo - A clone of the Japanese PuyoPuyo game

## SYNOPSIS
flobopuyo

## DESCRIPTION
The goal of flobopuyo is to make groups of four or more Puyos (coloured bubbles) to make them explode and send bad ghost Puyos to your oponent. You win the game if your oponent reaches the top of the board. You can play against computer or another human.

The game has nice graphics and animations as well as music and sound effects.

## OPTIONS
None.

## BUGS
Please report any bugs you find to <iosteam@ios-software.com>.

## LICENSE
flobopuyo is covered by the GNU General Public License (GPL).

## SEE ALSO
xpuyopuyo(6), kfouleggs(6).

## AUTHOR
Florent Boudet <flobo@ios-software.com>

Guillaume Borios <gyom@ios-software.com>

Jean-Christophe Hoelt <jeko@ios-software.com>

This manual page was written by Uwe Hermann <uwe@debian.org>, for the Debian project (but may be used by others).


foobillardplus

package: foobillardplus

title: foobillardplus(6)

summary: 3D OpenGL Billiard Game

text:
# foobillardplus(6)

## NAME
FooBillard++ - 3D OpenGL Billiard Game

## SYNOPSIS
foobillardplus [--option [<arg>]]

## DESCRIPTION
foobillardplus is an advanced 3D OpenGL billiard game based on the original foobillard 3.0a sources from Florian Berger. You can play it with one or two players or against the computer.

The game features:

* Wood paneled table with gold covers and gold diamonds.

* Reflections on balls.

* Zoom in and out, rotation, different angles and bird's eye view.

* Different game modes: 8 or 9-ball, Snooker or Karambol.

* Tournaments. Compete against other players.

* Animated cue with strength and eccentric hit adjustment.

* Jump shots and snipping.

* Realistic gameplay and billiard sounds.

* Red-Green stereo.

* And much more.

## OPTIONS
--player1 <arg>

arg=ai|human set player1 ai/human

--player2 <arg>

arg=ai|human set player2 ai/human

--p1 <arg>

arg=ai|human set player1 ai/human

--p2 <arg>

arg=ai|human set player2 ai/human

--name1 <arg>

Set name of player1

--name2 <arg>

Set name of player2

--8ball

8ball pool game

--9ball

9ball pool game

--carambol

Carambol billard game

--snooker

Snooker billard game

--chromeblue

Blue table with chrome edges

--goldgreen

Green table with gold edges

--goldred

Red table with gold edges

--blackbeige

Beige table with black metal

--tronmode <arg>

Toggle Tron Mode

--tablesize <arg>

Table size (length) in foot (default=7.0)

--lensflare

Turn on lens flare

--nolensflare

Turn off lens flare

--poslight

Use positional light

--dirlight

Use directional light

--vsync <arg>

arg=on|off

--ai1err <arg>

To err is artificial (player1 error 0..1)

--ai2err <arg>

To err is artificial (player2 error 0..1)

--balldetail <arg>

Set ball detail l[ow] m[edium] h[igh] or v[eryhigh]

--glassball <arg>

arg=on|off Glassballs on or off

--rgstereo

Start in stereo mode (red-green(cyan))

--rgaim <arg>

arg=left|right|middle for aiming eye position

--hostaddr <arg>

arg=IP-address for TCP/IP connection

--portnum <arg>

arg=port# for TCP/IP connection

--geometry <arg>

<width>x<height> window geometry

--fullscreen

Play in fullscreen mode

--browser <arg>

arg= browsername in path (default: firefox)

--freemove <arg>

arg=on|off free move in external view mode

--cuberef <arg>

arg=on|off rendered cubemap reflections

--cuberes <arg>

arg=<texture size for cuberef> (must be power of 2)

--ballsphere <arg>

arg=on|off

--bumpref <arg>

arg=on|off bumpmap reflections of edges

--bumpwood <arg>

arg=on|off bumpmap of wood covers

--balltraces <arg>

arg=on|off trace lines of balls

--gamemode <arg>

arg=match|training|tournament

--avatar <arg>

arg=on|off enable/disable avatar

--tourfast <arg>

arg=1.0..10.0 AI fast motion ratio for tournament

--showbuttons <arg>

arg=on|off

--jumpshots <arg>

arg=on|off

--aliasing <arg>

arg=on|off

--aliasmax <arg>

fsaa value 1,2,4,8

--statustext <arg>

arg=on|off

--language <arg>

Change language

--usesound <arg>

arg=on|off

--usemusic <arg>

arg=on|off

--musicvol <arg>

Volume 0-128

--soundvol <arg>

Volume 0-128

--pcarambol <arg>

arg=5-100

--controlkind <arg>

arg=on|off

--aibirdview <arg>

arg=on|off

--anisotrop <arg>

arg=on|off

--mouseshoot <arg>

arg=on|off

--oldmoving <arg>

arg=on|off

--auto_freemove <arg>

arg=on|off

--fsaa <arg>

arg=on|off

--roomtexture <arg>

arg=on|off

--furnituretex <arg>

Extratexture: 0 = off, 1 = default, 2 = high

--help

This help


fortune

package: fortune

title: fortune(6)

text:
# fortune(6)

## NAME
fortune - print a random, hopefully interesting, adage

## SYNOPSIS
fortune [-acefilosw] [-n length] [ -m pattern] [[n%] file/dir/all]

## DESCRIPTION
When fortune is run with no arguments it prints out a random epigram. Epigrams are divided into several categories, where each category is sub-divided into those which are potentially offensive and those which are not..SS Options The options are as follows:

-a

Choose from all lists of maxims, both offensive and not. (See the -o option for more information on offensive fortunes.)

-c

Show the cookie file from which the fortune came.

-e

Consider all fortune files to be of equal size (see discussion below on multiple files).

-f

Print out the list of files which would be searched, but don't print a fortune.

-l

Long dictums only. See -n on how ``long'' is defined in this sense.

-m pattern

Print out all fortunes which match the basic regular expression pattern. The syntax of these expressions depends on how your system defines re_comp(3) or regcomp(3), but it should nevertheless be similar to the syntax used in grep(1).

The fortunes are output to standard output, while the names of the file from which each fortune comes are printed to standard error. Either or both can be redirected; if standard output is redirected to a file, the result is a valid fortunes database file. If standard error is also redirected to this file, the result is still valid, but there will be ``bogus'' fortunes, i.e. the filenames themselves, in parentheses. This can be useful if you wish to remove the gathered matches from their original files, since each filename-record will precede the records from the file it names.

-n length

Set the longest fortune length (in characters) considered to be ``short'' (the default is 160). All fortunes longer than this are considered ``long''. Be careful! If you set the length too short and ask for short fortunes, or too long and ask for long ones, fortune goes into a never-ending thrash loop.

-o

Choose only from potentially offensive aphorisms. The -o option is ignored if a fortune directory is specified. Please, please, please request a potentially offensive fortune if and only if you believe, deep in your heart, that you are willing to be offended. (And that you'll just quit using -o rather than give us grief about it, okay?)

... let us keep in mind the basic governing philosophy of The Brotherhood, as handsomely summarized in these words: we believe in healthy, hearty laughter -- at the expense of the whole human race, if needs be. Needs be. --H. Allen Smith, "Rude Jokes"

-s

Short apothegms only. See -n on which fortunes are considered ``short''.

-i

Ignore case for -m patterns.

-w

Wait before termination for an amount of time calculated from the number of characters in the message. This is useful if it is executed as part of the logout procedure to guarantee that the message can be read before the screen is cleared.

The user may specify alternate sayings. You can specify a specific file, a directory which contains one or more files, or the special word all which says to use all the standard databases. Any of these may be preceded by a percentage, which is a number n between 0 and 100 inclusive, followed by a %. If it is, there will be a n percent probability that an adage will be picked from that file or directory. If the percentages do not sum to 100, and there are specifications without percentages, the remaining percent will apply to those files and/or directories, in which case the probability of selecting from one of them will be based on their relative sizes.

As an example, given two databases funny and not-funny, with funny twice as big (in number of fortunes, not raw file size), saying

fortune funny not-funny

will get you fortunes out of funny two-thirds of the time. The command fortune 90% funny 10% not-funny

will pick out 90% of its fortunes from funny (the ``10% not-funny'' is unnecessary, since 10% is all that's left). The -e option says to consider all files equal; thus

fortune -e funny not-funny

is equivalent to fortune 50% funny 50% not-funny

This fortune also supports the BSD method of appending ``-o'' to database names to specify offensive fortunes. However this is not how fortune stores them: offensive fortunes are stored in a separate directory without the ``-o'' infix. A plain name (i.e., not a path to a file or directory) that ends in ``-o'' will be assumed to be an offensive database, and will have its suffix stripped off and be searched in the offensive directory (even if the neither of the -a or -o options were specified). This feature is not only for backwards-compatibility, but also to allow users to distinguish between inoffensive and offensive databases of the same name. For example, assuming there is a database named definitions in both the inoffensive and potentially offensive collections, then the following command will select an inoffensive definition 90% of the time, and a potentially offensive definition for the remaining 10%:

fortune 90% definitions definitions-o

## FILES
Note: these are the defaults as defined at compile time.

/usr/share/games/fortune

Directory for innoffensive fortunes.

/usr/share/games/fortune/off

Directory for offensive fortunes.

If a particular set of fortunes is particularly unwanted, there is an easy solution: delete the associated .dat file. This leaves the data intact, should the file later be wanted, but since fortune no longer finds the pointers file, it ignores the text file.

## BUGS
The division of fortunes into offensive and non-offensive by directory, rather than via the `-o' file infix, is not 100% compatible with original BSD fortune. Although the `-o' infix is recognised as referring to an offensive database, the offensive database files still need to be in a separate directory. The workaround, of course, is to move the `-o' files into the offensive directory (with or without renaming), and to use the -a option.

The supplied fortune databases have been attacked, in order to correct orthographical and grammatical errors, and particularly to reduce redundancy and repetition and redundancy. But especially to avoid repetitiousness. This has not been a complete success. In the process, some fortunes may also have been lost.

The fortune databases are now divided into a larger number of smaller files, some organized by format (poetry, definitions), and some by content (religion, politics). There are parallel files in the main directory and in the offensive files directory (e.g., fortunes/definitions and fortunes/off/definitions). Not all the potentially offensive fortunes are in the offensive fortunes files, nor are all the fortunes in the offensive files potentially offensive, probably, though a strong attempt has been made to achieve greater consistency. Also, a better division might be made.

## HISTORY
This version of fortune is based on the NetBSD fortune 1.4, but with a number of bug fixes and enhancements.

The original fortune/strfile format used a single file; strfile read the text file and converted it to null-delimited strings, which were stored after the table of pointers in the .dat file. By NetBSD fortune 1.4, this had changed to two separate files: the .dat file was only the header (the table of pointers, plus flags; see strfile.h), and the text strings were left in their own file. The potential problem with this is that text file and header file may get out of synch, but the advantage is that the text files can be easily edited without resorting to unstr, and there is a potential savings in disk space (on the assumption that the sysadmin kept both .dat file with strings and the text file).

Many of the enhancements made over the NetBSD version assumed a Linux system, and thus caused it to fail under other platforms, including BSD. The source code has since been made more generic, and currently works on SunOS 4.x as well as Linux, with support for more platforms expected in the future. Note that some bugs were inadvertently discovered and fixed during this process.

At a guess, a great many people have worked on this program, many without leaving attributions.

## SEE ALSO
re_comp(3), regcomp(3), strfile(1), unstr(1)


dbm-fc-solver

package: freecell-solver

title: dbm-fc-solver(6)

summary: memory efficient solving of difficult

text:
# dbm-fc-solver(6)

## NAME
depth-dbm-fc-solver, dbm-fc-solver - memory efficient solving of difficult to verdict Freecell deals.

## SYNOPSIS
depth-dbm-fc-solver --offload-dir-path offload/ --num-threads 1 /path/to/freecell.board

## DESCRIPTION
depth-dbm-fc-solver is a command line application that tries to verdict a single Freecell deal as solvable or impossible.

## SEE ALSO
fc-solve(6)

<https://fc-solve.shlomifish.org/faq.html> .

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


fc-solve

title: fc-solve(6)

text:
# fc-solve(6)

## NAME
fc-solve - automated solver for Freecell and related Solitiare variants

## INTRODUCTION
This is Freecell Solver version 6.10.x, a program that automatically solves most layouts of Freecell, and similar Solitaire variants as well as those of Simple Simon.

Freecell Solver is distributed under the MIT/Expat License ( <http://en.wikipedia.org/wiki/MIT_License> ), a free, permissive, open-source license.

Note that the Freecell Solver source and Win32 binary distributions do not provide a graphical user-interface (GUI) and are primarily meant to be used by Solitaire researchers and software developers. If you’re looking for a suitable GUI based on Freecell Solver, see our links at:

<http://fc-solve.shlomifish.org/links.html#front_ends>

I hope you’ll enjoy using Freecell Solver, and make the best of it.

— Shlomi Fish ( <http://www.shlomifish.org/> )

## BUILDING
Read the file INSTALL.txt for information on how to do that.

## USAGE
The program is called "fc-solve". You invoke it like this:

```
fc-solve board_file
```

board_file is the filename with a valid Freecell startup board. The file is built as follows:

It has the 8 Freecell stacks.

Each stack contains its cards separated by a whitespace and terminated with a newline character( it’s important that the last stack will also be terminated with a newline !). The cards in the line are ordered from the topmost card (= the card right on the virtual table and the one with the most cards placed on it) in the left, to the bottommost card in the right (= the card with no other cards placed on it).

A card string contains the rank of the card followed by its suit. The card number is one of: A,1,2,3,4,5,6,7,8,9,T,J,Q,K. Alternatively, 10 can be used instead of T, but using that is discouraged and is only supported for backward compatibility. The card suit is one of: H,S,D,C (standing for Hearts, Spades, Diamonds and Clubs respectively).

Here is an example board: (PySol/Microsoft board No. 24)

```
4C 2C 9C 8C QS 4S 2H
5H QH 3C AC 3H 4H QD
QC 9S 6H 9H 3S KS 3D
5D 2S JC 5C JH 6D AS
2D KD TH TC TD 8D
7H JS KH TS KC 7C
AH 5S 6S AD 8H JD
7S 6C 7D 4D 8S 9D
```

Visually, it appears as this:

[Freecell Deal No. 24]

As can be seen, the four of clubs (4C), five of hearts (5H), etc. are at the bottom of the stacks and the start of the lines in the board input.

And another one: (PySol board No. 198246790)

```
KD JH 5H 7D 9H KC 9D
3H JD 5D 8H QH 7H 2D
4D 3S QC 3C 6S QS KS
TC 9S 6D 9C QD 8S TD
TS 8C 7S TH 2C AS
8D AC AH 4H JC 4C
6H 7C 4S 5S 5C JS
AD KH 6C 2H 3D 2S
```

Starting from Freecell Solver 3.14.x, a stack can also start with a leading colon (":"). This is to allow input from states as output by Freecell Solver using the -p option.

You can specify the contents of the freecells by prefixing the line with "FC:" or with "Freecells:". For example:

```
FC: 3H QC
```

will specify that the cards 3 of hearts and queen of clubs are present in the freecells. To specify an empty freecell use a "-" as its designator.

If there’s another "FC:" line, the previous line will be overridden.

You can specify the contents of the foundations by prefixing the line with "Founds:" or with "Foundations:" and then using a format as follows:

```
Founds: H-5 C-A S-0 D-K
```

Hence, the suit ID followed by a dash followed by the card number in the foundation. A suit that is not present will be assumed to be 0. Again, if there’s more than one line like that, then the previous lines will be ignored and overridden.

The program will stop processing the input as soon as it read 8 lines of standard stacks. Therefore, it is recommended that the foundations and freecells lines will come at the beginning of the file.

The program will process the board and try to solve it. If it succeeds it will output the states from the initial board to its final solution to the standard output. If it fails, it will notify it.

For information about the various command-line switches that Freecell Solver accepts, read the USAGE.txt file in this directory.

To solve Simple Simon boards append --game simple_simon right after the "fc-solve" program name.

## THE BOARD GENERATION PROGRAMS
Several programs which can generate the initial boards of various Freecell implementations can be found in the "board_gen/" sub-directory. Read the README.txt file there for details on how they can be compiled and used.

In any case, they can save you the time of inputting the board yourself.

## SOME COMPLETE EXAMPLES FOR LAYOUTS
A layout in the middle of the MS Freecell deal No. 109 solution:

```
Foundations: H-6 C-9 D-2 S-0
Freecells:  QS  3S  2S  KD
: 8H 3D
: KS QD JC
: AS 8D TD 7D JH TS 9D
: 7S 6D
: 5S
: KH QC JD TC 9H 8S 7H 6S 5D 4S
: KC QH JS TH 9S
: 4D
```

Similar, but with an empty Freecell:

```
Foundations: H-6 C-9 D-2 S-0
Freecells:  QS  3S  -  KD
: 8H 3D 2S
: KS QD JC
: AS 8D TD 7D JH TS 9D
: 7S 6D
: 5S
: KH QC JD TC 9H 8S 7H 6S 5D 4S
: KC QH JS TH 9S
: 4D
```

Likewise, only without leading colons where unnecessary:

```
Foundations: H-6 C-9 D-2 S-0
Freecells:  QS  3S  -  KD
8H 3D 2S
KS QD JC
AS 8D TD 7D JH TS 9D
7S 6D
5S
KH QC JD TC 9H 8S 7H 6S 5D 4S
KC QH JS TH 9S
4D
```

## HOW TO READ THE SOLUTIONS
The file USAGE.txt covers all of Freecell Solver’s command line options, but it may be too exhaustive for casual users. As a result, here is a shorter tutorial. First of all whenever invoking fc-solve one should add the flags -p -t -sam -sel which will make the solution easier to understand. Then, assuming the board could be successfully solved, one will be given the layouts in the solution (in the format given above) vis-a-vis with the moves as the string. Note that the indexes of the resources given in the moves are 0-based rather than the more natural 1-based notation.

## THE PROGRAMS
Most command-line switches have two versions:

•A short POSIX one which is a dash followed by a letter or a few. This option must come standalone and not clustered: -sam is not equivalent to specifying -s, -a and -m.

•A long switch which is two dashes followed by the command string. For example: --prelude, --st-name.

If command line arguments have parameters, they are followed in separate parameters - Freecell Solver won’t recognise a parameter preceded by an equal sign. --st-name=myname is invalid, while --st-name myname is OK.

### The Scope of the Options
The scope of the options is mentioned along with them. Options can be:

1.Global - affects all the soft-threads.

2.Instance-specific - affects an instance (separated by the --next-instance option below). Each instance consists of several flares.

3.Flare-specific - affects the current flare (separated by the --next-flare option below. Each flare consists of several hard threads.

4.Hard-thread-specific - affects the current hard thread (separated by the --next-hard-thread option below. Each hard thread consists of several soft threads.

5.Soft-thread-specific - affects only the current soft thread.

## GETTING HELP

### -h , --help
Global

This option displays a help text on the screen. This help gives a help display summarizing some ways to use the program and get more help.

### --version
Global

This option displays the version number of the components that make the executable (and then exits).

### --help-configs
Global

Some help on the various configurations of Freecell Solver.

### --help-options
Global

A help screen giving an overview of all available options.

### --help-real-help
Global

Explains how to change the default help screen to a different one.

### --help-short-sol
Global

How to generate shorter solutions.

### --help-summary
Global

The default help screen.

## OUTPUT OPTIONS

### -p , --parseable-output
Global

This option will display the columns in a format that can be more easily manipulated by text-processing programs such as grep or perl. Namely, The freecells will be displayed in one line, and the foundations in a separate line. Plus, Each column will be displayed horizontally, in its own line, while beginning with a :.

### -t , --display-10-as-t
Global

This option will display the 10 cards as a capital T instead of a 10. Thus, the cards will be more properly aligned.

For example, here is a command line using -p and -t:

```
$ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
-=-=-=-=-=-=-=-=-=-=-=-
Foundations: H-0 C-0 D-0 S-0
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D AS
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D
====================
Foundations: H-0 C-0 D-0 S-A
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D
```

### -c , --canonized-order-output
Global

Freecell Solver re-arranges the stacks and freecells in a given state according to their first card. It keeps their actual position in a separate place, but internally it uses their canonized place. Use this option, if you want Freecell Solver to display them in that order. One should be warned that that way the place of a given stack in the board will not be preserved throughout the solution.

### -m , --display-moves
Global

This option will display the moves instead of the intermediate states. Each move will be displayed in a separate line, in a format that is human-readable, but that can also be parsed and analyzed by a computer program with some effort on the programmer’s part.

For example:

```
$ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
-=-=-=-=-=-=-=-=-=-=-=-
Move a card from stack 3 to the foundations
====================
Move a card from stack 6 to freecell 0
====================
Move a card from stack 6 to freecell 1
```

### -sn , --standard-notation
Global

This option will display the moves in standard notation in which every move consists of two characters and there are ten moves in a line. Naturally, this option will only become apparent if the display moves is specified. (it does not implicitly specify it, though).

For more information regarding standard notation refer to the following web-page:

<http://www.solitairelaboratory.com/solutioncatalog.html>

### -snx , --standard-notation-extended
Global

This option is similar to the previous one, except that when a sequence move is made to an empty stack with more than one card in the sequence, the move will be followed with "v" and the number of cards moved in hexadecimal.

### -sam , --display-states-and-moves
Global

This option will display both the intermediate states and the moves that are needed to move from one to another. The standard notation option applies to it to.

```
$ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
-=-=-=-=-=-=-=-=-=-=-=-
Foundations: H-0 C-0 D-0 S-0
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D AS
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D
====================
Move a card from stack 3 to the foundations
Foundations: H-0 C-0 D-0 S-A
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D
====================
Move a card from stack 6 to freecell 0
Foundations: H-0 C-0 D-0 S-A
Freecells:  JD
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H
: 7S 6C 7D 4D 8S 9D
====================
Move a card from stack 6 to freecell 1
```

### -pi , --display-parent-iter
Global

This option (assuming the -s and -i options are specified) will also display the iteration index of the state from which the current state was derived. This is especially useful for BeFS (so-called a-star) or BFS scans.

### -o [filename] , --output [filename]
Global

Outputs to a file instead of standard output. So for example:

```
$ fc-solve -o 2405.solution.txt 2405.board
```

Will put the solution to the file in 2405.board in the file 2405.solution.txt . This will also be done using:

```
$ fc-solve --output 2405.solution.txt 2405.board
```

### -sel , --show-exceeded-limits
Global

This option will display a different status message ("Iterations count exceeded.") instead of "I could not solve this game." in case the iterations count was exceeded. This is recommended because the "I could not solve this game." message can also mean that the entire game graph was fully traversed (within the limitations of the specified moves' types) and so no solution is possible.

This option is not the default, to retain compatibility with previous versions of Freecell Solver, and was added in version 3.12.0 of fc-solve.

### -hoi , --hint-on-intractable
Global

Presents the moves to the intermediate reached state, if the maximal number of iterations was reached without a conclusion (= "intractable").

This option is not the default, to retain compatibility with previous versions of Freecell Solver, and was added in version 4.20.0 of fc-solve.

## GAME VARIANTS OPTIONS

### --freecells-num [Number of Freecells]
Global

This option specifies the number of freecells which are available to the program. Freecell Solver can use any number of freecells as long as it does not exceed its maximal number.

This maximum is hard-coded into the program, and can be specified at compile-time by modifying the file config.h. See the file INSTALL (or alternatively INSTALL.html) for details.

### --stacks-num [Number of Stacks]
Global

This option specifies the number of stacks present in the board. Again, this number cannot exceed the maximal number of stacks, which can be specified in the file config.h during compile-time of Freecell Solver.

### --decks-num [Number of Decks]
Global

This options specifies how many decks are found in the board. This number cannot exceed the maximal number of decks, which can be specified by the Freecell Solver build system.

### --sequences-are-built-by {suit|alternate_color|rank}
Global

This option specifies whether a card sequence is built by suit or by alternate colour or by rank regardless of suit.

### --sequence-move {limited|unlimited}
Global

This option specifies whether the sequence move is limited by the number of freecells or vacant stacks or not.

### --empty-stacks-filled-by {kings|none|all}
Global

Specifies which cards can fill an empty stack.

### --game [game] , --preset [game] , -g [game]
Global

Specifies the type of game. Each preset implies several of the settings options above and sometimes even the moves’ order below. The default configuration is for Freecell.

Available presets:

bakers_dozen

Baker’s Dozen

bakers_game

Baker’s Game

beleaguered_castle

Beleaguered Castle

citadel

Citadel

cruel

Cruel

der_katz

Der Katzenschwanz

die_schlange

Die Schlange

eight_off

Eight Off

fan

Fan

forecell

Forecell

freecell

Freecell (default)

good_measure

Good Measure

ko_bakers_game

Kings' Only Baker’s Game

relaxed_freecell

Relaxed Freecell

relaxed_sehaven

Relaxed Seahaven Towers

seahaven

Seahaven Towers

simple_simon

Simple Simon

streets_and_alleys

Streets and Alleys

Note: in order to solve Der Katzenschwanz and Die Schlange I recommend you compile Freecell Solver with the INDIRECT_STACK_STATES option, or else it will consume much more memory. For details consult the file INSTALL.

### Examples
To solve PySol Eight Off game No. 1,000 type:

```
$ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off
```

To solve PySol Baker’s Game No. 50, type:

```
$ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game
```

If you want to solve a game similar to Freecell only with sequences built by rank, and unlimited sequence move, do:

```
$ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited
```

## SOLVING ALGORITHM OPTIONS

### -mi [Iterations num] , --max-iters [Iterations num]
Global

This parameter limits the maximal number of states to check. This will give a rough limit on the time spent to solve a given board.

### -md [Maximal depth] , --max-depth [Maximal depth]
Not currently implemented

Freecell Solver recurses into the solution. This parameter specifies a maximal recursion depth. Generally speaking, it’s not a good idea to set it, because that way several important intermediate states may become inaccessible.

### -mss [num] , --max-stored-states [num]
Global

Limits the number of the states stored by the program in the computer’s memory. This differs from the maximal number of iterations in the sense, that it is possible that a stored state was not checked yet.

### -tmss [num] , --trim-max-stored-states [num]
Instance-wide

This also limits the number of trimmed stored states, but this time will try to trim them once the limit has been reached (which is time consuming and may cause states to be traversed again in the future).

### -to [Moves’ Order] , --tests-order [Moves Order]
Soft-thread-specific

This option specifies the order in which Freecell Solver will try the different types of moves (formerly termed "tests") that it can perform. Each move is specified by one character, and they are performed in the order in which they appear in the parameter string. You can omit moves by not including their corresponding characters in the string.

The moves along with their characters are:

Freecell Moves:

0

put top stack cards in the foundations.

1

put freecell cards in the foundations.

2

put freecell cards on top of stacks.

3

put non-top stack cards in the foundations.

4

move stack cards to different stacks.

5

move stack cards to a parent card on the same stack.

6

move sequences of cards onto free stacks.

7

put freecell cards on empty stacks.

8

move cards to a different parent.

9

empty an entire stack into the freecells.

j

put freecell cards on empty stacks and right away put cards on top.

Atomic Freecell Moves:

A

move a stack card to an empty stack.

B

move a stack card to a parent on a different stack.

C

move a stack card to a freecell.

D

move a freecell card to a parent.

E

move a freecell card to an empty stack.

Simple Simon Moves:

a

move a full sequence to the foundations.

b

move a sequence to a true parent of his.

c

move a whole stack sequence to a false parent (in order to clear the stack)

d

move a sequence to a true parent that has some cards above it.

e

move a sequence with some cards above it to a true parent.

f

move a sequence with a junk sequence above it to a true parent that has some cards above it.

g

move a whole stack sequence to a false parent which has some cards above it.

h

move a sequence to a parent on the same stack.

i

move any sequence to a false parent (using it may make the solution much slower).

Manipulating the moves order can be very helpful to the quick solution of a given board. If you found that a certain board cannot be solved in after a long time or in a certain maximal number of iterations, you should try different moves' orders. Usually, one can find a moves order that solves a board very quickly.

Note that this moves order usually makes sense only for the Soft-DFS and Random DFS scans (see the --method option below).

Also note that Freecell moves are not suitable for solving Simple Simon games and Simple Simon moves are not suitable for solving anything except Simple Simon.

Moves can be grouped together into groups using parenthesis (e.g: "(0123)") or square brackets ("[012][3456789]"). Such grouping is only relevant to the Random DFS scan (see below). A group may optionally be followed by the equal sign "=" and by an ordering specifier. If one specifies "=rand()", then the derived states will be randomised based on the seed (which is what happens if no equal sign is specified). On the other hand, if one specifies something like "=asw(5,0,5,0,0,5)", then the numbers inside the parentheses will be treated as weights for the same ordering function used by the -asw flag (see below).

If the order specifier is "=all()" then all the moves in the group will be run, even if some derived states have been yielded by earlier moves in the group. ( This was added in version 5.24.0. )

### -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves' Order]
Soft-thread-specific

Sets the Moves' order starting from the minimal depth onwards. This way, if a Soft-DFS scan recurses deeply into the game, it will use a different moves' order.

Note that if you set the moves' order of a minimal depth of say 50, then it will override all the moves' order of 50 and above. As a result, it is recommended that you set the minimal depth moves order in an increasing depth.

It should be noted that the -to or --tests-order option above is equivalent to using this option with a minimal depth of 0.

Here are some examples:

```
-to 0123456789 -dto2 30,0138924567
```

This sets the moves' order to 0123456789 for all depths below 30 and to 0138924567 for all depths above it.

```
-to 0123457 -dto2 10,750123 -dto2 25,710235
```

This sets the moves' order to 0123457 for depths -9 (those below 10), to 750123 for depths 10-24, and to 710235 for the depths 25 onwards.

```
-to 0123457 -dto2 "10,[012357]=asw(1)"
```

This sorts the moves starting from 10 onward based on the asw() function.

```
-to 0123457 -dto2 "10,[012357]=rand()"
```

This randomises the moves from 10 onward.

```
-to 0123457 -dto2 "10,[012357]"
```

This does the same thing as the previous example.

Note : This option should be used instead of the older -dto option given below which mutilates the moves order parameter and is still provided for backward compatibility.

### -dto [Min Depth],[Moves' Order] , --depth-tests-order [Min Depth],[Moves' Order]
This is equivalent to specifying -dto2 [Min Depth],[Min Depth],[Moves' Order] - i.e: the "[Min Depth]," string is prefixed to the given moves order.

This option is provided for backward compatibility with older versions of Freecell Solver.

### -me [Solving Method] , --method [Solving Method]
Soft-thread-specific

This option specifies the solving method that will be used to solve the board. Currently, the following methods are available:

•a-star - A Best-First-Search scan (not "A*" as it was once thought to be)

•bfs - A Breadth-First Search (or BFS) scan

•dfs - A Depth-First Search (or DFS) scan

•random-dfs - A randomized DFS scan

•patsolve - uses the scan of patsolve.

•soft-dfs - A "soft" DFS scan

Starting from recent Freecell Solver versions there is no difference between dfs and soft-dfs. In earlier versions, use of soft-dfs is recommended. random-dfs is similar to soft-dfs only it determines to which states to recurse into randomly. Its behaviour will differ depending on the seed you supply to it. (see the "-seed" option below.)

BFS does not yield good results, and a-star has a mixed behaviour, so for the time being I recommend using Soft-DFS or Random-DFS.

The Random-DFS scan processes every moves' random group, randomizes the states that it found and recurses into them one by one. Standalone moves that do not belong to any group, are processed in a non-random manner.

### -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
Soft-thread-specific

Specify weights for the a-star (= "Best-First Search") scan, assuming it is used. The parameter should be a comma-separated list of numbers, each one is proportional to the weight of its corresponding test.

The numbers are, in order:

1.The number of cards out.

2.The maximal sequence move.

3.The number of cards under sequences.

4.The length of the sequences which are found over renegade cards.

5.The depth of the board in the solution.

6.The negative of the number of cards that are not placed above their parents. To get the irreversibility depth, give equal weight to this weight and to the number of cards out.

The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}

### -seed [Seed Number]
Soft-thread-specific

Specifies a seed to be used by Freecell Solver’s internal random number generator. This seed may alter the behaviour and speed of the random-dfs scan.

### --set-pruning [Pruning] , -sp [Pruning]
Soft-thread-specific

This option sets the pruning algorithm for the soft thread. Current valid values are only the empty string ("") for no pruning and r:tf (short for "Run: to foundations") for Horne’s rule. See:

<https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214>

### -opt , --optimize-solution
Flare-wide

This option instructs Freecell Solver to try and optimize the solution path so it will have a smaller number of moves.

### -opt-to [moves order] , --optimization-tests-order [moves order]
Flare-wide

This argument specifies the moves order for the optimization scan, in case it should be different than an order that contains all the moves that were used in all the normal scans.

### --reparent-states
Flare-wide

This option specifies that states that were encountered whose depth in the states graph can be improved should be reparented to the new parent. This option can possibly make solutions shorter.

### --calc-real-depth
Flare-wide

This option becomes effective only if --reparent-states is specified. What it does, is explicitly calculate the depth of the state by tracing its path to the initial state. This may make depth consideration more accurate.

### --patsolve-x-param [pos],[value]
Soft-thread-specific

Sets the patsolve’s scan X param (an integer) in position "pos" into "value".

Examples:

```
--patsolve-x-param 0,5
--patsolve-x-param 2,100
```

### --patsolve-y-param [pos],[value]
Soft-thread-specific

Sets the patsolve Y param (a floating point number) in position "pos" into "value".

Examples:

```
--patsolve-y-param 0,0.5
--patsolve-y-param 1,103.2
```

## RUNNING SEVERAL SCANS IN PARALLEL
Starting from Version 2.4.0, Freecell Solver can run several scans in parallel on the same state collection. Each scan resides in its own "Soft Thread". By specifying several soft threads on the command line one can create and run several task-switched scans. Once one of the scans reaches a solution, the solution will be displayed.

### -nst , --next-soft-thread
Hard-thread-specific

This option creates a new soft-thread and makes the following scan-specific options initialize it. For example:

```
$ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
```

will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467 on myboard.txt.

### -step [Step] , --soft-thread-step [Step]
Soft-thread-specific

This option will set the number of iterations with which to run the soft thread before switching to the next one. By specifying a larger step, one can give a certain scan a longer run-time and a higher priority.

Note: after some experimentation, we have concluded that the --prelude option normally yields better results, but -step can be used as a fallback.

### -nht , --next-hard-thread
Flare-wide

This argument lets one initialize the next hard thread. If Freecell Solver was compiled with such support, then it is possible to run each hard thread in its own system thread. Each hard-thread contains one or more soft threads.

### --st-name [soft thread name]
Soft-thread-specific

This argument sets the name used to identify the current soft thread. This name can later be used to construct the prelude (see below).

### --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
Hard-thread-specific

Sets the prelude for the hard thread. At the beginning of the search, the hard thread plays a static sequence of iterations at each of the soft threads specified in the prelude, for the number of iterations specified.

For example, if you had three soft threads named "foo", "bar" and "rin", then the following prelude:

```
--prelude 500@foo,1590@bar,100@foo,200@rin
```

Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo" again, and then 200 in "rin". After the prelude finishes, the hard thread would run the scans one after the other in the sequence they were defined for their step number.

### --scans-synergy {none|dead-end-marks}
Flare-wide

Specifies the synergy between the various scans, or how much they cooperate between themselves. none means they do not cooperate and only share the same memory resources. dead-end-marks means they try to mark states that they have withdrawn from, and states whose all their derived states are such, as "dead ends". This may or may not improve the speed of the solution.

### -ni , --next-instance
Global

This option allows one to run two or more separate solvers one after the other. If the first one returned an unsolvable verdict, then the second one would run and so on. One use of it is to run an atomic moves scan after a meta-moves scan, so we will always get an accurate verdict and still enjoy some of the speed benefits of the meta-moves scan.

### -nf , --next-flare
Instance-wide

Each instance contains several flares. Flares are various alternative scans, that are ran one after another, as specified in the --flares-plan below or defaulting to running only the first flare (which isn’t very useful). Out of all the flares that are successful in solving a board, Freecell Solver picks the one with the shortest solution.

### --flare-name [flare name]
Flare-wide

This is a name that identifies the flare for use in the flares' plan.

### --flares-plan [flare plan]
Instance-wide

This instance-wide parameter gives a plan for the flares as a big string. Here are some examples:

```
--flares-plan "RunIndef:FlareyFlare"
```

This plan will run the flare with the name FlareyFlare indefinitely, until it terminates. Once a RunIndef action is encountered, the rest of the plan is ignored.

```
--flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
```

Runs MyFlare for 500 iterations and FooFlare for 2,000 iterations. Note that both flares will be run and won’t share any resources between them, and then the minimal solution out of both flares (or only those that finished ). If no flares finished, then Freecell Solver will run them both again for the same number of iterations each, until at least one finishes (or it ran out of the iterations' limit).

```
--flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
```

This runs the flares identified by dfs and befs and then see if a solution was reached ("CP:" stands for "checkpoint"), and if so yield it. If both flares did not reach a solution yet, or failed to solve the board, it will run the flare funky for 10,000 iterations and yield its solution. And like the previous case, this solution will loop after it ended for as long as the no flare solved the board or the program did not run out of iterations.

Using checkpoints one can yield a possibly sub-optimal (as far as solution length is concerned) solution that will still solve faster than letting all the flares run.

### --flares-choice [choice]
Global

This dictates how to choose the winning flare based on if more than one yielded a solution. Possible options are:

1.--flares-choice fc_solve - the default, which picks up the solutions based on the length of the solution in Freecell Solver’s moves.

2.--flares-choice fcpro - picks up the shortest solution based on the number of Freecell Pro moves, while not considering implicit moves to the foundations using Horne’s Prune / Raymond Prune.

### -fif [factor] , --flares-iters-factor [factor]
Global

Sets a global, floating-point number, factor to multiply all the iterations counts in the flares plans. The higher it is, the longer the scans will take, but there is a greater chance more of them will succeed, and, as a result, the solution may be shorter.

As an example, the following:

```
--flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
```

Is equivalent to:

```
--flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
```

while:

```
--flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
```

Is equivalent to:

```
--flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
```

### --cache-limit [cache limit]
Global

This is a numeric limit to the LRU cache which only matters if Freecell Solver was compiled with FCS_RCS_STATES enabled. This value should be a positive integer and the higher it is, the more quickly it is likely that Freecell Solver will run, but it will also consume more memory. (The entire point of FCS_RCS_STATES is to conserve memory).

## META-OPTIONS

### --reset
Global

This option resets the program to its initial state, losing all the configuration logic that was input to it up to that state. Afterwards, it can be set to a different configuration, again.

### --read-from-file [num_skip,]filename
Global (but context-specific).

This option will read the configuration options from a file. The format of the file is similar to that used by the UNIX Bourne Shell. (i.e: spaces denote separate arguments, double-quotes encompass arguments, backslash escapes characters).

The filename can be preceded by an optional number of the arguments to skip followed by a comma. (the default is 0)

### -l [preset] , --load-config [preset]
Global (but context-specific).

Reads the configuration specified by [preset] and configures the solver accordingly. A preset is a set of command line arguments to be analyzed in the place of this option. They are read from a set of presetrc files : one installed system-wide, the other at $HOME/.freecell-solver/presetrc and the third at the path specified by the FREECELL_SOLVER_PRESETRC environment variable. You can add more presets at any of these places. (refer to <http://groups.yahoo.com/group/fc-solve-discuss/message/403> for information about their format)

Presets that are shipped with Freecell Solver:

abra-kadabra

a meta-moves preset

amateur-star

a meta-moves preset that yields solutions faster on average than three-eighty.

blue-yonder

a meta-moves preset generated by a quota optimization algorithm.

children-playing-ball

a meta-moves and flare-based preset that tends to yield very short solution, but is very slow (solves only 3 boards per second on a Pentium 4 2.4GHz).

conspiracy-theory

a meta-moves preset that yields solutions faster on average than amateur-star.

cookie-monster

a meta-moves preset that yields solutions faster on average than one-big-family.

cool-jives

a meta-moves preset

crooked-nose

an atomic-moves preset (guarantees an accurate verdict)

enlightened-ostrich

a meta-moves preset (that depends on Freecell Solver 3.4.0 and above) that yields solutions faster on average than foss-nessy.

fools-gold

an atomic-moves preset

foss-nessy

a meta-moves preset (that depends on Freecell Solver 3.2.0 and above) that yields solutions faster on average than the-iglu-cabal.

good-intentions

runs "cool-jives" and then "fools-gold"

gooey-unknown-thing

a meta-moves preset that aims to minimise the outcome solution’s length.

hello-world

a meta-moves preset

john-galt-line

a meta-moves preset

looking-glass

a meta-moves preset that yields solutions faster on average than cookie-monster.

maliciously-obscure

a meta-moves and flare-based preset that tends to yield very short solutions (even in comparison to children-playing-ball ) but is slow.

micro-finance

a meta-moves and flare-based preset that tends to yield very short solutions (even in comparison to maliciously-obscure ) but is even slower.

micro-finance-improved

a meta-moves and flare-based preset, based on micro-finance that yields somewhat shorter solutions on average, and should not be slower.

one-big-family

a meta-moves preset that yields solutions faster on average than conspiracy-theory.

qualified-seed

a meta-moves and flare-based preset, based on micro-finance-improved that yields somewhat shorter solutions on average, and should not be slower.

qualified-seed-improved

qualified-seed with -fif 5 and --flares-choice fcpro

rin-tin-tin

a meta-moves preset

sand-stone

an atomic-moves preset that aims to minimise the outcome solution’s length.

slick-rock

run "gooey-unknown-thing" and then "sand-stone"

sentient-pearls

a meta-moves and flares based preset with short solutions. Much faster than children-playing-ball but yields less optimal solutions.

tea-for-two

a meta-moves preset optimized for two-freecells' Freecell games (although it can work on other Freecell-like games as well).

the-iglu-cabal

a meta-moves preset that yields faster solutions on average than blue-yonder.

the-last-mohican

a preset for solving Simple Simon. Yields less false negatives than the default one, but might be slower.

three-eighty

a meta-moves preset (that depends on Freecell Solver 3.4.0 and above) that yields solutions faster on average than enlightened-ostrich.

toons-for-twenty-somethings

an atomic-moves preset that solves more boards efficiently than "fools-gold".

video-editing

a meta-moves and flare-based preset, based on qualified-seed that yields shorter solutions on average, but may be somewhat slower. Named to commemorate the earlier work of Adrian Ettlinger (1925-2013) <http://en.wikipedia.org/wiki/Adrian_Ettlinger> who later contributed to Freecell Solver and to Freecell research.

yellow-brick-road

a meta-moves preset

They can be abbreviated into their lowercase acronym (i.e: "ak" or "rtt").

## RUN-TIME DISPLAY OPTIONS

### -i , --iter-output
Global

This option tells fc-solve to print the iteration number and the recursion depth of every state which is checked, to the standard output. It’s a good way to keep track of how it’s doing, but the output slows it down a bit.

### --iter-output-step [step]
Global

Prints the current iteration if -i is specified, only every [step] steps, where [step] is a positive integer. For example, if you do fc-solve -i --iter-output-step 100, you will see this:

```
Iteration: 0
Iteration: 100
Iteration: 200
Iteration: 300
```

This option has been added in Freecell Solver 4.20.0 and is useful for speeding up the runtime process, by avoiding excessive output.

### -s , --state-output
Global

This option implies -i. If specified, this option outputs the cards and formation of the board itself, for every state that is checked. "fc-solve -s" yields a nice real-time display of the progress of Freecell Solver, but you usually cannot make what is going on because it is so fast.

## SIGNAL COMBINATIONS
If you are working on a UNIX or a similar system, then you can set some run-time options in "fc-solve" by sending it some signal combinations.

If you send the fc-solve a single ABRT signal, then fc-solve will terminate the scan prematurely, and report that the iterations’s limit has been exceeded.

If you send the signal USR1, without sending any other signals before that, then fc-solve will output the present number of iterations. This method is a good way to monitor an instance that takes a long time to solve.

If you send it the signal USR2 and then USR1, then fc-solve will print the iteration number and depth on every state that it checks. It is the equivalent of specifying (or unspecifying) the option -i/--iter-output.

If you send it two USR2 signals and then USR1, then fc-solve will also print the board of every state. Again, this will only be done assuming the iteration output is turned on.

## AUTHOR
Shlomi Fish


title: fc-solve-board_gen(6)

summary: make\-microsoft\-freecell\-board, make_pysol_freecell_board.py \-

text:
# fc-solve-board_gen(6)

## NAME
pi-make-microsoft-freecell-board, make_pysol_freecell_board.py - Programs to generate boards to be used as input to Freecell Solver.

## SYNOPSIS
pi-make-microsoft-freecell-board [-t] board-number

or for make_pysol_freecell_board.py:

make_pysol_freecell_board.py [-t] [-F] [--ms] board-number [game-string]

## DESCRIPTION
These programs are command-line programs that can generate the initial board of the games of several popular Solitaire implementations. Those boards can be in turn be input to fc-solve by means of a pipeline, or placed inside a file for safe-keeping.

make_pysol_freecell_board.py also accepts an optional third argument which indicates the game variants. This type defaults to Freecell, but is useful for generating the boards of other games. Note that using this flag still requires one to use the "--game" flag of fc-solve, if necessary.

make_pysol_freecell_board.py also accepts a flag called -F or --pysolfc that deals the PySolFC boards instead of the classic PySol ones, and one called --ms or -M that deals Microsoft Freecell/Freecell Pro deals even for higher seeds.

A common paradigm for using those programs is something like:

```
    bash:~$ pi-make-microsoft-freecell-board -t 11982 | fc-solve -l gi
```

If the "-t" option is specified, then the 10 cards are printed with "T"'s, instead of "10"'s. While fc-solve can accept either as input, it may prove useful for other solvers or solitaire implementations which do not accept "10"'s.

Here is a short description of each program:

make_pysol_freecell_board.py

A Python script that generates the boards of the various games of PySol.

pi-make-microsoft-freecell-board

A program that generates the boards of Microsoft Freecell and of the Freecell Pro implementation of Freecell.

## OPTIONS
board-number is the board number as a decimal number.

game-string is a string describing the game. Valid strings and their respective games are:

bakers_game - Baker's Game

bakers_dozen - Baker's Dozen

beleaguered_castle - Beleaguered Castle

citadel - Citadel

cruel - Cruel

der_katz - Der Katzenschwantz

die_schlange - Die Schlange

eight_off - Eight Off

fan - Fan

forecell - Forecell

freecell - Freecell (the default)

good_measure - Good Measure

ko_bakers_game - Kings' Only Baker's Game

relaxed_freecell - Relaxed Freecell

relaxed_seahaven - Relaxed Seahaven Towers

seahaven - Seahaven Towers

simple_simon - Simple Simon

streets_and_alleys - Streets and Alleys

## SEE ALSO
fc-solve (6)

gen-multiple-pysol-layouts (6)

/usr/share/doc/freecell-solver-FCS_VERSION/board_gen/README

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


freecell-solver-range-parallel-solve

title: freecell-solver-range-parallel-solve(6)

summary: The Freecell Solver utility for

text:
# freecell-solver-range-parallel-solve(6)

## NAME
freecell-solver-range-parallel-solve - The Freecell Solver utility for solving a range of Microsoft Freecell/Freecell Pro Boards

## SYNOPSIS
freecell-solver-range-parallel-solve start end print_step [--binary-output-to filename] [fc-solve Arguments...]

## DESCRIPTION
freecell-solver-range-parallel-solve is a command line application that solves a range of Freecell deals of Microsoft Freecell and Freecell Pro.

start is the first board to solve; end is the last (inclusive) and print_step is the division of board numbers in which to print a status message.

Following this three mandatory parameters are several flags specific to the range solve. (refer to the OPTIONS section for more information)

Afterwards one can give it a fc-solve command line that it will use to solve each board. Refer to the fc-solve(6) man page for information about its options.

## OPTIONS
--binary-output-to sets the filename into which to output the number of iterations it took to solve each board. This file can later be used with statistical preset optimizers such as those found in the Freecell Solver version control repository.

## SEE ALSO
fc-solve(6)

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


gen-multiple-pysol-layouts

title: gen-multiple-pysol-layouts(6)

summary: generate multiple PySol / MS initial

text:
# gen-multiple-pysol-layouts(6)

## NAME
gen-multiple-pysol-layouts. - generate multiple PySol / MS initial solitaire deals.

## SYNOPSIS
gen-multiple-pysol-layouts --dir=[dir] --prefix=[prefix] --suffix=[suf] [idxs...]

## DESCRIPTION
This program emits some starting PySol / Freecell Pro deals in separate files inside the target directory.

Some examples:

```
    gen-multiple-pysol-layouts --dir foo/ --prefix "" --suffix .board --ms 24 42 100
    gen-multiple-pysol-layouts --dir foo/ --prefix "" --suffix .board --ms seq 1 32000
    gen-multiple-pysol-layouts --dir foo/ --prefix "" --suffix .board --ms read /path/to/indexes-file.txt
```

Generate Black Hole solitaire <https://en.wikipedia.org/wiki/Black_Hole_%28solitaire%29> PySol FC deals:

```
    gen-multiple-pysol-layouts --game black_hole --dir foo/ --prefix "" --suffix .board seq 100000 200000
```

## OPTIONS
To be discussed.

## SEE ALSO
pi-make-microsoft-freecell-board (6), make_pysol_freecell_board.py (6).

/usr/share/doc/freecell-solver-FCS_VERSION/board_gen/README

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


transpose-freecell-board.py

title: transpose-freecell-board.py(6)

summary: transpose a Freecell/etc. layout from play\-stacks

text:
# transpose-freecell-board.py(6)

## NAME
transpose-freecell-board.py - transpose a Freecell/etc. layout from play-stacks in text-columns to play-stacks in text lines.

## SYNOPSIS
transpose-freecell-board.py -o output_fn input_fn | -

## DESCRIPTION
This programs transposes a Freecell/etc. layout.

Sample input:

```
    4C 5H QC 5D 2D 7H AH 7S
    2H QH 9S 2S KD JS 5S 6C
    9C 3C 6H JC TH KH 6S 7D
    8C AC 9H 5C TC TS AD 4D
    QS 3H 3S JH TD    8H 8S
       4H KS 6D 8D    JD
       QD 3D AS       KC
          2C          9D
          4S
          7C
```

Sample output:

```
    : 4C 2H 9C 8C QS
    : 5H QH 3C AC 3H 4H QD
    : QC 9S 6H 9H 3S KS 3D 2C 4S 7C
    : 5D 2S JC 5C JH 6D AS
    : 2D KD TH TC TD 8D
    : 7H JS KH TS
    : AH 5S 6S AD 8H JD KC 9D
    : 7S 6C 7D 4D 8S
```

The columns are prefixed with a single optional "Foundations:" line followed by a single optional "Freecells:" line in fc-solve format.

## OPTIONS
-o Specify an output filename.

## SEE ALSO
fc-solve (6)

/usr/share/doc/freecell-solver-FCS_VERSION/board_gen/README

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

Thanks to Manish Jain for inspiring this program.


freeciv-client

package: freeciv-client-data

title: freeciv-client(6)

summary: The clients for the Freeciv game

text:
# freeciv-client(6)

## NAME
freeciv-gtk2, freeciv-gtk3, freeciv-gtk3.22, freeciv-sdl, freeciv-sdl2, freeciv-qt, freeciv-xaw - The clients for the Freeciv game

## SYNOPSIS
freeciv-gtk2|freeciv-gtk3|freeciv-gtk3.22|freeciv-sdl|freeciv-sdl2|freeciv-qt|freeciv-xaw [ -A|--Announce protocol ] [ -a|--autoconnect ] [ -d|--debug level_number ] [ -F|--Fatal [ signal_number ] ] [ -f|--file filename ] [ -h|--help ] [ -l|--log filename ] [ -M|--Meta URL ] [ -n|--name name ] [ -p|--port port ] [ -P|--Plugin string ] [ -r|--read filename ] [ -s|--server address ] [ -S|--Sound name ] [ -t|--tiles name ] [ -v|--version ] [ -- client-specific-parameters ]

freeciv-gtk2 accepts the standard Gtk parameters following --; see the Gtk documentation. It also accepts [ -h|--help ]

freeciv-gtk3 accepts the standard Gtk parameters following --; see the Gtk documentation. It also accepts [ -g|--gtk-warnings ] [ -h|--help ] [ -r|--resolution WIDTHxHEIGHT ]

freeciv-gtk3.22 accepts the standard Gtk parameters following --; see the Gtk documentation. It also accepts

freeciv-qt accepts the standard Qt parameters following --; see the Qt documentation. It also accepts [ -h|--help ]

freeciv-sdl accepts the following parameters following --: [ -e|--eventthread ] [ -f|--fullscreen ] [ -h|--help ] [ -t|--theme string ]

freeciv-sdl2 accepts the following parameters following --: [ -f|--fullscreen ] [ -h|--help ] [ -t|--theme string ]

freeciv-xaw accepts the standard X11 toolkit parameters following --; see X(7) . It also accepts [ -h|--help ]

## DESCRIPTION
Freeciv is a free turn-based multiplayer strategy game, in which each player becomes the leader of a civilization, fighting to obtain the ultimate goal: To become the greatest civilization.

Players of Civilization II® by Microprose® should feel at home, since one aim of Freeciv is to have compatible rules.

Freeciv is maintained by an international team of coders and enthusiasts, and is easily one of the most fun and addictive network games out there!

This is the client program used to connect to a Freeciv server - see also freeciv-server(6) . freeciv-gtk2, freeciv-gtk3, freeciv-gtk3.22, freeciv-qt, freeciv-sdl, and freeciv-sdl2 can also spawn their own local server for single-player games.

This manual page only lists the command line arguments. For more details about using freeciv-gtk2, freeciv-gtk3,freeciv-gtk3.22, freeciv-sdl, freeciv-sdl2, freeciv-qt, or freeciv-xaw, see the Client Manual which can be found at the Freeciv website as well as the documentation which is part of the Freeciv distribution.

## OPTIONS
The following options are accepted by all clients. They may not be combined; that is, "-np caesar 5557" will not work, instead you would need to enter "-n caesar -p 5557". All options have a short form (single hyphen and single letter) and a long form (double hyphen and a complete word); their effects are identical.

-A protocol, --Announce protocol

Uses protocol when searching for games on a LAN. Possible values for protocol are: IPv4

IPv6

none

-a, --autoconnect

Skips the connect dialog, automatically inserting the default values. This is quite convenient when all has been set up properly.

-d level_number, --debug level_number

Sets the amount of debugging information to be logged in the file named by the -l option. Acceptable values for the level_number are: 0 for fatal messages only.

1 for fatal and error messages.

2 for fatal, error and normal messages (default).

3 for fatal, error, normal, and verbose messages.

-F [ signal_number ], --Fatal [ signal_number ]

Raise a custom signal on failed assertion. If signal_number is not specified, then the ABRT signal will be used.

-f filename, --file filename

Loads a saved game file (filename). This is for reloading previously saved games, or for starting scenarios from the command line.

-h, --help

Prints a short summary of the standard command line options.

-l filename, --log filename

Defines a log file, filename, to be produced during processing. Use the -d option to set how much is logged. By default, fatal, error, and normal messages are printed to standard output. With a log file, such messages go to the log instead. If filename already exists, it is appended to.

-M URL, --Meta URL

Specifies the URL of the metaserver to connect to. A metaserver is a place where Freeciv servers can publish their presence. Freeciv clients consult the metaserver to offer users a selection of games to join. By default, the standard metaserver run by the Freeciv maintainers will be used.

-n name, --name name

Specifies the user name (name) to use to connect to the server. This option is critical when reconnecting to a game. Please note that you might need to quote your username.

-p port, --port port

Specifies the server port to connect to. By default this is 5556, if in doubt ask the server administrator.

-P string, --Plugin string

Specifies the plugin to use for sound output. Available options for string are: none

sdl

-r filename, --read filename

Specifies a file, filename, of server commands which a server spawned by the client will automatically read and process, as if you had typed them in at the server's prompt.

-s address, --server address

Specifies the game server address to connect to. This server might easily run on the same machine as the client.

-S name, --Sound name

Specifies the sound set to use. A file called name.soundspec is searched for in the usual places (see the FILES section).

-t name, --tiles name

Specifies the map graphics ("tiles") to be used within the game. A file called name.tilespec is searched for in the usual places (see the FILES section). Currently the following tilespecs are distributed with Freeciv: • amplio2.tilespec

• cimpletoon.tilespec

• hex2t.tilespec

• isophex.tilespec

• isotrident.tilespec

• trident.tilespec

-v, --version

Prints the version number and exits.

--

All parameters following this -- will be considered as client-specific parameters.

-- -e, -- --eventthread

Initializes the event subsystem in other thread. Only available for the freeciv-sdl client under Linux or BeOS.

-- -f, -- --fullscreen

Starts the client in full screen mode. Only implemented in the freeciv-sdl and freeciv-sdl2 client.

-- -h, -- --help

Print the client-specific parameter help.

-- -r WIDTHxHEIGHT, -- --resolution WIDTHxHEIGHT

Behave as if screen resolution were WIDTHxHEIGHT. Only implemented in the freeciv-gtk3 and freeciv-gtk3.22 clients.

-- -t theme, -- --theme theme

Use a particular GUI theme. Only implemented in the freeciv-sdl and freeciv-sdl2 clients.

## EXAMPLES
freeciv-gtk3 --name "King Richard" --server io.daimi.aau.dk

Starts the GTK3 client using the name King Richard and connecting to the server at io.daimi.aau.dk.

freeciv-sdl -a -t trident

Starts the SDL client with the trident tiles and autoconnects to localhost.

## FILES
~/.freeciv/freeciv-client-rc-[version-number]

This is where your local settings will be stored.

tilespecs

These are searched for in the data path; see ENVIRONMENT.

soundspecs

These are searched for in the data path; see ENVIRONMENT.

The freeciv-modpack(6) utility can be used to locate and download additional content such as tilesets and soundsets and (for client-spawned servers only) scenarios and rulesets; it saves files under ~/.freeciv .

## ENVIRONMENT
The Freeciv client accepts these environment variables:

FREECIV_CAPS

A string containing a list of "capabilities" provided by the server. The compiled-in default should be correct for most purposes, but if you are familiar with the capability facility in the source you may use it to enforce some constraints between clients and server.

FREECIV_COMPRESSION_LEVEL

Sets the compression level for network traffic.

FREECIV_DATA_ENCODING

Sets the character encoding used for data files, savegames, and network strings). This should not normally be changed from the default of UTF-8, since that is the format of the supplied rulesets and the standard network protocol.

FREECIV_INTERNAL_ENCODING

Sets the character encoding used internally by the freeciv client. This generally needs to match the GUI toolkit, so its default depends on the specific client; most clients default to UTF-8.

FREECIV_LOCAL_ENCODING

Sets the local character encoding (used for the command line and terminal output). The default is inferred from other aspects of the environment.

FREECIV_MULTICAST_GROUP

Sets the multicast group (for the LAN tab).

FREECIV_DATA_PATH

A colon separated list of directories pointing to the freeciv data directories. By default Freeciv looks in the following directories, in order, for any data files: the current directory; the "data" subdirectory of the current directory; the subdirectory ".freeciv/2.6" in the user's home directory; and the directory where the files are placed by running "make install". If not set, FREECIV_PATH is checked before these defaults are used.

FREECIV_SAVE_PATH

A colon separated list of directories pointing to the freeciv save directories. By default Freeciv looks in the following directories, in order, for save files: the current directory; and the subdirectory ".freeciv/saves" in the user's home directory. If not set, FREECIV_PATH is checked before these defaults are used; in this case Freeciv also looks in "saves" potential subdirectories. (This does not affect where the server spawned by the client creates save game files; these are always created in ".freeciv/saves" in the user's home directory.)

FREECIV_SCENARIO_PATH

A colon separated list of directories pointing to the freeciv scenario directories. By default Freeciv looks in the following directories, in order, for scenario files: the current directory; the "data/scenarios" subdirectory of the current directory; the subdirectories ".freeciv/2.6/scenarios" and then ".freeciv/scenarios" in the user's home directory; and the directory where the files are placed by running "make install". If not set, FREECIV_PATH is checked before these defaults are used; in this case Freeciv also looks in "scenario" and "scenarios" potential subdirectories. (This does not affect where the server spawned by the client creates scenario files; these are always created in ".freeciv/scenarios" in the user's home directory.)

FREECIV_PATH

A colon separated list of directories to look for various files. This variable has no effect if FREECIV_DATA_PATH, FREECIV_SAVE_PATH and FREECIV_SCENARIO_PATH are defined together; those variables are the recommended way to override paths, with FREECIV_PATH provided only for backward compatibility with older versions of Freeciv; FREECIV_PATH will be removed in a future release. The precise search path depends on the type of file being searched for.

FREECIV_OPT

Specifies a file to contain local settings, instead of ~/.freeciv/freeciv-client-rc-[version-number].

HOME

Specifies the user's home directory.

http_proxy

Set this variable accordingly when using a proxy.

LANG or LANGUAGE

Sets the language and locale on some platforms.

LC_ALL or LC_CTYPE

Similar to LANG (see documentation for your system).

USER

Specifies the username of the current user.

## BUGS
Please report bugs to the Freeciv bug tracker .

## MORE INFO
See the Freeciv homepage .

Updates and new info is first posted there.

## AUTHORS
The Freeciv Team <freeciv-dev AT freelists.org>.

This manpage was originally put together by Florian Ernst <florian_ernst AT gmx.net> using the Client Manual and the comments in the sourcecode. It was updated by Ben Bettin <bwbettin AT gmail.com> to add new features, integrate information from the website's online documentation, and for slight formatting adjustments. Feel free to use it as you wish.

## SEE ALSO
freeciv-server(6) freeciv-modpack(6) and the Client Manual at the Freeciv homepage.