pmars

package: pmars

title: pmars(6)

text:
# pmars(6)

## NAME
pmars - portable corewar system with ICWS'94 extensions

## SYNOPSIS
pmars [ option ... ] file1 [ file(s) ]

## DESCRIPTION
pMARS (portable Memory Array Redcode Simulator) is a corewar interpreter with multi-platform support. pMARS currently runs on UNIX systems, PC/DOS, VMS, Amiga (AmigaDOS command line), and the Mac. pMARS implements the ICWS'94 draft standard, but can also be used in ICWS'88 mode. The base system includes a graphical core display for UNIX (curses, X-windows), PC/linux (svgalib), PC/DOS and the Mac (see APPENDIX). A line-oriented debugger is included to help in writing warriors for the ICWS'94 draft standard.

pMARS runs one or more warriors written in Redcode that are provided as file(s) on the command line. Running a single warrior is supported for debugging. Two warriors are pitted against each other for standard play, but up to 36 warriors can be named for "multi-warrior" core war. If the warrior(s) assemble without error they are loaded into the core array and executed in round-robin mode starting with the first warrior. Warrior 1 is loaded starting at core position 0, warrior 2, 3, etc., at either a random or fixed position. For fairness the starting order is rotated after each round.

## SCORE
The score is reported after all rounds have been played. A round ends when either a single surviving warrior remains or when a maximum number of cycles has elapsed. For each round, every surviving warrior is awarded points calculated from a score formula (F). By default, this is (W*W-1)/S, where W is the total number of warriors participating, S is the number of of survivors, and "/" is integer division. Alternative score formulas can be specified with the = option (see below).

When two warriors battle, the results are reported as wins1, wins2, and ties, where wins1 and wins2 are the numbers of rounds that each warrior won, and ties are the number of rounds in which both warriors lasted until time-out. The score is then:

```
        warrior 1:  points = wins1 * F + ties * F

        warrior 2:  points = wins2 * F + ties * F
```

F is a score formula containing the W and S parameters. When more than two warriors (W) participate in a game, results are reported as wins[1], wins[2], .., wins[W], losses for each warrior, where the index indicates the number of warriors that survived until the end (S parameter in the score formula). The total number of points for each warrior is then calculated as:

```
        points =  sum (S=1..W) (wins[S] * F)
```

A few alternative score formulas:

```
        10

        (W+1)/S

        (x=W-S+1)*(x+1)/2

        (S==3)*5 + (S==2)*3 + (S==1)

        (S == 1)*W + (S != 1)
```

## OPTIONS
Command line options may occur anywhere on the command line. Single-letter options without a parameter can be combined as in -fbe. The special argument - (dash) stands for standard input (stdin). It can be combined with the -@ option (see below) to signify reading options from stdin, or the - can take the place of a warrior filename, in which case warrior code starting with a ;redcode line and ending with an END statement is extracted from stdin. The END statement can be omitted if the next ;redcode line immediately follows the last instruction. Several warriors, each specified by a separate dash on the command line and bracketed by ;redcode/END can be piped into pMARS. #- (where # is a positive number) is a shorthand for writing this number of dashes on the command line.

-r #

This options sets the number of rounds to play. The default is 1. -r 0 produces assembly output (unless -b is specified), but does not execute the warrior(s). A maximum of 32787 rounds can be specified.

-s #

The -s option specifies the size of core memory in number of instructions. It defaults to 8000. Maximum core size is platform-dependent, but usually at least 65535.

-c #

-c sets the maximum number of cycles per round. A cycle consists of one execution of each warrior. A round ends when either a single warrior remains executing or when the maximum number of cycles has elapsed.

-p #

This option sets the maximum number of processes a warrior can run. The default is 8000.

-l #

This sets the maximum length of a warrior source file in instructions. It defaults to 100 and can be up to 500.

-d #

This option specifies the minimum distance between the first instruction of each warrior. It cannot be smaller than the maximum length (-l option) and defaults to 100 instructions.

-S #

The -S option sets the size of the P-space to # cells. The default is 1/16th of core size if core size is evenly divisible by sixteen, or the next larger divisible fraction. See also the P-SPACE section below.

-f

The -f option instructs the loader to use a fixed series of addresses for positioning warriors. This is done by initializing the pseudo random number generator with a checksum value derived from the source of all warriors. Thus, initial placements will still be "random" from round to round, but will be the same if the same warriors are run again. As a consequence, the result of battles run with the -f option will show no statistical fluctuations. This options is useful for validating ports of pMARS to new platforms and for providing an absolute, albeit arbitrary performance measure for warriors.

-F #

This option server two purposes. It sets the seed value of the pseudo random number generator, and also tells the loader to install warrior 2 at the given address # for round 1. If the number is larger than the core size minus the minimum warrior distance, it will be wrapped around to the range of available starting positions. This option is useful for testing different versions of a warrior with constant initial placement. Warrior 1 is always installed at address 0. The -F and -f options are mutually exclusive. If neither option is specified, the pseudo random number generator is initialized with the system time.

-P

This option makes pMARS use an alternative algorithm for positioning warriors. This algorithm uses all possible combinations of starting order and position in a random sequence, and will not use the same combination twice unless all the combinations have already been used. If the -r option is not given, the number of rounds fought will be the number of all possible combinations. Trying to use this option with more (or less) than two warriors causes an error.

-e

If this option is specified, the cdb debugger is entered immediately after loading warriors into core.

-b

This options runs pMARS in brief output mode. -b suppresses warrior listings after assembly.

-k

With the -k option, pMARS uses the same output format as the KotH program. This option enables pMARS to work with scripts written for the KotH server.

-8

This options enforces strict compliance with the ICWS'88 standard and disables all ICWS'94 language extensions, which are flagged as syntax errors by the assembler. Since ICWS'94 is a superset of ICWS'88, this options is not necessary to run ICWS'88 warriors.

-o

When this option is given, pMARS reports scores in decreasing order rather than in the order warriors were named on the command line. This is mostly useful for multi-warrior play.

-V

The assembler generates verbose output with this option. This is only useful for debugging.

-v

This option sets the display mode for UNIX and DOS display versions (see APPENDIX).

-@ <fn>

pMARS continues reading options and filenames from the parameter file <fn>. If <fn> is a - (dash) standard input is parsed. Comments in the parameter file start with a semicolon.

-= <string>

The = (equal) option allows you to specify a custom score formula (see SCORE). The formula may contain the standard arithmetic and logical operators (as in the C language), as well as the parameters W (number of warriors participating) and S (number of warriors surviving this round). You need to enclose the formula string with quotes if it contains spaces or characters interpreted by the operating system.

-Q #

The "query" option is intended for use in scripts that run pMARS in batch mode. Depending on the number code following -Q, the program returns an informative number as the exit status. "pmars -Q 1000" e.g. will cause pMARS to exit with a code that spells out the program version. More on -Q arguments and exit codes can be found in the ADDENDUM.

$

The $ (dollar) parameter is not preceded by a dash and cannot be grouped with other options. It terminates reading command line parameters and is used in parameter files or input streams (-@ fn). The $ is necessary if you want to combine two or more of command line parameters, warrior code and cdb commands in the same input stream or file. Below an example of such a combined input file:

```
    ;Below the command line parameters:

    -r 10 -beF 1000 2- $

    ;redcode

    ;name Imp 1

    ;assert 1

    mov 0,1

    end

    ;redcode

    ;name Imp 2

    ;assert 1

    mov 0,2

    mov 0,2

    end

    !! cdb commands follow:

    sk 1000

    reg

    quit

```

## X-WINDOWS OPTIONS
The X-Windows display version of pMARS has these additional command line options:

-display <string>

Expects a string specifying the display where the window should appear. Following X standards, this display specification has a format of hostname.domain:display.screen where the part before the colon is the standard internet host specification and display and screen are integers. The screen specification can be omitted. For an example, consider you are working at an X terminal named ncd13.complang.tuwien.ac.at and remotely logged in at host stud1.tuwien.ac.at where the binary of pmars lies, you can use the following command line

```
  stud1$ pmars -display ncd13.complang.tuwien.ac.at:0 -b aeka.red aeka.red
```

and the window will appear at you local screen. -geometry <string>

Lets you specify the initial size and position of the window. The format is widthxheight+x+y where width, height, x, y are integers and + may be replaced by -. Either of the two parts (widthxheight or +x+y) may be omitted. This overrides the -v switch concerning the window geometry. As an example, pmars -geometry 600x400+30+100 .... will open a window of 600 by 400 pixels at the screen position (30,100). pmars -geometry 1024x768 ... creates a window of 1024x768 pixels and pmars -geometry -20+300 ... creates a window with standard size with its left upper corner at position (-20,300), i.e. out of the left side of the screen.

-fn <string>

The string following this argument specifies the X font to use. By default, a terminal font is used. If this font can't be found, "fixed" is used for a font ("fixed" should be present at every X installation). Use the command 'xlsfonts' to get a listing of fonts that can be used at your X server. 'xfontsel' provides a comfortable way to select a font. "fixed" is the fallback if the specified font can't be found. It is strongly recommended to use a fixed pitch font.

The argument of the -v display option has an additional fourth digit in the X-Windows version: 0 (the default) enables the color display, 1 the grayscale, and 2 the black and white display (e.g. -v 1033 for the grayscale display).

## REDCODE
pMARS implements an extension of the proposed ICWS'94 standard. The new instruction modifiers .A,.B,.AB,.F,.X, and .I, the arithmetic instructions MUL, DIV and MOD, as well as post-increment indirect (>) are supported. pMARS currently does not implement read/write ranges, although they may be added in future versions.

Version 0.5 of pMARS adds support for three experimental opcodes that are currently not included in the ICWS'94 draft:

SEQ (Skip if EQual): this is a synonym for CMP and is included mainly for clarity (future versions of pMARS may implement SEQ as a "predefined EQU" rather than a true opcode).

SNE (Skip if Not Equal): the opposite of SEQ.

NOP (No OPerations): do nothing.

Version 0.6 adds three new indirect addressing modes that use the A-field instead of the B-field as the pointer for indirection:

* - indirect using A-field

{ - predrecement indirect using A-field

} - postincrement indirect using A-field

The new P-space instructions of version 0.8 are discussed under separate heading below.

The assembler also supports multi-line EQU statements, a feature not included in the current ICWS'94 draft. The format for multi-line EQUates is

```
    <label> EQU <line1>

            EQU <line2>

            [...]

            EQU <lineN>
```

<label> in the warrior source is replaced by <line1> <newline> <line2> <newline> [....] lineN. In contrast to KotH, pmars EQUs substitute arbitrary text, and not just expressions. EQU expressions are not implicitly parenthesized. pMARS features the non-standard FOR text-repetition macro. This macro repeats the text between FOR and ROF a specified number of times:

