Free strategy role playing games software for linux

Role Playing Tools extends the pen and paper role playing tabletop to the computer by providing a die rolling tool with a full expression language including Javascript functions, tabbed rolling bars, quick summation features, and the ability to save and restore sessions. There is also a client and server map sharing tool. Both are intended to be simple and powerful and enhance the game, not distract from it.

We found that we wanted to augment our pen-and-paper roleplaying (primarily 3.5ed D&D) with computer aids.

These tools extend and augment our traditional playing style. They are not a role playing game by themselves, nor are they meant to replace everything at the D&D table.

DiceToolis a simple but powerful expression parser that has built in functions for random number generation and can be further extended by JavaScript to do all sorts of calculations.
MapToolis an elegant graphical tool to share maps (images) and map data (drawings, markers, grid placement) in a client/server fashion between multiple players.
TokenToolis an accessory to MapTool. Drag any image onto the workspace and use the mouse to move and zoom the image in the reticle. Then drag from the preview pane directly onto MapTool -- or File->Save to save a png file.

Regnum Online is a MMORPG game, that wants to invite you to join our world and play for free. The only thing we require is that you fight for your realm.
Regnum Online is a massive multiplayer online role playing game (MMORPG MMORPG) for the PC where the player are immersed in a 3D virtual world. There they can live as Elves, Humans Dwarves, or Dark Elves having exciting adventures, exploring the wild lands or joining an army of players to take on the other kingdoms armies."
The game is in beta stage, but already offers many quests, items, and monsters, not to mention the large number of both english-, spanish-, and portuguese-speaking players youll meet in-game.
Main features:
- Regnum offers 3 realms to choose from.
- 9 fully customizable player characters.
- Hundreds of quests.
- The ability to capture forts and castles.
- Expansive lands to explore.
- Glorious graphical environments.

Online Cardgame System project is a client-server system for playing card games over the net.
OCS is a client-server cardgame system, similar to those found at Yahoo! Games and elsewhere. The server is portable and has been tested under Linux, Win32, and several unix systems. We currently have Win32 and Java clients available, and a Qt client for Linux is in development.
Games are implemented as plugin modules, so new games can be added without recompiling the server. In addition, the client is written to be unaware of the mechanics of gameplay, so it can theoretically play any games the server supports without having to know how to play them specifically.
We currently have Euchre and Spades implemented, with bot support for both games, meaning you dont need a full 4 people to play a game. We plan on implementing more games in the future.
On a side note, development of this project tends to wax and wane with our motivation and amount of schoolwork.
Enhancements:
- Massive restructure of code into more object orientated patterns
- Added daemon capability to server
- Got rid of checksumming in the protocol since TCP/IP does it internally
- Padded STRINGS in the protocol on DWORD boundaries
- Added support for loadable account managers
- Removed crypting of the password by ocsd (account managers may do it)
- Added ODBC (for windows) and mySQL (for unix) account managers (database connectivity!!)
- Modified packet classes to throw exceptions instead of returning true-false
- Created packet manager classes to queue client packets, reduces total send calls
- Implemented bots when there arent enough people to play games
- Added new command line processing capabilities as well as configuration file support
- Fixed bug that allowed a person to overwrite an account when creating that same account
- Win32 - Made server link with DLL runtime library to reduce executable size and ease DLL dependencies
- Updated messages to be sent in HTML since the main clients support it
- Created Java client which can be run as an application or as an applet
- After a client is booted from a game, they cannot join the game again until they receive an invitation
- Fixed libtidy bug which caused it to erroneously format HTML
- Euchre supports intelligent bots
- Spades supports moronic bots (the AI is horrible but allows for gameplay)
- Fixed Spades textual problem when a round was over.
- Fixed Spades score calculation that resulted in no loss of points
- Win32 client now supports HTML (IE4+ required)
- Win32 client can now join games by right-clicking on an empty game slot in the game view.
- Fixed major bug in Win32 client that would cause it to crash when sending private messages
- Win32 client can now use /msg to send private messages

Sloth Online RPG is aJava Online RPG with Real-Time Action and rich 2D graphics.

Sloth Online RPG is a work in progress that will provide a fully graphical online role playing game engine. SlothORPG is coded in Java and is currently in a near playable state featuring several classes with over a thousand lines of code.

My main intentions with this project are to provide a free, fully functional, ever expanding Role Playing Engine (both client and server side) for the end user who would be playing the game. Developers would also be able to use the project as a resource on certain aspects of Java Game Programming.

Server side the project implements the NIO Networking library to create a smoother, stronger tcp/ip core. I found UDP and TCP w/ the old IO library to be unreliable and sluggish respectively. The way in which the server is structured has proven to be strong thus far.

The client side of the code features the Graphics2D Java library to provide near perfect animation without requiring a rendering device such as OpenGL or DirectX.

To summarize my entire intent for this project I basically wanted to provide an Online RPG that is functional on almost any OS that has Java installed and can run just as smooth on low end machines while still being able to feature rich 2-D graphics. The source code is clean and neat as well as commented and organized.

It is easy to read and understand for someone who has some knowledge of Java. As I write this, the project is coming along nicely and some pre-alpha local network testing has proven this. I plan to continue with this project and in the future include database integration and more of a developer-side interface.

A quick rundown of what this project includes so far: Character Creation, Smooth character animation, and fully supported tcp/ip gameplay. Chatting is also implemented.

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

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.