Free knights software for linux

Emacs Chess is an object-oriented library written in Elisp for manipulating chess objects (games, plies, positions, etc.), and for displaying them.
Main features:
- Emacs Chess is also an object-oriented library for manipulating chess objects (games, plies, positions, etc), and for displaying them. It supports a wide range of engine objects to use as move sources. This what allows chess.el to act as a chess client.
- chess-announce.el announces your opponents moves verbally, such as "knight takes at f4"provided you have "festival" installed.
- chess-sound.el is similar to chess-announce, but uses specific WAV files for each sound used. It takes up much more disk space, but is nicer to listen to. Available in English only at the moment.
- chess-irc.el provides a tiny IRC bot, allowing you to play games over IRC so long as your opponent enters moves in short algebraic notation. If they dont have chess.el, all they need is a regular chessboard, and a knowledge of SAN (short alegebraic notation).
- chess-ics.el lets you to play on Internet Chess Servers, using chess.el as your chessboard display (which means chess-announce works with it, etc). It has only been tested with FICS so far.
- chess-crafty.el, chess-gnuchess.el and chess-phalanx.el let you play against the Crafty, Gnuchess and Phalanx engines.
- chess-random.el will create Fischer Random positions to play against. Note that this feature only really works against opponents who are also using chess.el. Simply type "S" in the chessboard display buffer to setup a Fischer Random starting position.
- chess-network.el lets you play against other chess.el users directly, over a single open port on the server side. To be a server, you must have "netcat" installed, or be using Emacs 21.3 or higher (which supports server side network sockets). To be a client, all you need is Emacs 21.1 or higher.
- chess-link.el lets you tie two engines together, so that events from one are responded to by events from another. This can let you run a chess bot on your computer over any of the transport, or you can use it to pit two computer chess engines against each other.
- chess.el can even export chessboard display to other X servers, allowing you to play against people in your meeting room, even if they dont have Emacs installed!
Enhancements:
- This maintenance release includes several bugfixes.

Test::Cmd is a Perl module for portable testing of commands and scripts.

SYNOPSIS

use Test::Cmd;

$test = Test::Cmd->new(prog => program_or_script_to_test,
interpreter => script_interpreter,
string => identifier_string,
workdir => ,
subdir => dir,
match_sub => $code_ref,
verbose => 1);

$test->verbose(1);

$test->prog(program_or_script_to_test);

$test->basename(@suffixlist);

$test->interpreter(script_interpreter);

$test->string(identifier string);

$test->workdir(prefix);

$test->workpath(subdir, file);

$test->subdir(subdir, ...);
$test->subdir([sub, dir], ...);