```
<labels> <counter> FOR <times>

                   [..]

                   ROF
```

<times> is an expression specifying the number of expansions; it may contain EQUates and labels as long as they have been defined before the FOR/ROF block. <counter> is the last label before the FOR word, but not necessarily on the same line. It is expanded to 01, 02, .., <times> in each repetition. The optional <labels> label the first instruction after FOR expansion. An example:

```
        ORG start
start
sp      FOR 2
a&sp        SPL a&sp

            JMP a&sp

        ROF
becomes after expansion
start
a01     SPL a01

        JMP a01
a02     SPL a02

        JMP a02
```

The symbol & concatenates 'a' and 01, 02 to form a valid label. EQU expansion and FOR/ROF processing is done in the same pass. It is therefore possible to write

```
dest01  EQU 500
dest02  EQU 1000
dest03  EQU 1500
idx     FOR 3

            MOV src,dest&idx

            MOV src+1,dest&idx

        ROF
src     MOV <-1,<-1

        JMP src,<-2
```

Using predefined EQUates (see below) it is possible to define adaptive FOR/ROF blocks. The next example fills the remainder of the warrior (up to MAXLENGTH lines) with decoy instructions:

```
    FOR MAXLENGTH-CURLINE

        DAT 1,1

    ROF
```

Since true logical expressions have a value of "1" and false expressions a value of "0", you can write conditionally assembled code enclosed by FOR/ROF:

```
    FOR CORESIZE == 8000

    <some code>

    ROF

    FOR CORESIZE != 8000

    <other code>

    ROF
```

pMARS uses KotH-style ;name and ;author comments to describe warriors. If a line starting with ;redcode is present, all text preceding it is ignored. This makes it possible to run posted warriors without removing mail headers and descriptive text. The ;version, ;strategy and other comments mentioned in the ICWS'94 draft are currently not used. As another "non-standard" extension, the assembler predefines the following run-time variables: CORESIZE, MAXPROCESSES, MAXCYCLES, MAXLENGTH, MINDISTANCE, ROUNDS, and PSPACESIZE. They can be used in your Redcode as though they were defined by EQUs like

```
    CORESIZE     EQU 55440  ;current value of -s parameter

    MAXPROCESSES EQU 10000  ;current value of -p parameter

    [etc.]
```

The run-time variable CURLINE holds the current instruction number offset from the first instruction. WARRIORS is initialized with the number of warriors specified on the command line. pMARS supports the ;assert directive as a way of checking whether a warrior is run under the parameters it was designed for. If the expression following ;assert evaluates to "0" (false), assembly is aborted with an error message. If an ;assert is missing, a warning is issued. Examples:

```
    ;assert CORESIZE == 55440 && MAXLENGTH >= 200

    ;assert !(CORESIZE % 4)  ; is multiple of 4

    ;assert 1 ; if warrior works under all settings
```

The run-time variable VERSION holds the current pMARS version (e.g. "60" is v0.6.0) and is useful in ;assert expressions. With the -8 option, pMARS is fully ICWS'88 compatible, except that a comma is required between operands. Extensions like predefined and multi-line EQUs and FOR/ROF are supported even in ICWS'88 mode.

A full treatment of corewar and ICWS'94 in particular is beyond the scope of this document. General information about corewar as well as the ICWS'94 draft is available by anonymous FTP from soda.berkeley.edu in pub/corewar.

## P-SPACE
Originating from discussions on rec.games.corewar, P-space is an attempt at making warriors more "intelligent" by giving them a memory. P-space, short for "private", "permanent" or "priviledged" space is a memory area separate from core whose contents is not cleared between rounds. Every warrior has its own P-space for gathering information about the opposing warrior, but there is a provision for sharing P-space in team play (see below).

P-space cells contain values in the range 0..CORESIZE-1. The number of P-space cells can be adjusted with the -S command line option; by default, P-space size is 1/16th of CORESIZE. This number is available to warriors as the predefined variable PSPACESIZE. pMARS updates P-space cell 0 at the beginning of each round with the result of the previous round: 0 signifies a loss in the previous round, a number larger than zero means that the warrior survived until the end of the round, the value indicating the number of surviving warriors. That is, a value of "1" means that the warrior survived by itself (a "win" in a two-warrior battle), a value of "2" that two warriors lasted until the end (a "tie" in a two warrior battle), etc.. In the first round, P-cell 0 is set to -1 (actually CORESIZE-1) to indicate that there is no previous result.

There are two new instructions for accessing P-space:

LDP

(Load P-space) loads P-space cell specified by A-value into core at B-address.

STP

(Store P-space) stores A-value into P-space cell specified by B-value.

It is important to note that P-space cells are refered to by A/B-values as opposed to A/B-addresses. As an example, "STP #9,#1" stores number 9 in P-cell 1.

Since all P-space access is only via these two instructions, it takes too much time and space to use P-space for working variables where they would be safe from the opposing warrior. P-space was made deliberately hard to access, unlike a set of general purpose registers.

P-space can also be used for communication between warriors belonging to a team in multi-warrior core war. To allow communication, P-space has to be declared as "shared". You do this by including the PIN pseudo-opcode in your source:

PIN

(P-space Identification Number) has a single numerical argument. If two or more participating warriors have the same PIN argument, they share the same P-space. If the PIN pseudo-opcode is missing from a warrior's source, its P-space is strictly private. The PIN argument is not normalized to [0..CORESIZE-1] before comparison. "PIN 0" and "PIN CORESIZE" are therefore not the same.

P-cell #0 holding the result of the last round is exempt from sharing, i.e. every warrior has its own last round cell even though the rest of its P-space may be shared.

## CDB DEBUGGER
Cdb is a line-oriented debugger. It is invoked either by specifying the -e option (enter cdb immediately), by including debugging commands in the warrior source, or by hitting Ctrl-C during the simulation. The debugger is also entered whenever a warrior terminates ("post-mortem") if execution was started with the go command. cdb is very powerful and has an overwhelming number of commands. You may want to start with only the most often used commands: step (single step execution), go (execute until breakpoint), list (look at core), trace and untrace (set and remove breakpoints), and go on to more complex ones later.

The following commands are available at the cdb prompt; commands can be abbreviated to the first unambiguous substring.

<Enter>

repeats the last command issued at the cdb prompt.

help

displays a brief command summary.

progress

displays the status of the current game in progress.

registers

displays the current state of the simulator, including program counters and task queues.

go

runs the simulator until an instruction whose trace bit is set is executed. If there are no traced instructions go returns to the post-mortem debugger.

step

executes the next instruction in the task queue and returns to the cdb prompt.

continue

returns to the simulator to complete the game without interruptions.

thread

is similar to step except that only the current task thread is traced.

skip [count]

executes the next [count] instructions in the queue silently before returning to the cdb prompt.

execute [address]

resets the task queue of the current warrior to [address] and executes it. This is useful in conjunction with edit.

quit

aborts pMARS and returns to the OS prompt.

trace [range]

sets the trace bit of the specified address or address range.

untrace [range]

clears the trace bit of the specified address or address range.

moveable on|off

specifies whether the trace bit is copied by the MOV.I instruction. The default is on.

list [range]

displays the specified range of core addresses, a set trace bit is indicated by 'T'. Unmodified addresses (DAT.F 0,0) are shown as blank.

edit [range]

allows modifying core. The specified addresses are edited by typing in new instructions. Typing one or more spaces leaves the core address unchanged, just hitting <return> repeats the last input, and a syntax error aborts the edit. The full Redcode syntax including labels and (multi-line) EQUates can be used. Label and EQUate definitions remain in effect until the program terminates. The edit command is useful for modifying warriors and trying out single instructions without having to exit and restart pMARS.

fill [range]

is similar to edit. Instructions in the specified range are replaced by one typed in instruction. Entering DAT.F 0,0 ,e.g. clears the address range.

search [pattern]

searches core instructions for a text pattern in the forward direction. The next instruction matching [pattern] is displayed. The search includes the address number and trace symbol (T), is case- and space-insensitive and may contain wildcards: * (asteriks) matches any number of characters; ? (question mark) matches exactly one character. E.g. "search ," searches for the next non-blank address; "search dat*, ?0t" searches for the next DAT instruction that is traced and has a zero B-operand value, regardless of modifier, A-operand and B-mode.

write [file]

opens a file for logging subsequent cdb output to. The logfile is closed by issuing write without an argument.

echo [string]

is used mostly inside macros. [string] is echoed to the screen followed by <newline>.

remark [string]

is ignored by cdb and can therefore be used to comment macros.

cls

clears the screen. The no-display UNIX version does this by echoing an ANSI escape sequence; if this doesn't work for you, you need to change the CLRSCR string in config.h and recompile. clear is a synonym for cls .

display clear|on|off|nnn

(available in display versions only) allows clearing the core display (display clear) or changing the display mode. display on changes the display to the default mode, display off (same as display 0 ) suspends all display updates, and display nnn , where nnn is a 1 to 3-digit number, sets the display to this mode. "nnn" is interpreted like the parameter to the -v command line option (see APPENDIX).

switch [1|2]

(available in display versions only) makes the left (1) or right (2) panel the current panel for cdb output. Without a number argument switch changes to the other panel. If the right panel doesn't exist (initially, or after close, see below), it is created first.

close

(available in display versions only) closes the right cdb panel (if it exists) and makes the left panel fullscreen.

calc expr1[,expr2]

is a command line calculator. Since calc has no side-effects other than echoing the result of expression 1 (and expression 2 if provided). In the context of cdb macros it is also used to assign values to the register variables 'c' through 'z'.

macro [name][,file]

loads, executes or lists macros. A macro expands to one line of cdb commands separated by the tilde character (~) (a so-called command chain, see below). The command macro name executes the macro "name"; if "name" is left out, all currently available macros are listed. macro name,file loads macro definitions from file "file" and executes macro "name"; again, if "name" is missing, only a listing is produced. Macro definitions are appended to the list of previously loaded definitions or replace a previously loaded macro definition with the same name. If you are trying to execute or list macros, but no macros have been loaded yet, the default macro file "pmars.mac" is loaded automatically. The special macro file "user" can be specified to input macro definitions directly from the keyboard. Macro definitions consist of a macro name, followed by the equal sign, followed by a command (chain). The macro name can consist of any printable character excluding <space> and comma; the equal sign is only allowed at the end of a macro name. Individual macro lines have a limit of 80 characters, but macro calls inside macro expansions are allowed. Cdb can hold up to 200 macros in memory. See also the section on cdb macro programming below.

if <expression>

