Free board game risk software for linux

Acquire is a computer version of the classic board game.
The goal of the game is to make the most profit by buying stocks in companies that form, merge and grow as tiles are placed on the game board.
This program is a text-based version of the game and should be playable on any system with a C++ compiler.
Enhancements:
- The main improvement of this release is that the bug causing the game to crash at the end was fixed, so you can now see who won.
- There were some other small bugfixes and changes.

BoardGame Tool provides a C++ front-end/Python back-end for running board games.
It features an easy and flexible interface to interact with the players and has transparent support for network or AI-controlled games.
Through a clear XML interface, games elements can be specified. Using an easy-to-learn back-end language like Python for rule implementations makes it very easy to implement, adjust, or enhance rules that come with a game.
The same back-end language can be used easily for simple or complex AI implementations.
Main features:
- XML specification with DTD validation for game definition
- Easy-to-learn Python programming for rule implementation
- Integrated and transparent network play
- Network chat with selected players
- Simple interface for programming AI players
- Extensive support for image formats
- Runtime scaling of images, allowing easy application of anything as gamepiece
Games currently implemented:
- Chess
- Go
Enhancements:
- This release includes the data archive with correct licensing information for the Fergus Duniho abstract chess piece set.

gewee game is a Go-like board game with "next generation" graphics.

This is a game between a human ("player") and a computer ("opponent"). The players objective is to accumulate as many points as possible. When the player wins a game, a point is added to his/her score. When the player loses a game, a point is subtracted from his/her score. The competitor with the most pieces on the board at the end of the game is the winner. A game is finished when a competitor forfeits, or has no valid empty square to place a piece on. The opponent is granted additional moves at the start of a game based on the players score.

Each competitor has a distinct set of pieces of the same shape and color. The competitors take turns placing one piece on an empty square on the board. A piece or group of pieces that has no empty square adjacent to it is removed from the board.

MegaMek project is an unofficial, online version of the Classic BattleTech board game.
Currently, nearly all level 1 BattleTech rules and technology are working. Work is progressing on level 2 rules and technology, and most of those are functional at this point. Even some level 3 rules have been added.
MegaMek is open source, free software. It is licenced under the GPL.
Main features:
- Network or hotseat play for 2 or more players
- A cunning AI opponent for offline play
- All level 1 (3025) tech
- Most level 2 (2750, 3050+) tech
- Compatible with all 3025 mechs and many from later eras
- Most level 1 rules implemented
- Many level 2 rules implemented, including vehicles, infantry and fire
- Map board selection and editing
- Map boards based off official map packs included
- Mech selection and support for some mech editors
- Most official mech designs included
- Color graphics
- Lasers
Enhancements:
- Bug: bot died when only unarmed targets available
- Bug: occasional exceptions observing bot v bot games
- Tweak build.xml to ask for version number when packaging a new release.
- Bug 1588924: Cannot Open Custom BA Panel with Java 1.4
- Bug 1582609: Cannot load MUL that includes the TMP-3M2 "Storm Tempest"
- Bug 1585497: Check for partial cover when hitting with infernos
- Bug 1598976: Mech with Torso-Mounted Cockpit destroyed by head blown off critical.
- Bug 1591093: no units to move error when swarming infantry knocked off in accidental fall
- Body-mounted C3 Masters in Tanks should fire their TAG into the front arc,
- per the Ask the PM Forum.
- Bug 954406: Charge declaration and stacking
- Bug: Megamek required "Helvetica" font
- Bug: NPE in stop swarm attack if the swarmed unit was destroyed earlier in the phase
- Bug 1613504: Unloading BA from prone mech didnt work
- Bug 1610653: Flying BA can be thrashed
- Bug 1598816: Description of Game Option "Friendly Fire"
- Bug 1623985: Swarm LRM attacks source

SYNOPSIS

# automatical computer-vus-computer play script
use Games::Checkers::Constants;
use Games::Checkers::Board;
use Games::Checkers::BoardTree;

my $board = new Games::Checkers::Board;
my $color = White;
my $numMoves = 0;
print $board->dump;

while ($board->canColorMove($color)) {
sleep(2);
# allow 100 moves for each player
die "Automatical drawn" if $numMoves++ == 200;
my $boardTree = new Games::Checkers::BoardTree
($board, $color, 2); # think 2 steps ahead
my $move = $boardTree->chooseBestMove; # or: chooseRandomMove

$board->transform($move);
print $move->dump, "n", $board->dump;
$color = ($color == White)? Black: White;
}

print "n", ($color == White? "Black": "White"), " won.n";
ABSTRACT ^
Games::Checkers is a set of Perl classes implementing the Checkers game play. Several national rule variants are supported. A basic AI heuristics is implemented using the Minimax algorithm. Replay of previously recorded games is supported too.
DESCRIPTION ^
This package is intended to provide complete infrastructure for interactive and automatic playing and manipulating of Checkers games. Some features are not implemented yet.

Risk is a Java version of the classic RISK board game, with a simple map format, network play, single player mode, hotseat, and many more features. Risk works on all operating system that run Java 1.4 or higher.

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.

Concede project is a computer version of the board game "Take It Easy".

Concede is a computer version of the board game "Take It Easy". The game is a kind of mix between 4-in-a-row and bingo (aka loto in some place). The player start with an empty board where 19 hexagonal tiles have to be placed. At each turn a random tile is drawn and the player must put it somewhere on the board.

Each tile is marked with 3 numbers (from 1 to 9) and the player must try to make as many complete rows as possible with the tiles he get. The problem is that their is more tiles in the game than places on the board and they come in random order.

When the board is full the game end and the score is computed by adding all the complete rows together. So for example a row of four 5 is worth 20 points, a row of three 9 is worth 27 points, etc.