$test->write(file, read($contents, [subdir, file]);
$test->read(@lines, [subdir, file]);

$test->writable(dir);
$test->writable(dir, $rwflag);
$test->writable(dir, $rwflag, %errors);

$test->preserve(condition, ...);

$test->cleanup(condition);

$test->run(prog => program_or_script_to_test,
interpreter => script_interpreter,
chdir => dir, args => arguments, stdin => pass(condition, &func);

$test->fail(condition);
$test->fail(condition, &func);
$test->fail(condition, &func, $caller);

$test->no_result(condition);
$test->no_result(condition, &func);
$test->no_result(condition, &func, $caller);

$test->stdout;
$test->stdout($run_number);

$test->stderr;
$test->stderr($run_number);

$test->match(@lines, @matches);
$test->match($lines, $matches);

$test->match_exact(@lines, @matches);
$test->match_exact($lines, $matches);

$test->match_regex(@lines, @regexes);
$test->match_regex($lines, $regexes);

$test->diff_exact(@lines, @matches, @output);
$test->diff_exact($lines, $matches, @output);

$test->diff_regex(@lines, @regexes, @output);
$test->diff_regex($lines, $regexes, @output);

sub func {
my ($self, $lines, $matches) = @_;
# code to match $lines and $matches
}
$test->match_sub(&func);
$test->match_sub(sub { code to match $_[1] and $_[2] });

$test->here;

The Test::Cmd module provides a low-level framework for portable automated testing of executable commands and scripts (in any language, not just Perl), especially commands and scripts that interact with the file system.

The Test::Cmd module makes no assumptions about what constitutes a successful or failed test. Attempting to read a file that doesnt exist, for example, may or may not be an error, depending on the software being tested.

Consequently, no Test::Cmd methods (including the new() method) exit, die or throw any other sorts of exceptions (but they all do return useful error indications). Exceptions or other error status should be handled by a higher layer: a subclass of Test::Cmd, or another testing framework such as the Test or Test::Simple Perl modules, or by the test itself.
(That said, see the Test::Cmd::Common module if you want a similar module that provides exception handling, either to use directly in your own tests, or as an example of how to use Test::Cmd.)

In addition to running tests and evaluating conditions, the Test::Cmd module manages and cleans up one or more temporary workspace directories, and provides methods for creating files and directories in those workspace directories from in-line data (that is, here-documents), allowing tests to be completely self-contained. When used in conjunction with another testing framework, the Test::Cmd module can function as a fixture (common startup code for multiple tests) for simple management of command execution and temporary workspaces.

The Test::Cmd module inherits File::Spec methods (file_name_is_absolute(), catfile(), etc.) to support writing tests portably across a variety of operating and file systems.

A Test::Cmd environment object is created via the usual invocation:

$test = Test::Cmd->new();

Arguments to the Test::Cmd::new method are keyword-value pairs that may be used to initialize the object, typically by invoking the same-named method as the keyword.

PVKII Linux Server is a dedicated server package for PVKII game. This is for hosting a dedicated server not for playing!

PVKII is a Halflife 2 Modification based on 3 teams from times past locked in a never-ending battle for wealth, dominance and power.

Pirates, Vikings & Knights II pits each team against one another in a variety of different scenarios enabling a varied, strategic, and fun gameplay. Each team has its overall strengths and weaknesses, as well as each member within those teams contributing special abilities for the success or failure of each goal.

Cooperation will lead you to victory and glory!

They will battle in territories familiar to them such as Medieval Castles, European Villages, Winter Landscapes, Grassy Plains, Sea Vessels, Catacombs, Sea Ports and more!

Immerse yourself in the PVKII world!

Abura Tan project is a Rogue-like adventure game.
Abura Tan is a Rogue-like adventure game of cowboy knights and lurking horror.
AburaTanisan adventure game and a dungeon crawl. Your task is to buildupacharacterthroughadventureandto ultimately save the world.Its that simple.
Permanentdeath(permadeath) is an important feature of Abura Tan. Ifyour character dies during the course of your adventure you will not havetheoptiontoreload at an earlier point.
Because the gameplay balanceaccounts for permadeath,backing up saved games will spoil the game for you and is therefore not recommended.
Asthegameisstillin mid-stages of development you may find it somewhat lacking a purpose. There is currently no way to win.
Here are some TIPS for "Abura Tan":
- Enter the sewers near your starting location and try to delve as deeply as possible.
- Try out each character class to see which one you like most.
- Locate a town, on the surface level of Texarkana.
- Chat with the locals, or start a fight to inherit some items.
- Try chatting with non-humans too. (Certain skills may help here.)
- Try to find a kaleidoscope and apply it!
Enhancements:
- Levels are no longer discrete.
- Melee and ranged combat has been rebalanced.
- New classes, monsters, and items have been added.
- Many tweaks were made to the user interface, and many minor bugs were fixed.

gsQuery project is a PHP library that can query various game servers.
It allows you to query various game servers for things like number of players, the players itself, current map, etc. It also includes a ready to use example for non-PHP-aware people.
Games supported by "gsQuery":
- Unreal Tournamnet and most mods (gameSpy)
- Unreal Tournamnet 200x and most mods (gameSpy)
- Battlefield 1942 and most mods (gameSpy)
- Halflife and most Mods (hlife)
- Americas Army (armyGame)
- Quake 3 and some Mods (q3a)
- Star Trek: Elite Force (q3a)
- Medal of Honor Allied Assault (q3a)
- MoHAA: Spearhead/Breakthrough (mohs)
- Return to Castle Wolfenstein (q3a)
- Vietkong (vietkong)
- Rainbow Six: Raven Shield (rvnshld)
- Call of Duty (q3a)
- Battlefield Vietnam (gameSpyQ)
- Quake 2 and most mods (q2)
- Kingpin (q2)
- Sin (q2)
- Farcry (farCry)
- IGI2: Covert Strike (igi2)
- Jedi Knight 3 (q3a)
- Solider of Fortune 2 (sof2)
- Far Cry (farCry)
- Quake 2 (q2)
- Kingpin (q2)
- Heretic 2 (q2)
- Halo (halo)
- Deus Ex (deuxEX)
- Doom 3 (d3)
- Halflife 2 (hlife2)
- CS:Source (hlife2)
- Savage: The Battle For Newerth (savage)
- StarWars BattleFront (gameSpy)
- And probably more

BMUD project is a GNOME mud client.
Its a GNOME/gtk+ mud client designed to make muds more enjoyable.
Enhancements:
- Aliases (thanks Dan Tenner)
- New networking code (thanks Robert Hansen)
- Internationalization/localization (I think...)
- New preferences dialog
- Lots of fixes for compatability with muds, like
- the is appended as per rfc854 (Thanks David Knight)
- handles escape codes that dont end in m (Thanks Stephan Gtter)
- Lots of code cleanup
- Lots of bug fixes
- Connection wizard is now buttons (click on which mud you want

CONS is a replaceement for make.

Do you use Makefiles for your project? Have you ever done a "make clean; make all" just because you didnt know if the files you changed would be rebuilt correctly?

Or perhaps you work on several machines accessing an NFS server, and if their clocks arent in sync, make wont know to rebuild things? Well, welcome to a new and better way to control the building of your projects.

It is not compatible with make, but it has a number of powerful capabilities not found in other software construction systems, including make.

CONS is implemented in Perl. You dont need to know Perl to use CONS, although you can use it more powerfully if you do.