controls execution of commands in macros or command chains. If <expression> evaluates to zero, the next command block is skipped. A command block consists of either a single command or any number of commands bracketed by !! (loop start) and ![e] (loop end, see section on macro programming below). <expression> may contain C-style comparison and boolean operators (see below). An if immediately preceeding a loop end (![e]) can skip out of the loop.

reset

is used inside macros in conjunction with if to terminate macro execution, e.g. inside an infinite loop (...~if A==0~reset~...~!).

pqueue [1|2|..|off]

switches cdb into "process queue mode". In this mode, list, edit and fill operate on the process queue instead of the core array, i.e. you can view and modify the process queue as easily as the core array. This is especially useful for debugging complicated multi-process warriors. pqueue without argument uses the process queue of the current warrior. With argument 1,2,.., uses the process queue of warrior 1,2,.., respectively. pqueue off returns to normal mode.

wqueue [off]

stands for "warrior queue" and is similar to pqueue, except that numbers provided as arguments for list, edit and fill now refer to warriors: "list 0" now shows the program counter of warrior 1, "list 1" that of warrior 2 and so on. wqueue off returns to normal "address mode".

pspace [1|2|..|off]

complements the pqueue and wqueue commands. If a number is specified, the P-space of that warrior is selected for viewing/editing. Without an argument, the P-space of the currently executing warrior is selected. "pspace off" returns to core mode.

go, step, continue and thread may have a single address argument. The program counter of the current warrior is set to this address before execution continues.

The range argument of the list, trace, etc. commands has the format <start>,<stop>. Addresses <start> and <stop> are numbers, special symbols or C-style expressions including special symbols. If either <start> or <stop> is omitted, it defaults to the current address. If both are omitted, the range of the last cdb command is used. A single address (without the comma) acts on only that address. Addresses starting with a + or - are interpreted relative to the current address.

Expressions may contain the arithmetic operators -,+,*,/,% (modulo), the comparison operators ==, !=, <=, >=, and the boolean operators && (AND), || (OR), and ! (negation). Expressions may also include register variables C through Z and the assignment operator =. Operator precedence is like that of the C-language and may be overridden by parentheses. Assignment, comparison and boolean operations are mostly used with calc and if commands in macros, but can also be used in Redcode operands.

Special address symbols used in cdb commands:

```
 .     (dot) is the current address (displayed last).

 $     (dollar) is the last core address.

 A     is the A value of the current instruction.

 B     is the B value of the current instruction.

 PC    is the program counter of the currently executing warrior.

 PC1   is the program counter of warrior 1.

 PC2   is the program counter of warrior 2.

 LINES is the number of lines available to the cdb display

 CYCLE is the current execution cycle (counted down)
```

In process queue (pq), warrior queue (wq) or pspace (ps) mode (see pqueue, wqueue, pspace), most of these symbols have a different meaning:

```
 .     (dot) is the current process number (pq),

       warrior (wq), or P-space cell (ps) which was displayed last.

 $     (dollar) is the last process in the process queue (pq),

       the last warrior (wq), or the last P-space cell (ps).

 A     is the A value of the instruction of the current process (pq),

       the next executing process of the current warrior (wq), or

       the P-space selector (ps, same as warrior number if unshared).

 B     is the B value of the instruction of the current process (pq),

       the next executing process of the current warrior (wq), or

       the P-space selector (ps).

 PC    is 0.

 PC1.. are 0
```

Preceding a command with the character '@' (ampersand) will suppress its screen output, but not output to a logfile. Preceding a command with '&' will suppress both screen and logfile output, which is useful if you are only interested in the "side-effects" of a command. Starting a command with a <Space> character suppresses saving it to the "last-command" buffer that is recalled by <Enter>.

## COMMAND CHAINS AND MACRO PROGRAMMING
Several commands can be issued on one line when separated by the tilde character ( ). These "command chains" are useful for repeating long command sequences, since <Enter> recalls the entire chain (see the examples below). Commands requiring user intervaention (list, edit, fill) also read their input from the chain.

The "empty command" (two consecutive tildes or a tilde at the end of the chain) repeats the last command in the chain. A command consisting of <Space> is a null command and is used to simulate pressing <Enter> in list, edit and fill.

The exclamation mark (!) character is a special "chain repetitor" command. The optional expression following '!' specifies how many times the command chain starting at the beginning of the line or the last ´!' is executed. '!' without an expression repeats until the program terminates.

The symbol '!!' is used for nested loops and marks the start of a command block to be repeated. The command block is closed by '![expression]' and may contain other command blocks. A command block immediately following an if command is executed only if the condition is true.

With loops, subroutines (macros calling macros), variables (C..Z), expressions involving comparisons and boolean operations, and conditional execution (if), the cdb command language can be used to construct complicated macros for e.g. executing a warrior until a certain core address has changed, controlling the 2-panel display, automatically finding the right constants for a warrior, etc. See the file "pmars.mac" for examples.

## EXAMPLE CDB COMMANDS
list ,+20

lists the next 20 instructions.

trace pc-10,pc+10

traces 21 addresses centered around the program counter of the currently executing warrior.

untrace 0,$

clears all trace bits.

go reg l+a,+b

chains these commands: execute until the next traced address or end of round, display the simulator status and list addresses in the range A-number to B-number of the current instruction.

@fill0,100 dat.f 0,0

fills addresses 0 through 100 with 'dat.f 0,0', not echoing the changed addresses to the screen.

write trace.log step !

produces a continuous execution trace by repeating step until pMARS terminates, saving the output to logfile "trace.log".

@l x=5 !! @ed x~dat x,0 if (x=x+1)<$+1 !

This command chain could be useful for debugging a stone-type, self-modifying warrior, which is assumed to occupy address 0 through 4 in this example. The command fills core starting at address 5 with "dat 5,0", "dat 6,0", a.s.o., so that you can tell where a bomb which overwrites the warrior came from. To save some typing, you can turn this command into a macro (foo=@l x=5~..). This is how it works, step by step: Assign 5 to register x and make it the current address (@l x=5). Start a loop (!!) and change address x to "dat x,0" (@ed x~dat x,0). Increment x, if x is then smaller than the core size ($+1), continue looping (if (x=x+1)<$+1~!). The '@' in front of the list and edit commands suppresses screen output.

@s @4 if b<2 || b>=$-3 reset !

This command executes a warrior until the B-field of address 4 points to address 0 through 5: Step and make address 4 the current address (@s~@4). If the B-field is less than 2 or greater than or equal to 7996 (CORESIZE-1-3) stop execution, else continue looping (if b<2 || b>=$-3~reset~!).

## SOURCE DEBUGGING DIRECTIVES
Trace bits can also be set by including debugging commands in the warrior source. A comment format is used to retain compatibility with simulators that do not support source-embedded debugging commands.

;debug [static/off]

This command enables/disables all subsequent source-embedded commands. It is used for commenting out other source comments. ;debug static has the same effect as the command moveable off at the cdb command prompt. ;debug is implicitly added in front of every warrior. The last ;debug or ;debug static encountered specifies whether the trace bit is copied by a MOV.I instruction or not.

;trace [off]

;trace starts setting the trace bit with the next instruction until EOF or a ;trace off command is encountered.

;break

sets the trace bit of the next instruction.

## FUTURE DIRECTIONS
We will be glad to assist in porting pMARS to other, currently unsupported platforms. This program is still under development and we will continue to enhance functionality and speed, as well as adapt to changes in the proposed ICWS'94 standard. If there is demand, future versions of pMARS will also implement read/write ranges

## BUGS
None whatsoever (right). Contact for bug reports and suggestions is Stefan Strack (stst@vuse.vanderbilt.edu). Please be detailed and include a logfile of the cdb session if applicable. Bug reports and suggestions concerning the Macintosh display and interface should also be directed to Alex MacAulay (macaulay@mundil.cs.mu.oz.au).

## AUTHORS
The portable MARS project was initiated after discussing the ICWS'94 draft on the rec.games.corewar newsgroup. We realized that we needed a portable system to try out the proposed standard and to accept, modify or reject it. The people who started portable MARS and are responsible for the base code as well as the DOS and UNIX displays are:

```
Albert Ma (ama@athena.mit.edu)
Nandor Sieben (nandor.sieben@asu.edu)
Stefan Strack (stst@vuse.vanderbilt.edu)
Mintardjo Wangsaw (wangsawm@csos.orst.edu)
```

Alex MacAulay (macaulay@mundil.cs.mu.oz.au) wrote the Macintosh display version. Martin Maierhofer (m.maierhofer@ieee.org) contributed the linux SVGA and X windows display. Nathan Summers (00ncsummers@bsuvc.bsu.edu) did the port to VMS.

## ACKNOWLEDGMENTS
We thank Planar (Damien.Doligez@inria.fr) for expert help with debugging and porting pMARS to different UNIX machines. We also appreciate the help of Chris Lindensmith (lind0014@student.tc.umn.edu) and Pierre Baillargeon (dak@info.polymtl.ca) with the initial Mac and Amiga ports respectively. Mark Durham (durham@ricevm.rice.edu) spearheaded development of the ICWS'94 draft and we thank him for writing the sample interpreter code included with the draft.

## PMARSV
pMARSv is a DOS version of pMARS with a graphical core display. You can chose between EGA/VGA graphics or text mode with the -v command line options or by pressing 'v' during the game. The -v option takes a three digit argument 'xyz'. Digit 'x' specifies the initial display speed and ranges from 0 (fastest) to 7 (slowest). 'y' is the initial display mode: 0 for text mode, 1 for standard VGA graphics, 2 and 3 for SVGA, 4 and 5 for EGA, and 6 for CGA graphics.

The display level 'z' specifies how much is displayed:

0

Display nothing. This greatly speeds up execution, especially when in graphics mode.

1

Display execution of addresses. In text mode, a black '0' on blue background is shown for warrior 1, a black '1' on green for warrior 2, a.s.o.. Numbers blink in white when a DAT instruction is executed. In graphics mode, a blue square represents warrior 1, a green square warrior 2, a.s.o.. These colors are also used for other core accesses.

2

Also display write accesses. In text mode, they appear as dots; in graphics mode, they appear as two pixels, offset diagonally.

3

Also display decrements and increments. They are shown as '+' and '-' in text mode and as two pixels offset vertically or horizontally in graphics mode.

4

Also display read accesses, which appear as small dots in text mode and as single pixels in graphics mode.

The more is displayed, the slower runs the simulation. The argument for -v defaults to 103, i.e. speed=1, mode=text, level=3.

The text mode display is very fast, but contains less on-screen information than the graphics display. The core display and the cdb debugger run full-screen on separate display pages.

