Free games go diagrams software for linux

Ghost Diagrams is a project that takes sets of tiles and tries to find patterns into which they may be formed. The patterns it finds when given randomly chosen tiles are often surprising.

It turns out that tiling patterns are a form of computation of equal power to Turing machines, lambda calculus, and cellular automata. For example, here is a tileset implementing "Rule 110", a cellular automaton known to be capable of universal computation.

Considerations similar to the halting problem and Godels theorem apply. There is no upper limit to their capacity to surprise us. Furthermore, tiles have an intuitive quality that other forms of computation lack. You can see how they fit together.

An organism is more than the sum of its organs. When the organs are fitted together, the organism becomes something more. This surprising something more we call "spirit" or "ghost". Ghost Diagrams finds the ghosts implicit in simple sets of tiles.

Games::Go::Dg2Ps is a Perl extension to convert Games::Go::Diagrams to PostScript.

SYNOPSIS

use Games::Go::Dg2Ps
my $dg2ps = B convertDiagram($diagram);

Games::Go::Dg2Ps converts a Games::Go::Diagram into PostScript.

Games::Go::Dg2TkPs is a Perl extension to convert Games::Go::Diagrams to Postscript.

SYNOPSIS

use Games::Go::Dg2TkPs
my $dg2ps = B convertDiagram($diagram);

This is a real hack to get PostScript output from the Dg2Tk converter. All it does is use the built-in PostScript that a Tk::Canvas widget provides to convert the Dg2Tk canvas pages to PostScript. The resulting PostScript is fairly crude because the Canvas that it is drawn from is crude to begin with. See Games::Go::Dg2Ps for a better PostScript converter.

A Games::Go::Dg2TkPs inherits from Games::Go::Dg2Tk, and uses all its methods and options. The main difference is that after conversion to Tk is complete, each diagram Tk::Canvas is converted to PostScript via the Tk::Canvas->postscript method. Some minor massaging of the PostScript source is done to string the canvas pages together.

Games::Go::Dg2PDF is a Perl extension to convert Games::Go::Diagrams to PDF (Portable Document Format).

SYNOPSIS

use Games::Go::Dg2PDF
my $dg2pdf = B convertDiagram($diagram);

A Games::Go::Dg2PDF object converts a Games::Go::Diagram object into a PDF file.

AGATourn is a Perl extensions to ease the pain of using AGA tournament data files.

SYNOPSIS

use Games::Go::AGATourn;
my $agaTourn = Games::Go::AGATourn->new (options);

An AGATourn object represents a round or several rounds of an American Go Association tournament. There are methods for parsing several type of AGA file format:

tdlist

The entire list of AGA members including playing strength, club affiliation, and some other stuff.

register.tde

The starting point for a tournament. All players in a tournament must be entered in the register.tde file.

round results: 1.tde, 2.tde, etc.

Game results for each round of the tournament.

A note on IDs: in general, hashes in an AGATourn object are keyed by the AGA ID. An AGA ID consists of a three letter country specifier (like USA or TMP for temporary IDs) concatenated to an integer. Here we specify the three letter country specifier as the country and the integer part as the agaNum. The country concatenated with the agaNum is the ID. My ID for example is USA2122. IDs should be normalized (capitalize the country part and remove preceding 0s from the agaNum part) with the NormalizeID method (below).

Note also that some programs may accept limited integers in the agaNum part of the ID. Accelerat, for example, seems to accept only up to 32K (someone used a signed short somewhere?)

Games::Goban is a board for playing go, renju, othello, etc.

SYNOPSIS

use Games::Goban;
my $board = new Games::Goban (
size => 19,
game => "go",
white => "Seigen, Go",
black => "Minoru, Kitani",
referee => &Games::Goban::Rules::Go,
);

$board->move("pd"); $board->move("dd");
print $board->as_sgf;

This is a generic module for handling goban-based board games. Theoretically, it can be used to handle many of the other games which can use Smart Game Format (SGF) but I want to keep it reasonably restricted in order to keep it simple.

Games::Go::SGF is a Perl module that can parse and dissect Standard Go Format files.

SYNOPSIS

use Games::Go::SGF;
my $sgf = new Games::Go::SGF($sgfdata);
print "Game played on ".$sgf->date."n";
print $sgf->white. " (W) vs. ".$sgf->black." (B)n";
print "Board size: ".$sgf->size.". Komi: ".$sgf->komi."n";

while ($move = $sgf->move($move_no++)) {
print "$move_no: ".$move->move,"n";
}

This is a very simple SGF file parser, of currently limited functionality. It can read and step through SGF files, follow variations, and so on. Its good enough for getting simple statistics about games of Go, and building up Games::Go::Board objects representing games stored as SGF.

$sgf->move returns either a normal Games::Go::SGF::Node or a Games::Go::SGF::Variation object. They behave exactly the same, but the variation object has the additional methods mainline() to get the main line of the game, variation($n) to get the first node in the nth variation, and variations to retrieve an array of variations. $variation->move will, by default, follow the mainline.

Games::SGF::Tournament is a Perl module for tournament statistics generator.

SYNOPSIS

use CGI qw / :html /;
use Games::SGF::Tournament;
my $t = Games::SGF::Tournament->new();
print html(body($t->score()));

Smart Go Format (SGF) is a file format used to store game records of two player board games. This module used to collect tournament information from a set of SGF files and produce statistic HTML tables for creating WWW tournament pages.

INTERFACE

Games::SGF::Tournament is a class with following methods:

new

The constructor. Optional parameters are:

sgf_dir

Path to SGF files representing the tournament. Default: current directory.

base_url

Base URL to prefix file names of SGF files. Default: empty string.

games

Returns a table of played games in chronological order with hyperlinks to SGF files.

scores

Returns a table of players descending by score.