Free boardgame software for linux

MegamekNET project is a team-based multiplayer online campaign game.

MegaMekNET is based on FASAs Classic Battletech boardgame. It lets you join the war for the Inner Sphere.

The game allows you to join a house and lead units of towering Meks against other players online from around the globe.

Crush the other houses beneath your armoured feet in this turn-based strategy game.

You and your team fight to resurrect the Star League.

Libgmonodp enables monopd-compatible boardgame clients (such as gtkmonop) to run their own servers internally.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

Teeny Weeny Microgame Engine project is a console/curses interface for playing near-arbitrary board games.
The Teeny Weeny Microgame Engine is a specification for the portable play of board- style games in a wide variety of computing environments. As proof-of-concept, teeny-cpp implements the Teeny LRFC (Lesser RFC) and many extended features with a shell-like console interface and a curses-based UI.
Despite their simple appearances, they are very extensible via C++ and basic game script code using the commands defined in the LRFC. It is intended for hard-core hobby board gamers or war gamers.
Main features:
- Acts as a reference implementation of and an experimentation ground for the Teeny LRFC.
- It has two major modes of operation: console mode (for the Power User) and curses mode (for a colorful UI).
- Internally controlled almost completely via the command language interface described in the Teeny LRFC. This allows us to extend the list of game options almost indefinately without having to change the internals of the framework. This also inherently allows us to operate the game environment via scripts containing lists of game commands.
- The scriptability means we can use arbitrary tools to generate game data. For example, creating games using bash scripts is often easier than hand-writing game scripts because we can take advantage of the advanced features of such a shell, like loops and conditionals (which are lacking in our code).
- The curses UI allows some keys to be programmed to arbitrary command strings. This makes doing common operations a snap. (i hope to improve this support to cover most keys.) For example, map a key to the command teeny-board rotate to quicky rotate your game board.
- For boardgame designers it offers a pretty simple interface for prototyping game designs.
- Generic plugins/DLL support means clients may plug in their own commands or even plug in their own plugin base types. As a demonstration, the source comes with EDeck, a plugin for handling abstract decks of cards (i.e., lists of shuffleable items from which we may pull items off the top). Of course... this plugin can be controlled via the command language interface, so its scriptable.
- The curses UI has support for manipulating all commonly-used curses text attributes, including colors, bold, blink, underline, etc., for the game board. Attributes are specified on a per-Avatar basis, and each set of attributes (colormap) may be named, loaded and saved at will. As usual, these are controlled via the command language, and are thus scriptable.
- Most parts of the interface support the use of $VARIABLES from the user. e.g., loading $TEENY_HOME/file.s11n will load the file ~/.teeny/foo.s11n. You may of course define and manipulate these variables as you wish.
- Startup of the app can be customized via a script. e.g., to load a game or macro keys, set up environment variables, etc.
- Powerful, flexible object serialization support, which means that we can add support for saving/loading near-arbitrary data with extremely little effort, without having to worry one iota about the underlying data formats, transport layers, and other bogusness. We can independently save and load almost all parts of the games state if we wish, as well. Shameless plug: http://s11n.net
- The source code is fairly hackable, if i may say so. Adding command handlers and DLLs is especially simple for even entry-level C++ coders. im always looking for ways to improve the code, so feel free to contribute :).

csvdiff is a simple perl script to compare two (comma) seperated files with each other.
Mindless is an SDL-based puzzle game similar to the classic boardgame Mastermind.
The goal of the game is to crack a secret code consisting of four balls which can each be one of eight colors. The players takes turn guess (or do it simultaneously) and the first one to guess his/her code has won.
If both players takes the same number of turns to get the code correct then both has won.
For your help when guess you will for each (incorrect) answer see a combination of one or more black tokens and one or more white tokens on the right side of your last answer.
Each black token means that one of your balls is both of the correct color and location, but you dont know which one, and each white token means that one of your balls is of the correct color but wrong location.
You can play human vs. human, human vs. computer, or computer vs. computer.
Currently each player can either be controlled by a human player, a human with some computer assistance or by the computer. For computer controlled players there exists three different difficulty settings: "Automata", which is the simplest, "Computer" which is the default and "AI" which is the hardest.
Note that the AI setting uses quite a lot CPU cycles and it runs very slowly with more than 8 colors.
Enhancements:
- New gui elements, alternative AIs and "cyborg" mode.

JTicTacToe project is a version of the popular boardgame "Tic Tac Toe".

JTicTacToe is a version of the popular boardgame "Tic Tac Toe", with the difference that you can have a gamefield of arbitrary size and you need 5 Xs or Os in a row to win.

You need to play against another human being; JTicTacToe is meant to be played via the Internet.

Installation

Theres really not much to install. The tarball that can be downloaded just needs to be deflated using winzip in Windows or tar -xvzf jtictactoe.tar.gz if youre using Linux/Unix.

JTicTacToe is written in Java and all you need to run the game is the executable jar included in the tarball and a working Java Virtual Machine. You can place the extractet jar file wherever you please.

GF1 allows you to play GIPF against your computer.
GF1 is a computer program for playing the 2 player boardgame GIPF.
It has a nice and easy to use graphical user interface and you can play against another human, against the computer, or let the computer play against itself.
The computer player is good enough to beat even the best human players at the moment.
The faster you computer, the better it plays. But even on a pentium 60, the computer can be hard to beat.
Enhancements:
- a new way to execute a move has been added: if you now click on the to-position when it has already been selected, your move gets executed.
- added license-section to the about-box.
- the main window titlebar will show the name of the file you loaded or saved. when saving you can automatically use the same name as the previously loaded file.
- started using a new filechooser widget. (should be easier for windows-users)
- the file produced by the option "save log" now has the format specified on the gipf website for writing down games.

Pytego project is a networkable "Stratego" clone created with Pygame.
Pytego is a two-player, cross-platform networked clone of the classic boardgame "Stratego" from Milton Bradley developed using Pygame and SDL.
I could not find a good, networkable, free version of Stratego -- so I wrote my own. Mostly because I was interested in developing a game, partially because I think Python is a terrific language and partially because I was bored (sssh!).
This is the initial release of Pytego. Download it, try it out and send me your comments, questions, suggestions, and bug reports. Also, Im no artist, so send me new tiles and new graphics for the units -- anything! On my TODO list is support for user-customizable tilesets and icons.
Id like to acknowledge the Civil developers for inspiration (and their clear, easy-to-use networking code). Id also like to acknowledge David Clarkes Newbie Guide for convincing me to not worry about the "side issues" (rule #8) and to do things the "pythony way" (rule #13).
Enhancements:
- Reuse the "box" as the status area after the game has started, this way theres not a HUGE blank, white area after all the pieces have been placed.