In graphics mode, core and debugger share the same screen. The mouse can be used to navigate around core when debugging is enabled: clicking a mouse button on any core location lists addresses starting there. The mouse cursor follows the current program counter when in single step mode.

In both graphics and text mode, the cdb display can be divided into two side-by-side panels. You can switch between panels with the switch command (or the <Tab> macro) and close the right panel with close (or the <Shft-Tab> macro). Extended (function keys, arrow/page keys, ALT keys, etc.) and control keys generate macro calls at the cdb prompt; some of these "hot key macros" have been defined in "pmars.mac"; you can easily change them or add more with a text editor. E.g. <PgDn> and <PgUp> keys currently invoke macros that scroll through core one screen at a time.

A white line at the top of the display, called the time meter, indicates the time required to finish the current simulation. The amount of time depends on the number of warriors still alive in the arena. After a warrior dies it no longer needs simulation time so the required time to finish the simulation becomes less. On the time meter this is indicated by a discontinuity. One can count the number of dead warriors in the arena by counting the number of discontinuities on the time meter.

Just below, the length of "process meters" in the color of the warriors they represent show how many processes each warrior has running.

The following keys are available at the core display screen:

0..4

selects the display level (see above).

v

switches from text display to graphics display and vice versa.

>

increases the display speed.

<

decreases the display speed. The current speed is indicated by a red bar in graphics mode.

d

enters the cdb debugger. "Debug" on the graphics menu bar is highlighted in red inside cdb.

<space>

(also 'r') refreshes the core display.

<escape>

(also 'q') exits to DOS.

You can define additional keys and commands associated with them by defining "key-x" macros ("x" is any printable character). E.g.:

```
key-p= progress~registers~continue
```

Function-key and other macros can also be invoked from the core display.

## CURSES DISPLAY
The curses display is very similar to the DOS text mode display. There are separate pages for core and debugger. There is a status bar at the bottom of the core display:

```
Rave [0]: 1        Lucky 3 [1]: 3702  Cycle: 72967  R: 2/5 (0 0 1)
```

The display symbol that indicates execution is shown in brackets after the warrior name. The number after the colon shows the number of processes active. The "2/5 (0 0 1)" means that this is round 2 of 5; the result so far is one tie. Only cycle and round information is shown if more than two warriors are run.

There is no "hot key" user interface during the core display, but you can enter the debugger by hitting Ctrl-C and clearing the display, changing the display mode, etc. from within cdb. Only the first and third digit of the -v option and display command argument, namely the display speed and level, have an effect (see PMARSV above). The display speed setting (0=fastest, 7=slowest) adjusts the screen refresh rate; depending on the size of your display, movement in core may appear "jerky" at fast speeds. Control keys at the cdb prompt generate a macro call like in the DOS versions.

If you redirect standard input (by supplying a '-' filename or parameter file), all interactive input is disabled.

## MACINTOSH DISPLAY
MacpMARS is a Macintosh version of pMARS with a graphical core display and standard Macintosh user interface. It has two windows, the Core window and Text window. The display of the core uses four patterns for each warrior (black and white backgrounds respectively) to show what is happening in the core:

´/' when the core location is written to (including incrementing and decrementing);

´\' when a process has died at the core location;

´-' when a process has executed at the core location;

´|' when a process is waiting to execute at the core location.

If you click on a core location in the Core window while a battle is being run, the contents will be displayed in the Text window.

Two warriors can be in memory at any one time. To assemble a warrior choose "Choose Warrior n..." from the File menu. To remove the warrior from memory choose "Remove Warrior n...". You can modify the settings used by choosing "Preferences..." (this can only be done when no battle is being run). Alternatively, you can type in a command line in the same way as if you were typing from a unix prompt (if you're used to that sort of thing) by choosing "Command Line...". The Edit menu is just the normal Macintosh Edit menu and can be used to cut and paste text in the Text window and dialogs. The items in the Play menu are fairly self-explanatory: "Go" starts (or continues) a battle; "Step" executes one instruction and enters the debugger; "Halt" halts the battle and enters the debugger; "Abort" aborts the battle. The Window menu is used to show and bring either of the two windows to the front of the screen.

The cdb commands display, switch and close are not available in MacpMARS.

Note: to use very large core sizes (up to about 65000) and process limits you may need to increase the memory partition for MacpMARS. To do this, choose "Get Info" from the File menu in the Finder and set the preferred memory size to about 1200K.

## EXIT CODES
The following is mainly useful for people who write scripts or batch files for pMARS. Upon normal exit, the program returns 0. Below is a listing of what the abnormal exit codes mean. Your operating system may not support negative exit codes; in this case you have to convert the value to its unsigned counterpart.

```
    -4      graphics error

    -3      trying to execute 80386 code on a lesser processor

    -2      memory allocation error

    -1      serious program logic error, contact developers

     1      file not found

     2      command line error

     3      assembly error

     4      user aborted program
```

The exit codes of the VMS version conform to the VMS standard. The -Q (Query) command line option (see OPTIONS) allows you to customize the pMARS exit code. E.g. "pmars -Q 1000" returns the current pMARS version. Below the -Q arguments and what the resulting exit codes mean. 1..W

exit code is score of this warrior, 1: first in result output, 2: second, a.s.o.. If the -o option is also given, "1" gives the score of the highest scoring warrior, etc..

101..1W

returns the number of this warrior in the result output. Usually -Q 101 returns 1, -Q 102 returns 2 etc., so this is not very useful. If you also specify the "-o" (order results) option, -Q 101 returns the position of the highest scoring warrior on the command line, -Q 110 the position of the 10th highest scoring warrior, etc..

1000

exit code is the pMARS version in the same format as the predefined VERSION variable.

1001

returns the pMARS "variant": 0 if the program was compiled with the SERVER option (no debugger), 1 with debugger but without display, 2 with debugger and core display.

1002

returns a combination of version and variant: 10*variant+version.

1003

the exit code is the core address size in bytes. On a 32-bit CPU, this is sizeof(int), usually 4. With SMALLMEM compilation, core address size is sizeof(unsigned short), usually 2.

2000

returns how many warriors share one or more P-spaces. A value of 4, e.g. means that either four warriors share one P-space, or that two pairs of warriors share two P-spaces.


polymc

package: polymc

title: polymc(6)

text:
# polymc(6)

## NAME
polymc - a launcher and instance manager for Minecraft.

## SYNOPSIS
polymc [OPTIONS...]

## DESCRIPTION
PolyMC is a custom launcher for Minecraft that allows you to easily manage multiple installations of Minecraft at once. It also allows you to easily install and remove mods by simply dragging and dropping. Here are the current features of PolyMC.

## OPTIONS
-d, --dir=DIRECTORY

Use DIRECTORY as the PolyMC root.

-l, --launch=INSTANCE_ID

Launch the instance specified by INSTANCE_ID.

--alive

Write a small 'live.check' file after PolyMC starts.

-h, --help

Display help text and exit.

-v, --version

Display program version and exit.

-a, --profile=PROFILE

Use the account specified by PROFILE (only valid in combination with --launch).

## EXIT STATUS
0

Success

1

Failure (syntax or usage error; configuration error; unexpected error).

## BUGS
https://github.com/PolyMC/PolyMC/issues

## RESOURCES
GitHub: https://github.com/PolyMC/PolyMC

Main website: https://polymc.org

## AUTHORS
PolyMC Contributors


prboom

package: prboom

title: prboom(6)

text:
# prboom(6)

## NAME
prboom - PrBoom, a version of Doom for Unix, Linux and Windows systems

## SYNOPSIS
prboom [ -complevel lvl ] [ -width w ] [ -height h ] [ -viewangle n ] [ -vidmode gl ] [ -[no]fullscreen ] [ -[no]window ] [ -iwad iwadname ] [ -file wad1 ... ] [ -deh deh_file ] [ -noload ] [ -loadgame {0,1,2,3,4,5,6,7} ] [ -warp { map | epis level } -skill {1,2,3,4,5} ] [ {-fastdemo,-timedemo,-playdemo} demofile [ -ffmap num ] ] [ -record demofile ] [ -solonet ] [ -net hostname[:port] ] [ -deathmatch [ -altdeath ] ] [ { -timer mins | -avg }] ] [ -nosound ] [ -nosfx ] [ -nomusic] [ -nojoy ] [ -nomouse ] [ -noaccel ] [ -nodraw ] [ -config myconf ] [ -save savedir ] [ -bexout bexdbg ] [ -debugfile debug_file ] [ -devparm ] [ -noblit ] [ -nodrawers ]

