Free chess game 0.6.0 software for linux

3D Python OpenGL Chess Game project is a 3D chess game in Python with OpenGL.

3D Python OpenGL Chess Game is a normal chess game that has no computer player (yet). You can play against a friend on your PC.

Chess::Game::MoveList is a specialized list class for recording the moves of a Chess::Game.

SYNOPSIS

$movelist = Chess::Game::MoveList->new("white", "black");
$wpawn = Chess::Game::Pawn->new("e2", "white");
$entry = $movelist->add_move($wpawn, "e2", "e4");
$true = $entry->get_piece() eq $entry;
$bpawn = Chess::Game::Pawn->new("e7", "black");
$entry = $movelist->add_move($bpawn, "e7", "e6");
$entry = $movelist->add_move($wpawn, "e4", "e5");
@del_entries = $movelist->delete_move(1, "white"); # delete the list
$true = $entries[0]->get_piece() eq $wpawn;
$true = $entries[0]->get_dest_square() eq "e4";
$true = $entries[1]->get_piece() eq $bpawn;
$true = $entries[1]->get_dest_square() eq "e6";

The Chess module provides a framework for writing chess programs with Perl. This class forms part of that framework, recording a log of all moves during a Chess::Game in such a fashion that the list can be used to undo moves that have been made.

Chessweb is a J2EE chess game Website. It is a pure Java servlet implementation of a two-player chess game.

Two players log into the Web site, see an image of the current board in their browser, and make their moves.

The differentiating features of chessweb (e.g. versus WinBoard / XBoard) is that its an extremely lightweight implementation written completely in Java (nothing more than an app server and browser is required).

Furthermore, the client end is DHTML only, and verified to works with FireFox 1.0.6 and IE 6.

Chess::Elo is a Perl module to calculate Chess "Elo" ratings.

SYNOPSIS

use Chess::Elo qw(:all);

# Alice is going to thump Bob...
my ($alice_elo, $bob_elo) = (2100, 1200);

# Oh no, Alice lost to Bob!
my $result = 0; # 0.5 for draw, 1 for win

my @new_elo_alice_bob = elo ($alice, 0, $bob);
use Data::Dumper; warn Dumper(@new_elo_alice_bob);

[
2068.17894295388, # My, Alice took a hit on her rating :)
1231.82105704612 # Bob is setting pretty
];

This module provides a single function, elo which allows one to calculate individual ratings based on performance. Typically, a player is given an initial provisional rating of 1600 points. In all cases, one gains and loses points as a function of the playing strength of both parties and the result of their encounter.

The formula used is the same one used at magi-nation:

http://www.magi-nation.com/Tournaments/ratingsfaq.htm

Or, quantitatively speaking:

A2 = A1 + 32 ( G - ( 1 / ( 1 + 10 ** ( ( B1 -A1) / 400 ) ) ) )
A2 is Alices post-game rating
A1 is Alice rating before the game against Bob
B1 is Bobs rating before the game against Alice
G is the game result, in this case:

1, if A beats B

0, if A loses to B

0.5, if A draws to B

METHODS

($new_a, $new_b) = elo($elo_a, $result, $elo_b)

This function takes 3 arguments describing the result of a person with rating $elo_a competing with the person with rating $elo_b. The result argument is from the perspective of person A. Thus if A won $result is 1. If A lost, $result is 0. If A drew, $result is 0.5.

EXPORT

None by default, elo upon request.

glChess is a chess game with 3D OpenGL graphics.

An open-source 3D chess program. It uses openGL and gtkglarea (from GTK+) for the rendering and is designed for use in unix.

It will soon be able to be played over network much like xboard can currently. It has tentative support for computer play. Playable against a human or against "crafty" AI.

ChessTask project is a tool for generating chess tasks.

ChessTask is a frontend for easily creating chess tasks with LaTeX. The tasks are stored in a list which can be exported, either into a LaTeX input file, or into HTML files.

ChessY! project allows you to visually review the game histories from Yahoo! online chess.

You can email to yourself at the end of a Yahoo! online chess game.

Chess::PGN::Parse is a Perl module that reads and parses PGN (Portable Game Notation) Chess files.

SYNOPSIS

use Chess::PGN::Parse;
use English qw( -no_match_vars );
my $pgnfile = "kk_2001.pgn";
my $pgn = new Chess::PGN::Parse $pgnfile
or die "cant open $pgnfilen";
while ($pgn->read_game()) {
print $pgn->white, ", " , $pgn->black, ", ",
$pgn->result, ", ",
$pgn->game, "n";
}


use Chess::PGN::Parse;
my $text ="";
{
local $INPUT_RECORD_SEPARATOR = undef;
open PGN "< $pgnfile" or die;
$text = ;
close $text;
}
# reads from string instead of a file
my $pgn = new Chess::PGN::Parse undef, $text;
while ($pgn->read_game()) {
print $pgn->white, ", " , $pgn->black, ", ",
$pgn->result, ", ",
$pgn->game, "n";
}

use Chess::PGN::Parse;
my $pgnfile = "kk_2001.pgn";
my $pgn = new Chess::PGN::Parse $pgnfile
or die "cant open $pgnfilen";
my @games = $pgn->smart_read_all();

Chess::PGN::Parse offers a range of methods to read and manipulate Portable Game Notation files. PGN files contain chess games produced by chess programs following a standard format (http://www.schachprobleme.de/chessml/faq/pgn/). It is among the preferred means of chess games distribution. Being a public, well established standard, PGN is understood by many chess archive programs. Parsing simple PGN files is not difficult. However, dealing with some of the intricacies of the Standard is less than trivial. This module offers a clean handle toward reading and parsing complex PGN files.

A PGN file has several tags, which are key/values pairs at the header of each game, in the format [key "value"]
After the header, the game follows. A string of numbered chess moves, optionally interrupted by braced comments and recursive parenthesized variants and comments. While dealing with simple braced comments is straightforward, parsing nested comments can give you more than a headache.

Chess::PGN::Parse most immediate methods are: read_game() reads one game, separating the tags and the game text.

parse_game() parse the current game, and stores the moves into an
array and optionally saves the comments into an array of hashes
for furter usage. It can deal with nested comments and recursive
variations.

quick_parse_game() Same as the above, but doesnt save the comments,
which are just stripped from the text. It cant deal with nested
comments. Should be the preferred method when we know that we are
dealing with simple PGNs.

smart_parse_game() Best of the above methods. A preliminary check
will call parse_game() or quick_parse_game(), depending on the
presence of nested comments in the game.

read_all(), quick_read_all(), smart_read_all() will read all the records
in the current PGN file and return an array of hashes with all the
parsed details from the games.