Free othello game 0.2.1 software for linux

Gothello project is a GTK-based Othello game.

Its for one or two players.

You can use it to play against other people or against the computer, or you can play the computer against itself. The AI is implemented using Negamax search with Alpha-Beta pruning, with Iterative Deepening.

It has both fixed-depth and fixed-time search modes.

Games::Othello is a Perl extension for modelling a game of Othello.

SYNOPSIS

use Games::Othello;

my $game = Games::Othello->new();

while( !game->over ) {
printf "It is presently %ss move",
($game->whos_move eq b) ? black, white;
my @possible_moves = values $game->possible_moves();

if ( ! @possible_moves ) {
print "You have no moves available, you must pass.
$game->pass_to_opponent;
} else {
foreach ( my $move ) @possible_moves ) {
printf
"You will take %d of your opponents chips if you place your chip on %d,%d",
scalar @{ $move->{chips} }, $move->{x}, $move->{y};
}
my ($locx, $locy) = get_move();
my $flipped = $game->place_chip( $locx, $locy );
}

my $layout = $game->chip_layout();
foreach my $row ( @$layout ) {
foreach my $pos ( @$row ) {
printf %3s,
($pos eq b) ? B # Black occupied square.
: ($pos eq w) ? W # White occupied square.
: # Un-occupied square.
}
print "nn";
}
}
my ($black_score, $white_score) = $game->score;

Athana is a webserver written entirely in Python. Athana is based on the medusa web-server framework.
Main features:
- Support for upload functionality (http multipart)
- Session handling
- Cookies
- TAL Page Templates

Epiphany project is a multiplatform clone of the game Boulderdash.

It is written entirely in C++, using Clanlib as its graphic library.

The player must collect all valuable minerals scattered in levels, while avoiding being hit by a falling boulder or a bomb.

As an Othello player I have used since 1988 several tools and programs for improving my game play. The most often used tools have been: Thor, Cassio and WZebra. Those programs are very interesting tools for studying Othello but they have all the same drawback: you are locked to one OS platform.
The OthBase project has started beginning of November 2002 based on the following constatations:
- there was no cross platform Othello database program that was available on several platforms; you needed for example to use Cassio for MacOS 9.X, or use WZebra for Windows if you wanted to study tournament level games
- there was no Othello database program available on the Java platform nor Linux (sorry LZebra was not very well supported on Linux)
- there was always the need to update manually the database when using Cassio or WZebra; this task should have been done automatically via the program itself
Ajax and Cyrano, two good Othello programs written in Java, have shown that we can have strong and interesting Othello programs written on the Java platform
As an early Java adopter (since the first JDK 1.0 beta release in 1996!) and Othello addict, I decided on November 2002 to start this project as the Java platform is now very popular and really more mature than a couple of years ago. The JFC/SWING GUI library is now at a good level and JVM performances are increasing each year. Check for example infos about HotSpot. Moreover the Java developers community is really alive and responsive. You can check at Apache Jakarta Project and at JavaDesktop.
My main goals are:
- to promote Othello thru the use of a database program for studying games of tournament players
- to develop an Othello database program in Java that will be the same on Windows, MacOSX or Linux
- to support the Thor database format and other popular game file formats (e.g. XOF, SGF, PGN, Cassio)
- to implement a database feature set identical at minimum to Cassios one
- to allow an easy installation and update of the program
- to allow an easy update of the FFO game database available in the Thor database format
- to add new cool extra features that are needed by Othello players in a responsive way
- to allow developers to add some plugins into the program to add new features
Main features:
Database Formats Support
- XOF database files
- Thor database (.WTH / .JOU / .TRN files)
- PGN database files (Kurnik and VOG)
- GGF (old GGS server)
- Yahoo! Japan logs from Uniyma (text export format)
Database Management
- Create / Read / Import / Save XOF database files
- Read / Import Thor database directory
- Clean Thor database directory
- Synchronize manually / autimatically a Thor database directory with a FTP server
- Read / Import PGN database files
- Read / Import GGF database files
- Read / Import TXT database files from Uniyma logs
- In memory Database Merge thru import
- In memory Database export to XOF
- Add game to In memory Database
- Delete game(s) from In memory Database
- MRU support (most recently used database files)
- In memory Database filtering on Tournament (name, date), player name with support of complex boolean filters
- On the fly computed statistics for In memory Database depending on the moves played and filter
- Set / Unset Games bookmark
- Manage Games bookmarks
- Go to bookmarked game
Game Management
- Play game with backward/forward/go to start/go to end
- Mouse wheel support for fast move forward / backward
- Enter game as sequence of move on board
- Enter a game as a diagram
- Copy move list / position / diagram
- Paste move list
- Drag and drop a game from game list to Othello board
- Show game diagram
- Goto Move: by clicking on a move in diagram mode

Chess::Game is a class to record and validate the moves of a game of chess.

SYNOPSIS

use Chess::Game;

$game = Chess::Game->new();
$clone = $game->clone();
$move = $game->make_move("e2", "e4");
$move_c = $clone->make_move("e2", "e4");
$true = ($move->get_piece() ne $move_c->get_piece());
$move = $game->delete_move();
...
while (!defined($result = $game->result())) {
# get a move
$move = $game->make_move($sq1, $sq2);
if (!defined($move)) {
print $game->get_message();
}
}
if ($result == 1) {
print "White wins!n";
}
elsif ($result == 0) {
print "Draw!n"
}
else {
print "Black wins!n";
}

The Chess module provides a framework for writing chess programs with Perl. This class forms part of that framework, providing move validation for all moves recorded using the Chess::Game class. The Game contains a Chess::Board, 32 Chess::Pieces and a Chess::Game::MoveList that contains a series of Chess::Game::MoveListEntrys that record the exact state of the game as it progresses. Moves can be taken back one-at-a-time to allow for simple movelist manipulation.