## DESCRIPTION
PrBoom is a version of the 3D shoot'em'up Doom, originally by iD software. It is based on Boom, a version of Doom adapted by TeamTNT (http://www.teamtnt.com/) for DOS. PrBoom uses the SDL library, meaning it can run on a variety of different systems, including Windows, X11, Linux/SVGALib.

## Options
-complevel lvl

This sets the compatibility mode that PrBoom runs in. If you need to change this, see README.compat.

## Video Options
-width w

Specifies the width of the PrBoom window, in pixels. Default is 320, the width must be greater than 320..

-height h

Specifies the height of the PrBoom window, in pixels. Default is 200, the height must be greater than 200.

-viewangle n

Causes the player view to be rotated by a given offset (specified in 45degree increments, in the range 0..7) from the way the player is facing.

-vidmode gl

Use the OpenGL video mode. The default is to use the software video mode.

-fullscreen, -nofullscreen

These options toggle fullscreen mode. The default is fullscreen.

-window, -nowindow

This pair of options also toggle fullscreen mode. They only take effect for this prboom session and do not alter your configuration file.

## WAD Options
-iwad iwadname

Specifies the location of the IWAD file, typically doom.wad or doom2.wad (or doom2f.wad). This tells prboom where the main .wad file that came with the version of Doom that you own is.

-file wad1 ...

Specifies a list of PWAD files to load in addition to the IWAD file. PWAD files modify the existing Doom game, by adding levels or new sounds or graphics. PWAD files are widely available for download; try ftp.cdrom.com/pub/idgames for starters.

-deh deh_file

Tells PrBoom to load the dehacked patch deh_file.

## Game Options
-loadgame {0,1,2,3,4,5,6,7}

Instructs PrBoom to load the specified saved game immediately.

-warp { map | epis level }

Tells PrBoom to begin a new game immediately. For Doom 1 or Ultimate Doom, you must specify the episode and level number to begin at (epis is 1 for Knee-Deep in the Dead, 2 for Shores of Hell, 3 for Inferno, 4 for Ultimate Doom; level is between 1 and 9). For Doom ][ or Final Doom, you must specify the map to begin at, which is between 1 and 2 (0 for German Doom ][).

-skill n

Tells PrBoom to begin the game at skill level n (1 for ITYTD, 2 for Not Too Rough, 3 for Hurt Me Plenty, 4 for Ultraviolent, 5 for Nightmare).

-respawn

Tells PrBoom that monsters that die should respawn (come back to life) after a while. Not for the inexperienced.

-fast

Tells PrBoom to make all the monsters move react faster. Not for the inexperienced.

-nomonsters

Tells PrBoom to include no monsters in the game.

## Multiplayer Options
-net hostname[:port]

Specifies that a TCP/IP network game is to be started. hostname is the name of the machine on which the network game server is running (prboom-game-server). For more information about this, see prboom-game-server(6) and the README that came with prboom. port is the port number on the remote machine to which to connect; if not specified, the default of 5030 (which is the default for prboom-game-server(6) ) is assumed. The server will configure your PrBoom settings, so that all the players have the same game settings (skill, map etc).

Also, the server may specify additional PWAD files to play with; if you do not have the required .WAD file, PrBoom will ask the server for a download path, and attempt to use wget(1) and if necessary unzip(1) to download and extract the required WAD.

-port portnum

Specifies the local port to use to communicate with the server in a netgame.

-deathmatch

No longer used. Tells PrBoom to begin a deathmatch game, but this is overridden by the server's settings. Only works for single play (!).

-altdeath

Similar to -deathmatch, but implies a different set of rules for the deathmatch game. No longer used (specified by the server).

-timer mins

No longer used. Specifies that levels will end after mins minutes of play if the level is still being played, but is overridden by the server in a netgame. Not really useful for single play.

-avg

Equivalent to -timer 20

-solo-net

Used to run a single-player network game, without a network game server. This enables network game items & options for an otherwise single-player game; some demos are recorded like this.

## Demo (LMP) Options
-record demofile

Instructs PrBoom to begin recording a demo, to be stored in demofile.lmp. You should specify game options to specify which level and skill to record at.

-playdemo demofile

Play the recorded demo demofile.lmp

-timedemo demofile

Play the recorded demo demofile.lmp, reporting information about the length of the demo (in gametics) afterwards.

-fastdemo demofile

Play the recorded demo demofile.lmp as fast as possible. Useful for benchmarking PrBoom, as compared to other versions of Doom.

-ffmap num

Fast forward the demo (play at max speed) until reaching map num (note that this takes just a number, not a map name, so so -ffmap 7 to go fast until MAP07 or ExM7).

## I/O Options
-nosound

Disables all sound effects and in-game music. This prevents the sound server loading, which lets the game run a little faster.

-nosfx

Disables sound effects during the game. This does not stop the sound server loading, however, so for best performance use -nosound.

-nomusic

Disables playing of music in the game.

-nojoy

Disables joystick support.

-nomouse

Prevents the mouse being grabbed by the prboom window.

-noaccel

For prboom, this prevents it using the MITShm server extension for passing the screen data to the X server. This option may be required if the X server is not local. For lsdoom, this tells lsdoom not to use the accelerated graphics functions that SVGALib provides even when they are supported for your video card (normally this is autodetected).

-1, -2, -3

Specifies the scale factor by which to enlarge the window. The default, -1, displays the normal 320x200 pixel Doom screen (or whatever size is specified by the -width and -height parameters or in the config file for prboom). If this window is too small, try using -2 or -3 to enlarge the window. -nodraw Suppress all graphical display. Only for debugging & demo testing.

## Configuration
-config myconf

Loads an alternative configuration file, named myconf. The default is boom.cfg(5), taken from the same directory as PrBoom was run from, except when running with OpenGL, then the default is glboom.cfg(5).

-save savedir

Causes prboom to save games in the directory specified by savedir instead of ~/.prboom/.

## Debugging/Profiling Options
-devparm

Development mode. Mostly redundant these days, but it does force non-lazy generation of texture lookups which can be useful for level authors debugging PWADs.

-debugfile debug_file

Causes some debugging information, mainly network info I believe, to be written to the named file as prboom runs.

-nodrawers

Causes no rendering to be done. The only conceivable use of this is (a) a multiplayer server (b) to test the speed of the other routines in the program, when combined with -timedemo.

-noblit

Causes no copying to the screen from the rendering buffer to be performed. The only conceivable use of this is (a) a multiplayer server (b) to test the speed of the other routines in the program, when combined with -timedemo.

-bexout bexdbg

Causes diagnostics related to bex and dehacked file processing to be written to the names file.

## More Information
wget(1), unzip(1), boom.cfg(5), prboom-game-server(6)

For more information, see the README that came with PrBoom, the Boom documentation, and your original Doom documentation.

Doom is a registered trademark of id software (http://www.idsoftware.com/).

## Author
See the file AUTHORS included with the PrBoom distribution.


prboom-game-server

title: prboom-game-server(6)

summary: Server for network games of PrBoom.

text:
# prboom-game-server(6)

## NAME
prboom-game-server - Server for network games of PrBoom.

## SYNOPSIS
prboom-game-server [ -adfnrv ] [ -e epis ] [ -l level ] [ -t ticdup ] [ -x xtics ] [ -p port ] [ -s skill ] [ -N players ] [ -c conffilename ] [ -w wadname[,dl_url ]]

## DESCRIPTION
PrBoom is a version of the 3D shoot'em'up Doom, originally by id software. It includes, amongst other things, the ability to play with several players connected by a tcp/ip network. prboom-game-server is the `server', that is the program that passes data between the different players in the game.

To start a network game (often abbreviated to `netgame'), first the server is started. prboom-game-server accepts various parameters to control the type of game (the skill level, number of players, level to play, optional WAD file(s) to load, etc).

Then each player that wishes to participate runs prboom -net hostname, where hostname is the name of the machine on which the server is running. Each copy of prboom retrieves information about the game from the server, and when the specified number of players have joined, the game begins.

## Options
-N players

Specifies the number of players in the game (default 2). The server will wait for this many players to join before starting the game.

-e epis

The episode to play (default 1). Unless you are playing Doom 1 or Ultimate Doom, and wish to play one of the later episodes, you do not need to change this.

-l level

The level to play (default 1).

-s skill

Specify the skill level to play (1-5).

-d

Set game mode to (old) deathmatch (default is cooperative). See the original Doom docs for information about the different network game modes.

-a

Set game mode to `altdeath' (v2 deathmatch) (default is cooperative). See the original Doom docs for information about the different network game modes.

-f

Select fast mode (monsters move faster).

-n

Selects nomonsters mode, i.e. there are no monsters in the game.

-r

Respawn mode. If you don't know what this is, you don't want to ;-).

-c conffilename

Specifies a configuration file to read which sets parameters for the game. This is in the same format as the PrBoom configuration file (in fact, you can ask it to read your normal PrBoom configuration file if you want). Only certain settings are acknowledged: default_skill, default_compatibility_level, the compatibility options and some of the game settings (use -v to have the server print the options as it recognises them).

-w wadname[,dl_url]

Specifies a WAD file to play. This is added to the internal list that the server keeps. When a client connects, the server sends the list of WADs; PrBoom will then add this to the list of WADs specified on its command line. Optionally, an url to the file can be given too; if when PrBoom connects it cannot find the named WAD, it will attempt to retrieve the file from the given url, extracting it if necessary. See prboom(1) for information about the supported url types and compression formats.

-t ticdup

Reserved.

-x xtics

This causes extra information to be sent with each network packet; this will help on networks with high packet loss, but will use more bandwidth.

-p port

Tells prboom-game-server what port number to communicate via (default 5030). Note that if you change this from the default, then all the clients will also need to specify this number when they try to connect (the default programmed into prboom is also 5030).

-v

Increases verbosity level; causes more diagnostics to be printed, the more times -v is specified.

## More Information
prboom(6), boom.cfg(5)

For more information, see the README that came with PrBoom.

Doom is a registered trademark of id software (http://www.idsoftware.com/).

## Author
See the file AUTHORS included with the PrBoom distribution. This man page was written by Colin Phipps (cph@moria.org.uk).


prboom-plus

package: prboom-plus

title: prboom-plus(6)

text:
# prboom-plus(6)

## NAME
prboom - PrBoom, a version of Doom for Unix, Linux and Windows systems

## SYNOPSIS
prboom [ -complevel lvl ] [ -width w ] [ -height h ] [ -viewangle n ] [ -vidmode gl ] [ -[no]fullscreen ] [ -[no]window ] [ -iwad iwadname ] [ -file wad1 ... ] [ -deh deh_file ] [ -noload ] [ -loadgame {0,1,2,3,4,5,6,7} ] [ -warp { map | epis level } -skill {1,2,3,4,5} ] [ {-fastdemo,-timedemo,-playdemo} demofile [ -ffmap num ] ] [ -record demofile ] [ -solonet ] [ -net hostname[:port] ] [ -deathmatch [ -altdeath ] ] [ { -timer mins | -avg }] ] [ -nosound ] [ -nosfx ] [ -nomusic] [ -nojoy ] [ -nomouse ] [ -noaccel ] [ -nodraw ] [ -config myconf ] [ -save savedir ] [ -bexout bexdbg ] [ -debugfile debug_file ] [ -devparm ] [ -noblit ] [ -nodrawers ]

## DESCRIPTION
PrBoom is a version of the 3D shoot'em'up Doom, originally by iD software. It is based on Boom, a version of Doom adapted by TeamTNT (http://www.teamtnt.com/) for DOS. PrBoom uses the SDL library, meaning it can run on a variety of different systems, including Windows, X11, Linux/SVGALib.

## Options
-complevel lvl

This sets the compatibility mode that PrBoom runs in. If you need to change this, see README.compat.

## Video Options
-width w

Specifies the width of the PrBoom window, in pixels. Default is 320, the width must be greater than 320..

-height h

Specifies the height of the PrBoom window, in pixels. Default is 200, the height must be greater than 200.

-viewangle n

Causes the player view to be rotated by a given offset (specified in 45degree increments, in the range 0..7) from the way the player is facing.

-vidmode gl

Use the OpenGL video mode. The default is to use the software video mode.

-fullscreen, -nofullscreen

These options toggle fullscreen mode. The default is fullscreen.

-window, -nowindow

This pair of options also toggle fullscreen mode. They only take effect for this prboom session and do not alter your configuration file.

## WAD Options
-iwad iwadname

Specifies the location of the IWAD file, typically doom.wad or doom2.wad (or doom2f.wad). This tells prboom where the main .wad file that came with the version of Doom that you own is.

-file wad1 ...

Specifies a list of PWAD files to load in addition to the IWAD file. PWAD files modify the existing Doom game, by adding levels or new sounds or graphics. PWAD files are widely available for download; try ftp.cdrom.com/pub/idgames for starters.

-deh deh_file

Tells PrBoom to load the dehacked patch deh_file.

## Game Options
-loadgame {0,1,2,3,4,5,6,7}

Instructs PrBoom to load the specified saved game immediately.

-warp { map | epis level }

Tells PrBoom to begin a new game immediately. For Doom 1 or Ultimate Doom, you must specify the episode and level number to begin at (epis is 1 for Knee-Deep in the Dead, 2 for Shores of Hell, 3 for Inferno, 4 for Ultimate Doom; level is between 1 and 9). For Doom ][ or Final Doom, you must specify the map to begin at, which is between 1 and 2 (0 for German Doom ][).

-skill n

Tells PrBoom to begin the game at skill level n (1 for ITYTD, 2 for Not Too Rough, 3 for Hurt Me Plenty, 4 for Ultraviolent, 5 for Nightmare).

-respawn

Tells PrBoom that monsters that die should respawn (come back to life) after a while. Not for the inexperienced.

-fast

Tells PrBoom to make all the monsters move react faster. Not for the inexperienced.

-nomonsters

Tells PrBoom to include no monsters in the game.

## Multiplayer Options
-net hostname[:port]

Specifies that a TCP/IP network game is to be started. hostname is the name of the machine on which the network game server is running (prboom-game-server). For more information about this, see prboom-game-server(6) and the README that came with prboom. port is the port number on the remote machine to which to connect; if not specified, the default of 5030 (which is the default for prboom-game-server(6) ) is assumed. The server will configure your PrBoom settings, so that all the players have the same game settings (skill, map etc).

Also, the server may specify additional PWAD files to play with; if you do not have the required .WAD file, PrBoom will ask the server for a download path, and attempt to use wget(1) and if necessary unzip(1) to download and extract the required WAD.

-port portnum

Specifies the local port to use to communicate with the server in a netgame.

-deathmatch

No longer used. Tells PrBoom to begin a deathmatch game, but this is overridden by the server's settings. Only works for single play (!).

-altdeath

Similar to -deathmatch, but implies a different set of rules for the deathmatch game. No longer used (specified by the server).

-timer mins

No longer used. Specifies that levels will end after mins minutes of play if the level is still being played, but is overridden by the server in a netgame. Not really useful for single play.

-avg

Equivalent to -timer 20

-solo-net

Used to run a single-player network game, without a network game server. This enables network game items & options for an otherwise single-player game; some demos are recorded like this.

## Demo (LMP) Options
-record demofile

Instructs PrBoom to begin recording a demo, to be stored in demofile.lmp. You should specify game options to specify which level and skill to record at.

-playdemo demofile

Play the recorded demo demofile.lmp

-timedemo demofile

Play the recorded demo demofile.lmp, reporting information about the length of the demo (in gametics) afterwards.

-fastdemo demofile

Play the recorded demo demofile.lmp as fast as possible. Useful for benchmarking PrBoom, as compared to other versions of Doom.

-ffmap num

Fast forward the demo (play at max speed) until reaching map num (note that this takes just a number, not a map name, so so -ffmap 7 to go fast until MAP07 or ExM7).

## I/O Options
-nosound

Disables all sound effects and in-game music. This prevents the sound server loading, which lets the game run a little faster.

-nosfx

Disables sound effects during the game. This does not stop the sound server loading, however, so for best performance use -nosound.

-nomusic

Disables playing of music in the game.

-nojoy

Disables joystick support.

-nomouse

Prevents the mouse being grabbed by the prboom window.

-noaccel

For prboom, this prevents it using the MITShm server extension for passing the screen data to the X server. This option may be required if the X server is not local. For lsdoom, this tells lsdoom not to use the accelerated graphics functions that SVGALib provides even when they are supported for your video card (normally this is autodetected).

-1, -2, -3

Specifies the scale factor by which to enlarge the window. The default, -1, displays the normal 320x200 pixel Doom screen (or whatever size is specified by the -width and -height parameters or in the config file for prboom). If this window is too small, try using -2 or -3 to enlarge the window. -nodraw Suppress all graphical display. Only for debugging & demo testing.

## Configuration
-config myconf

Loads an alternative configuration file, named myconf. The default is boom.cfg(5), taken from the same directory as PrBoom was run from, except when running with OpenGL, then the default is glboom.cfg(5).

-save savedir

Causes prboom to save games in the directory specified by savedir instead of ~/.prboom/.

## Debugging/Profiling Options
-devparm

Development mode. Mostly redundant these days, but it does force non-lazy generation of texture lookups which can be useful for level authors debugging PWADs.

-debugfile debug_file

Causes some debugging information, mainly network info I believe, to be written to the named file as prboom runs.

-nodrawers

Causes no rendering to be done. The only conceivable use of this is (a) a multiplayer server (b) to test the speed of the other routines in the program, when combined with -timedemo.

-noblit

Causes no copying to the screen from the rendering buffer to be performed. The only conceivable use of this is (a) a multiplayer server (b) to test the speed of the other routines in the program, when combined with -timedemo.

-bexout bexdbg

Causes diagnostics related to bex and dehacked file processing to be written to the names file.

## More Information
wget(1), unzip(1), boom.cfg(5), prboom-game-server(6)

For more information, see the README that came with PrBoom, the Boom documentation, and your original Doom documentation.

Doom is a registered trademark of id software (http://www.idsoftware.com/).

## Author
See the file AUTHORS included with the PrBoom distribution.


prboom-plus-game-server

title: prboom-plus-game-server(6)

summary: Server for network games of PrBoom.

text:
# prboom-plus-game-server(6)

## NAME
prboom-game-server - Server for network games of PrBoom.

## SYNOPSIS
prboom-game-server [ -adfnrv ] [ -e epis ] [ -l level ] [ -t ticdup ] [ -x xtics ] [ -p port ] [ -s skill ] [ -N players ] [ -c conffilename ] [ -w wadname[,dl_url ]]

## DESCRIPTION
PrBoom is a version of the 3D shoot'em'up Doom, originally by id software. It includes, amongst other things, the ability to play with several players connected by a tcp/ip network. prboom-game-server is the `server', that is the program that passes data between the different players in the game.

To start a network game (often abbreviated to `netgame'), first the server is started. prboom-game-server accepts various parameters to control the type of game (the skill level, number of players, level to play, optional WAD file(s) to load, etc).

Then each player that wishes to participate runs prboom -net hostname, where hostname is the name of the machine on which the server is running. Each copy of prboom retrieves information about the game from the server, and when the specified number of players have joined, the game begins.

## Options
-N players

Specifies the number of players in the game (default 2). The server will wait for this many players to join before starting the game.

-e epis

The episode to play (default 1). Unless you are playing Doom 1 or Ultimate Doom, and wish to play one of the later episodes, you do not need to change this.

-l level

The level to play (default 1).

-s skill

Specify the skill level to play (1-5).

-d

Set game mode to (old) deathmatch (default is cooperative). See the original Doom docs for information about the different network game modes.

-a

Set game mode to `altdeath' (v2 deathmatch) (default is cooperative). See the original Doom docs for information about the different network game modes.

-f

Select fast mode (monsters move faster).

-n

Selects nomonsters mode, i.e. there are no monsters in the game.

-r

Respawn mode. If you don't know what this is, you don't want to ;-).

-c conffilename

Specifies a configuration file to read which sets parameters for the game. This is in the same format as the PrBoom configuration file (in fact, you can ask it to read your normal PrBoom configuration file if you want). Only certain settings are acknowledged: default_skill, default_compatibility_level, the compatibility options and some of the game settings (use -v to have the server print the options as it recognises them).

-w wadname[,dl_url]

Specifies a WAD file to play. This is added to the internal list that the server keeps. When a client connects, the server sends the list of WADs; PrBoom will then add this to the list of WADs specified on its command line. Optionally, an url to the file can be given too; if when PrBoom connects it cannot find the named WAD, it will attempt to retrieve the file from the given url, extracting it if necessary. See prboom(1) for information about the supported url types and compression formats.

-t ticdup

Reserved.

-x xtics

This causes extra information to be sent with each network packet; this will help on networks with high packet loss, but will use more bandwidth.

-p port

Tells prboom-game-server what port number to communicate via (default 5030). Note that if you change this from the default, then all the clients will also need to specify this number when they try to connect (the default programmed into prboom is also 5030).

-v

Increases verbosity level; causes more diagnostics to be printed, the more times -v is specified.

## More Information
prboom(6), boom.cfg(5)

For more information, see the README that came with PrBoom.

Doom is a registered trademark of id software (http://www.idsoftware.com/).

## Author
See the file AUTHORS included with the PrBoom distribution. This man page was written by Colin Phipps (cph@moria.org.uk).


prismlauncher

package: prismlauncher

title: prismlauncher(6)

text:
# prismlauncher(6)

## NAME
prismlauncher - a launcher and instance manager for Minecraft.

## SYNOPSIS
prismlauncher [OPTIONS...]

## DESCRIPTION
Prism Launcher is a custom launcher for Minecraft that allows you to easily manage multiple installations of Minecraft at once. It also allows you to easily install and remove mods by simply dragging and dropping. Here are the current features of Prism Launcher.

## OPTIONS
-d, --dir=DIRECTORY

Use DIRECTORY as the Prism Launcher root.

-l, --launch=INSTANCE_ID

Launch the instance specified by INSTANCE_ID.

--show=INSTANCE_ID

Show the configuration window of the instance specified by INSTANCE_ID.

--alive

Write a small 'live.check' file after Prism Launcher starts.

-h, --help

Display help text and exit.

-v, --version

Display program version and exit.

-a, --profile=PROFILE

Use the account specified by PROFILE (only valid in combination with --launch).

## ENVIRONMENT
The behavior of the launcher can be customized by the following environment variables, besides other common Qt variables:

QT_LOGGING_RULES

Specifies which logging categories are shown in the logs. One can enable/disable multiple categories by separating them with a semicolon (;). The specific syntax, and alternatives to this setting, can be found at https://doc.qt.io/qt-6/qloggingcategory.html#configuring-categories.

QT_MESSAGE_PATTERN

Specifies the format in which the console output will be shown. Available options, as well as syntax, can be viewed at https://doc.qt.io/qt-6/qtglobal.html#qSetMessagePattern.

## EXIT STATUS
0

Success

1

Failure (syntax or usage error; configuration error; unexpected error).

## BUGS
https://github.com/PrismLauncher/PrismLauncher/issues

## RESOURCES
GitHub: https://github.com/PrismLauncher/PrismLauncher

Main website: https://prismlauncher.org

## AUTHORS
Prism Launcher Contributors


qchdman

package: qchdman

title: qchdman(6)

text:
# qchdman(6)

## NAME
qchdman - Qt CHDMAN GUI, a graphical CHDMAN front-end

## SYNOPSIS

```
qchdman [-config_path path]
```

## DESCRIPTION
Qt CHDMAN GUI - or qchdman in short - is an approach to creating a graphical user interface for 'chdman', MAME's Compressed Hunks of Data manager, which is implemented as a tool used purely from command line. In a way qchdman is just a front-end, making it easier for not-so-technically-inclined users to even work with 'chdman'. However, at the same time it adds platform-independent scripting capabilities and ease-of-use features which should make it an interesting add-on for everyone.

For details, please see qchdman's wiki page at this URL: https://wiki.batcom-it.net/index.php?title=Qt_CHDMAN_GUI

## OPTIONS
-config_path path

Specify this argument to use the directory path instead of the default folder (~/.qmc2) to store qchdman's configuration.

## FILES
~/.qmc2/qchdman.ini

Individual user's configuration

## SEE ALSO
qmc2-sdlmame(6), qmc2-arcade(6)

## BUGS
None that we're aware of.

New bugs can be reported here: https://tracker.batcom-it.net/view_all_bug_page.php?project_id=1

## AUTHOR
The QMC2 development-team (https://qmc2.batcom-it.net/)


title: qmc2-main-gui(6)

text:
# qmc2-main-gui(6)

## NAME
qmc2-sdlmame - QMC2 - M.A.M.E. Catalog/Launcher II

## SYNOPSIS

```
qmc2-sdlmame [-config_path path] [-cc] [-tc] [-r] [-h|-?|-help] [qt_arguments]
```

## DESCRIPTION
QMC2 is a graphical front-end based on Qt which drives the great MAME emulator. Besides being a powerful catalog and launcher for systems emulated by MAME it also contains sophisticated ROM management features through its built-in ROMAlyzer.

## OPTIONS
-config_path path

Specify this argument to use the directory path instead of the default folder (~/.qmc2) to store QMC2's configuration, logs and cache-files / cache-folders.

-cc

This command line option will instruct QMC2 to clear all emulator related caches while starting up in order to forcibly reload this data from the emulator.

-tc

Specifying this option on the command line will perform a template check against the current default emulator (if set), printing its output to stdout and exiting before actual start-up occurs.

-r

The reconfigure option will relaunch the setup wizard / welcome dialog before starting. This allows you to update or correct the most important emulator settings in an easy way.

-h|-?|-help

Shows a brief command line usage help.

qt_arguments

See https://doc.qt.io/qt-5/qapplication.html#QApplication for more information. However, note that QMC2 will overwrite most of the available Qt arguments with its saved settings in ~/.qmc2/qmc2.ini.

## FILES
/etc/qmc2/qmc2.ini

System-wide default configuration (optional)

~/.qmc2/qmc2.ini

Individual user's configuration (system-wide settings will be copied initially, if any)

~/.qmc2/qmc2-sdlmame.log

Front-end log from the last run of QMC2

~/.qmc2/mame.log

Emulator-log containing the output from emulator instances launched by QMC2 (cleared whenever the 'first' emulator instance is launched)

~/.qmc2/mame.rsc

ROM state cache

~/.qmc2/mame.mlc

Machine list cache

~/.qmc2/mame.mlc.filtered

Filtered version of the machine list cache used by qmc2-arcade(6) (optional)

~/.qmc2/mame-xml-cache.db

XML cache database (SQLite 3)

~/.qmc2/mame-user-data.db

User data database (SQLite 3) containing rank information and personal comments per machine as well as paths to system- and software-manuals per machine/software

~/.qmc2/mame-machine-list.db

SQLite3 database version of the machine list cache (used by custom views)

~/.qmc2/mame-swl-cache.db

Software-list XML cache database (SQLite 3)

~/.qmc2/mame-icon-cache.db

Icon cache database (SQLite 3)

~/.qmc2/mame-dat-info.db

DAT-info database (SQLite 3), a combined data store for all supported DAT-info sources (emu-info, machine-info and software-info)

~/.qmc2/mame.fav

List of favorite machines

~/.qmc2/mame.hst

List of machines last played (play history)

~/.qmc2/mame.sic

Slot-info cache

~/.qmc2/sw-state-cache/*.ssc

Software-state cache

~/.qmc2/youtube/qmc2-sdlmame.yti, ~/.qmc2/youtube/*.png

YouTube video info/image cache

~/.qmc2/LocalStorage/*.localstorage

Folder used by the built-in web-browser to create small database files for 'HTML5 localStorage' support

~/.qmc2/qmc2-sdlmame-cookies.db

Permanent web-page cookie database (SQLite 3)

~/.qmc2/qmc2-sdlmame-checksum.db

ROMAlyzer's system-mode check-sum database for storing/retrieving paths to dumps available in your file-system by SHA-1 and/or CRC-32 (SQLite 3)

~/.qmc2/qmc2-sdlmame-software-checksum.db

ROMAlyzer's software-mode check-sum database for storing/retrieving paths to dumps available in your file-system by SHA-1 and/or CRC-32 (SQLite 3)

~/.qmc2/WebpageIcons.db

Web-page icon database (SQLite 3)

## SEE ALSO
qmc2-arcade(6), qchdman(6)

## BUGS
See the TODO file in the included QMC2 documentation for known bugs and restrictions.

New bugs can be reported here: https://tracker.batcom-it.net/view_all_bug_page.php?project_id=1

## AUTHOR
The QMC2 development-team (https://qmc2.batcom-it.net/)


title: qmc2-arcade(6)

text:
# qmc2-arcade(6)

## NAME
qmc2-arcade - Arcade / non-desktop version of QMC2 - M.A.M.E. Catalog/Launcher II

## SYNOPSIS

```
qmc2-arcade [-theme qml_theme] [-console type] [-language lang] [-video vdo] [-config_path path] [-fullscreen] [-windowed] [-nojoy] [-joy index] [-debugjoy] [-debugkeys] [-debugqt] [-h|-?|-help]
```

## DESCRIPTION
For those who want to 'go straight into the games' there's QMC2 Arcade, a QML / QtQuick based approach to presenting an optionally filtered machine-list, launching emulators in the same smart way that you're used to with QMC2's main GUI (see qmc2(6)).

Although it's designed to run stand-alone, you must start QMC2's main GUI at least once prior to using QMC2 Arcade, because some of the file caches need to be created first - QMC2 Arcade doesn't take care of this itself. Also, you cannot change the emulator's configuration from within QMC2 Arcade. So whenever you want to make modifications to a machine's configuration (or the global setup) you have to do this through QMC2's main GUI as well.

The main GUI also has a specific dialog for setting up all relevant back-end default options (-theme, -console, -graphicssystem, -language and -video), for producing a filtered machine list used by QMC2 Arcade exclusively (optional) and for mapping key-sequences or joystick-functions (also optional). Default values for back-end options can also be configured inside QMC2 Arcade provided the chosen qml_theme supports it (which all of the available themes do).

Changed back-end default options will require a restart of QMC2 Arcade to take effect. Specifying them on the command line will overwrite the current defaults temporarily, but will not change their stored default values. Note that the -language back-end default option is a shared setting for both QMC2 Arcade and the main GUI.

## OPTIONS
-theme qml_theme

Select the QML theme used for scene graphics, animations and/or shader effects. Available values for qml_theme are 'ToxicWaste' (default) and 'darkone'.

-console type

Choose the type of console to use. Available values for type are 'terminal' (default), 'window', 'window-minimized' and 'none'. Console type 'none' will effectively suppress all log messages.

-language lang

Choose translation to load. Run 'qmc2-arcade -h' for a list of available values for lang. Note that the default value for -language is shared with the main GUI's language setting!

-video vdo

Enable (vdo = 'on') or disable (vdo = 'off') the use of video snaps (theme-specific). The value of vdo will be ignored when the current theme has no built-in support for video snaps.

-config_path path

Specify this argument to use the directory path instead of the default folder (~/.qmc2) to search for QMC2's configuration and cache-files.

-fullscreen

Start up in full screen mode, overwriting the stored setting

-windowed

Start up in windowed mode, overwriting the stored setting

-nojoy

Disable joystick-function mapping (regardless if it's enabled in the main GUI or not).

-joy index

Use the joystick specified by index instead of the one read from ~/.qmc2/qmc2.ini, and enable joystick-function mapping (regardless if it's enabled in the main GUI or not).

-debugjoy

Enable debug logging for joystick-function mapping. Every recognized joystick-function which has been mapped to a key-sequence will be logged to the console.

-debugkeys

Enable debug logging for key-sequence mapping. Every recognized key or key-sequence will be logged to the console together with info on how the event is processed. Mapped key-sequences will cause event emulation, others will follow Qt's default event processing.

-debugqt

Enable logging of Qt debug messages

-h|-?|-help

Show usage help, available options / values and their current defaults.

## FILES
/etc/qmc2/qmc2.ini

System-wide default configuration (optional)

~/.qmc2/qmc2.ini

Individual user's configuration

~/.qmc2/mame.mlc

Machine list cache

~/.qmc2/mame.mlc.filtered

Filtered version of the machine list cache created by qmc2(6) (optional)

~/.qmc2/mame-icon-cache.db

Icon cache database (SQLite 3)

~/.qmc2/mame-dat-info.db

DAT-info database (SQLite 3), a combined data store for all supported DAT-info sources (emu-info, machine-info and software-info)

## SEE ALSO
qmc2-sdlmame(6), qchdman(6)

## BUGS
See the TODO file in the included QMC2 documentation for known bugs and restrictions.

New bugs can be reported here: https://tracker.batcom-it.net/view_all_bug_page.php?project_id=1

## AUTHOR
The QMC2 development-team (https://qmc2.batcom-it.net/)


redeclipse

package: redeclipse

title: redeclipse(6)

text:
# redeclipse(6)

## NAME
redeclipse - script to launch the Red Eclipse FPS game client

## SYNOPSIS
redeclipse

[-hhomedir] [-ppackagedir] [-osauerdir] [-glogfile] [-df{0|1}] [-dwwidth] [-dhheight] [-du{agf123}] [-dasamples] [-dddepth]

[-x'command(s)'] [-v{0..4}] [--help]

[-ss{0..3}] [-smservermaster] [-saservermasterport]

## DESCRIPTION
Red Eclipse is a single-player and multi-player first-person ego-shooter, built as a total conversion of Cube Engine 2, which lends itself toward a balanced gameplay, with a general theme of agility in a variety of environments.

redeclipse is a script which executes the redeclipse binary from the /usr/lib64/redeclipse directory.

The recommended way to change the settings of the client are to edit the config.cfg and init.cfg files in the home directory.

The redeclipse client starts a local loopback server upon launch which it uses to connect to for singleplayer, hence many of the server options are accepted by the redeclipse binary as well (see redeclipse-server(6)). To edit the specific settings related to the loopback server, use the localexec.cfg and localinit.cfg files in the home directory.

## CAVEATS
Many of these options will, if used, be permanently saved in the init.cfg file.

## OPTIONS

### Filesystem options
-hhomedir

Sets your home directory to homedir. Red Eclipse will look for files in this directory in addition the normal installation directory. All user files will be written to the home directory. Defaults to $HOME/.redeclipse/.

-ppackagedir

Includes the data files found in packagedir. Can be used for adding additional mods. Packages will be loaded in the order specified. By default redeclipse only includes data files in its working directory /usr/share/redeclipse/, and in the temp subdirectory of the home directory.

-osauerdir

Sets the path to your Sauerbraten directory. If Red Eclipse can find your Sauerbraten directory, you can load and play Sauerbraten maps from withing Red Eclipse.

-glogfile

Output log to logfile. Path is set relative to homedir unless a leading ´/' is used, uses stdout if -g is given without a parameter. Defaults to log.txt.

### Video options
-df{0|1}

Turns fullscreen mode on or off. 0 to disable, 1 to enable. Defaults to 1.

This configuration is stored in init.cfg

-dwwidth

Sets screen width to width. If height not specified, also sets height to 3/4 of width. min is 320.

This configuration is stored in init.cfg

-dhheight

Sets screen height to height. If width not specified, also sets width to 4/3 of height. min is 320.

This configuration is stored in init.cfg

-dasamples

Sets full-scene anti-aliasing (FSAA) to samples samples.

This configuration is stored in init.cfg

-dddepth

Sets z-buffer depth to depth.

This configuration is stored in init.cfg

### General options
-x'command1; command2; ...'

Executes a list of commands once Red Eclipse has started up.

-v{0..4}

Sets verbosity. This affects how much information is printed to the console. 0 is the least verbose, 4 is the most verbose, defaults to 0.

This configuration is stored in init.cfg

--help

Display this manpage

### Server options
-ss{0..3}

Sets the server type of the local server. 0 for local only, 1 for private, 2 for public, 3 for dedicated. Defaults to 1. If set as dedicated (3) redeclipse will act similarly to redeclipse-server and not start the GUI.

-smservermaster

Connects to servermaster to get the list of available servers, defaults to play.redeclipse.net.

-saservermasterport

Contacts the master server using port servermasterport, defaults to 28800.

## EXAMPLES
redeclipse -p$HOME/mod/data

Load data from an additional directory.

redeclipse -h$HOME/redeclipse_configs/

Reads and writes the configuration files to the specified directory instead of $HOME/.redeclipse/.

redeclipse -x'mode 7; trialweapon 0; map hinder'

Sets game mode to time trial, trialmode weapon to empty hands, and starts a game on the map "hinder".

## AUTHORS
Red Eclipse's main developers are Quinton "quin" Reeves and Lee "eihrul" Salzman

This manual page was written by Martin Erik Werner <martinerikwerner@gmail.com>

## HISTORY
Red Eclipse was forked as a continuation of the game Bloodfrontier, which in turn was based on the Cube2 engine and the Sauerbraten game. Red Eclipse and Sauerbraten are now developed in parallel.

## SEE ALSO
redeclipse-server(6).


redeclipse-server

package: redeclipse-server

title: redeclipse-server(6)

text:
# redeclipse-server(6)

## NAME
redeclipse-server - script to launch the server for the Red Eclipse FPS game

## SYNOPSIS
redeclipse-server

[-hhomedir] [-ppackagedir] [-osauerdir] [-glogfile] [-ss{0..3}] [-skjoinpass] [-sPadminpass] [-sldefaultmap] [-x"command(s)"]

[-siserverip] [-spserverport] [-smservermaster] [-saservermasterport] [-suserveruprate]

[-ms{0|1}] [-mimasterip] [-mpmasterport]

[--help] [-v{0..4}]

## DESCRIPTION
Red Eclipse is a single-player and multi-player first-person ego-shooter, built as a total conversion of Cube Engine 2, which lends itself toward a balanced gameplay, with a general theme of agility in a variety of environments.

redeclipse-server is a script which executes the redeclipse-server binary from the /usr/lib64/redeclipse directory.

The recommended way to change the settings of the server is to create and edit the file servinit.cfg in your home directory. Examples are available in /usr/share/doc/redeclipse/examples/

## OPTIONS

### Filesystem options
-hhomedir

Sets your home directory to homedir. This is where servinit.cfg is read from, it defaults to $HOME/.redeclipse/.

-ppackagedir

Includes the data files found in packagedir. Can be used for adding additional maps that may be distributed to clients. By default redeclipse-server only includes data files in the working directory /usr/share/redeclipse/data and in the subdirecory temp of the home directory.

-osauerdir

Sets the path to your Sauerbraten directory. If the Red Eclipse server can find your Sauerbraten directory, it will be able to load and distribute maps from it.

-glogfile

Output log to logfile. Path is set relative to homedir unless a leading ´/' is used, uses stdout if -g is given without a parameter. Defaults to stdout.

### Server configuration options
-ss{0..3}

Sets server type. 0 for local only, 1 for private, 2 for public, 3 for dedicated. Defaults to 1.

-skjoinpass

Sets the join password to joinpass. Users must know the password before they can connect.

-sPadminpass

Sets the admin password to adminpass.

-scmaxclients

Sets the maximum number of clients to maxclients.

-sldefaultmap

Sets default map to defaultmap.

-x"command 1; command 2; ..."

Executes a list of commands once the Red Eclipse server has started up.

### Server connection options
-siserverip

Binds the server to the host address serverip. Only needed for machines with more than one interface.

-spserverport

sets the server port to serverport.

-smservermaster

Uses servermaster as the master server, defaults to play.redeclipse.net.

-saservermasterport

Contacts the master server using port servermasterport, defaults to 28800.

-suserveruprate

Caps upstream rate to serveruprate. Once the cap is hit it will likely cause major connection glitching and disconnects. Use maxclients for bandwitch limiting instead.

### Master server options
-ms{0|1}

Enables the server to act as a master server, defaults to 0.

-mimasterip

Binds the master server to the host address masterip. Only needed for machines with more than one interface, defaults to localhost.

-mpmasterport

Binds the master server to the host port masterport, defaults to 28800.

### General options
--help

Display this manpage

-v{0..4}

Sets verbosity. This affects how much information is printed to the console. 0 is the least verbose, 4 is the most verbose.

## EXAMPLES
redeclipse-server -p$HOME/mod/data -ss0 -slbath -sPpass

Loads data from an additional directory, sets the server type to local (LAN), sets the default map to "bath" and sets the admin password to "pass"

redeclipse-server -h$HOME/redeclipse-server_configs/

Reads and writes the configuration files to the specified directory instead of $HOME/.redeclipse/.

## AUTHORS
Red Eclipse's main developers are Quinton "quin" Reeves and Lee "eihrul" Salzman

This manual page was written by Martin Erik Werner <martinerikwerner@gmail.com>

## HISTORY
Red Eclipse was forked as a continuation of the game Bloodfrontier, which in turn was based on the Cube2 engine and the Sauerbraten game. Red Eclipse and Sauerbraten are now developed in parallel.

## SEE ALSO
redeclipse(6)


retris

package: retris

title: retris(6)

text:
# retris(6)

## NAME
Retris - A tetromino game with graphics output to a Linux terminal or LED smart curtain. In this game you can rewind time.

## DESCRIPTION
A tetromino game with the following features:

- demo recording and playback

- time rewind

- automatic playback of recorded demos after a gameover

- gamepad support

- Linux terminal output

- Zengge/Surplife 20x20 LED smart curtain output

Was developed specifically for the purpose of outputting to a 20x20 LED smart curtain (which use the Surplife app), so the resolution in the Linux terminal is the same.

Has no relation to the game of the same name distributed on Steam (which is not a tetromino at all).

Can run on both regular PCs and small development boards, tested under Armbian on Raspberry Pi Zero 2W, Orange Pi One and Orange Pi Zero Plus2 H3. But for the development board, you might need a decent USB Bluetooth adapter. For example, the built-in Bluetooth on the Raspberry Pi Zero 2W produces a very low frame rate when updating smart curtain.

## SYNOPSIS
retris [options]

## OPTIONS
--refresh 5..100

set the refresh rate in ms (default 20)

--next [-]0..3

how many next pieces to show,

a negative value inverts the order

(default 1)

--record demo.rec

record a demo file

--play demo.rec

play a demo file

--seekend N

seek N seconds from the end of the demo

--dir path

play demos from this directory

(default "/usr/share/games/retris/replays")

--rewind 1..120

rewind length in seconds (default 10)

--testdemo

show demo info (specified by --play option)

--notermgfx

disable graphics output to the terminal

--color {rgb|simple|no}

set terminal colors (default "simple")

## JOYSTICK OPTIONS
--js /dev/input/jsN

specify the device

--js_thr 0x4fff{,0x2fff}

axis on/off thresholds

--js_rep N

button repeat rate in ms (default 100)

## SMART CURTAIN OPTIONS
--curtain_mac XX:XX:XX:XX:XX:XX

specify the MAC address of the Zengge Smart Curtain

--curtain_retry N

retry after N ms if connection is lost (disabled by default)

--curtain_refresh N

curtain refresh rate in ms (default 67)

--curtain_verbose N

verbosity level for the Bluetooth code

## EXAMPLES
Run the game on a smart curtain without displaying graphics in the terminal:

retris --notermgfx --js /dev/input/js0 \

--curtain_mac "08:65:F0:XX:XX:XX" \

--curtain_retry 3000

## KEYBOARD CONTROLS

```
| Key(s)         | Action             |
|----------------|--------------------|
| Up, W, Space   | rotate right       |
| Left, A        | move left          |
| Right, D       | move right         |
| Down, S        | move down          |
| Enter          | drop               |
| P              | pause              |
| Backspace      | rewind             |
| R              | restart            |
| Esc            | quit               |
```

## GAMEPAD CONTROLS

```
| Key(s)         | Action             |
|----------------|--------------------|
| X, A, LB       | rotate left        |
| Up, Y, B, RB   | rotate right       |
| Left           | move left          |
| Right          | move right         |
| Down           | move down          |
| LT, RT         | drop               |
| Mode, Start    | pause              |
| Select         | rewind             |
| Select (1 sec) | restart            |
```

## PROJECT PAGE
https://github.com/ilyakurdyukov/retris

## COPYRIGHT
Copyright (C) 2026 Ilya Kurdyukov