Free play the game queen wiki software for linux

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 :).

Wolvix is a GNU/Linux LiveCD built from SLAX. Wolvix is a desktop oriented distribution made to fit the needs from regular to advanced desktop users.

Along with the applications youll get some of the best free Linux games. (No 3D gfx card required).

Games Edition features over 50 games in different categories, four emulators and quite a few desktop applications.

You wont find World of Warcraft or Half-Life 2 on the CD, but Ive tried to include some of the finest free Linux games and I think there should be a game or two for most people, Ive even added dopewars for your grandma.

None of the games require 3D drivers, so you should be able to play most games on any graphics card

Custom Strategy Role Playing Game project is an engine for creating strategy role-playing games.
Two players confront two parties of characters (which have RPG attributes: job, level, exp, skills, etc.) over a battlefield, and the surviving party wins.
Jobs, skills, etc. are stored in XML custom files. It has a combat style similar to Final Fantasy Tactics and Shining Force.
Enhancements:
- Custom effects for skils.
- New contender attribute managing is working now.
- New skill types and skill capabilities (as enable at a certain level).
- Contenders final attributes can now depend on skills.
- Jobs have now a basic bonus and a level bonus (which depends on
- contenders level).
- Partial code rewriting for some old features.

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.

The Million Musician Challenge is a project to allow you to play music by playing games. The first game is a 2D vertically scrolling shoot-em-up game.

The keyboard (qwerty or musical) controls an array of sprites corresponding to the music notes. As you shoot the falling sprites, you play notes corresponding to the music.

Untahris Common Playground - you can play several classic fun, simple arcade games. But playing alone is not fun, and you can play them in multiplayer mode (on one computer, local network, or maybe Internet).
Now, Untahris has an original experimental feature, which makes it more than just a bundle of these games! In multiplayer mode each player can play a different game --- however, they play all on the same board. This may lead to funny interactions, battles or alliances between them.
The games in Untahris have been modified to make them better interact with each other. Thus, in each game you are allowed to shoot and collect bonuses, even if it was not a part of the original game.
Enhancements:
- The graphics were improved.
- Balls can kill bombers now.
- Worms, initial world selection, and sound were added.
- The homepage was made prettier.

SDLHana project is a SDL-based Hanafuda game.

Hanafuda is a Japanese-oriented card game which is mostly played in Japan and Korea, also known as "Hwa-Tu" in Korean.

Just like Poker, there are many ways to play with Hanafuda. This program currently supports two of them: Koi-Koi, which is a Japanese game, and Go-Stop, which is a Korean game.

There is also a variant of Koi-Koi game mostly found in gambling Coin-Op game machines, described as "Koi-Koi [BET]" in the game settings menu, which is played with 6 cards instead of 8 cards.