Free i want to play the game sims software for linux

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.

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

Catch the Furball project is an icebreaker board game for friends to play around a computer.

It features a freshly-generated board for each game, an eclectic collection of cards, and beautiful pictures of Cambridge University.

The distribution is intended both to allow Web masters to quickly set up their own copy of the game, and to allow tinkerers to use the game engine to make their own games.

It includes the editor used to create game data.

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

Build Order Anlyzer for the Axis & Allies RTS is a tool for analyzing builds in the Axis & Allies RTS game. Many sites go to great lengths to explain Build Orders, but the Build Order Analyzer is the first tool to actually allow players the ability to define a Build Order and then compare it to other Build Orders over time.

Key Facts to know about the Build Order Analyzer:

Only tool of its kind
Can support multiple types of RTS based games (not just Axis & Allies RTS!)
Built on Java technology & open source software

The Build Order Anlyzer 2.0 for Axis & Allies RTS is a tool for analyzing builds in the Axis & Allies RTS game. Wikipedia has a great defnition for a Build Order. To summarize, a Build Order in an RTS game defines the order in which a player builds their buildings, units, and upgrades. Understanding the timing and affect of various build trees is critical in making the appropriate tactical decisions during the game.

The BOA allows a player to build and analyze multiple Build Orders without playing a game. Lose to a player due to their build? Then plug it into the BOA and figure out a build to counter it! Gamers no longer have to play game, after game, after game to figure out a decent counter to another players Build Order, they can use the BOA to figure it out. The BOA can literally save serious gamers hundreds of hours of game play!

Attal: Lords of Doom is a strategy game still in development.

Its a turn-based strategy game, that can be played alone (against AI) or against other through a network (local or internet). Attal is available under Linux and Windows.

Games::Mastermind is a simple framework for MasterMind games.

SYNOPSIS

use Games::Mastermind;

# the classic game
$mm = Games::Mastermind->new;

# make a guess
$marks = $game->play(qw( Y C W R ));

# results
print "You win!n" if $marks->[0] == $mm->holes();

# the game history is available at all times
$history = $mm->history();
$last_turn = $mm->history()->[-1];

# reset the game
$mm->reset();

Games::Mastermind is a very simple framework for running Mastermind games.

KnoppiXMAME is a bootable CD/DVD image with hardware automatic probing and configuration for playing MAME games.

No games are included, but they can be added to the ISO image, as well as new versions of X-MAME, gxmame, and the Linux kernel.