Free falling software for linux

Falling Up its another tetris clone. No, Im not trying to make any money off of it or claim it as particularly unique. It is fun. Try it. Its evil. Im told that frequently.
People have even praised it. I wrote it as a precursor to other games, a way to learn new technologies (GLUT, OpenGL, OpenAL, NSIS, ...), and to brush up on old ones (c, for that matter).
The source code is essentially free to do with as you please, if you like. If you "steal" most of it, Id prefer you give credit back to here, but really... whatever. I learned from lots of places and anything I can do to pay that back is cool.
The game is... tetris. You have the same old blocks, and they fall down. You use left and right to move blocks left and right, up to rotate, down to move down a line, and spacebar to drop.
Theres a next item (optional), sound (optional), and... stuff like that. Please, just download it and play it already! Geeze! Youd think I was just rambling...
Enhancements:
- The score file was adding 1 to the "level" the score was attained at every time a new high score was made, give or take; that is fixed.
- I added a background image (doesnt work with trails, may slow down on slower systems), and made F4 quit out of playing the game.

FallingWords is a simple QT game that can help anyone to improve his/her typing skill.

The goal of the game is to type the falling words before they touch the bottom of the screen.

According to the difficulty you choose, words will fall at different speed.

The score is calculated according to the selected skill.

KBall is a game of skill and reflexes, non violent, suitable for all ages.
The idea is to move a ball around the map, without falling, without running out of time, and getting the prizes, in order to reach the exit.
The map has different traps, such as slides, pushers, jumps, falls, walls, etc.
Maps are viewed from top view, and the walls and players ball are real-time rendered in beautiful 3D.
Main features:
- Is 100% non-violent FUN - Suitable for ALL ages.
- Also, a easy to use, full map editor included! You can do your OWN maps!!!
- Available with cross-platform support for DOS, Windows, Unix, Linux, BeOS, QNX and MacOS systems.
- Source code also available (under open source license)
- Made in C++, using Allegro game library and other open source tools.
Enhancements:
- New speech sounds for game over and won screen.
- Fixed some engine bugs.
- New levels.
- Removed the "demo" message.
- Entering final stage of release.
- F11 key toggles show or not fps.
- New Windows installer.

Mountn Fall is a free Java board game.

Religion is a Perl module that can generate tracebacks and create and install die() and warn() handlers.

This is a second go at a module to simplify installing die() and warn() handlers, and to make such handlers easier to write and control.

For most people, this just means that if use use Religion; then youll get noticably better error reporting from warn() and die(). This is especially useful if you are using eval().

Religion provides four classes, WarnHandler, DieHandler, WarnPreHandler, and DiePreHandler, that when you construct them return closures that can be stored in variables that in turn get invoked by $SIG{__DIE__} and $SIG{__WARN__}. Note that if Religion is in use, you should not modify $SIG{__DIE__} or $SIG{__WARN__}, unless you are careful about invoking chaining to the old handler.

Religion also provides a TraceBack function, which is used by a DieHandler after you die() to give a better handle on the current scope of your situation, and provide information about where you were, which might influence where you want to go next, either returning back to where you were, or going on to the very last. [Sorry - Ed.]

See below for usage and examples.

USAGE

DieHandler SUB

Invoke like this:

$Die::Handler = new DieHandler sub {
#...
};

where #... contains your handler code. Your handler will receive the following arguments:

$message, $full_message, $level, $eval,
$iline, $ifile, $oline, $ofile, $oscope

$message is the message provided to die(). Note that the default addition of " at FILE line LINE.n" will have been stripped off if it was present. If you want to add such a message back on, feel free to do so with $iline and $ifile.

$full_message) is the message with a scope message added on if there was no newline at the end of $message. Currently, this is not the original message that die() tacked on, but something along the lines of " at line 3 of the eval at line 4 of Foo.pln".

$eval is non-zero if the die() was invoked inside an eval.

The rest of the arguments are explained in the source for Religion::TraceBack. Yes, I need to document these, but not just now, for they are a pain to explain.
Whenever you install a DieHandler, it will automatically store the current value of $Die::Handler so it can chain to it. If you want to install a handler only temporarily, use local().

If your handler returns data using return or by falling off the end, then the items returns will be used to fill back in the argument list, and the next handler in the chain, if any, will be invoked. Dont fall off the end if you dont want to change the error message.

If your handler exits using last, then no further handlers will be invoked, and the program will die immediatly.

If your handler exits using next, then the next handler in the chain will be invoked directly, without giving you a chance to change its arguments as you could if you used return.

If your handler invokes die(), then die() will proceed as if no handlers were installed. If you are inside an eval, then it will exit to the scope enclosing the eval, otherwise it will exit the program.

WarnHandler SUB

Invoke like this:

$Warn::Handler = new WarnHandler sub {
#...
};

For the rest of its explanation, see DieHandler, and subsitute warn() for die(). Note that once the last DieHandler completes (or last is invoked) then execution will return to the code that invoked warn().

DiePreHandler SUB

Invoke like this:

$Die::PreHandler = new DiePreHandler sub {
#...
};

This works identically to $Die::Handler, except that it forms a separate chain that is invoked before the DieHandler chain. Since you can use last to abort all the handlers and die immediately, or change the messages or scope details, this can be useful for modifying data that all future handlers will see, or to dispose of some messages from further handling.

This is even more useful in $Warn::PreHandler, since you can just throw away warnings that you know arent needed.

WarnPreHandler SUB

Invoke like this:

$Warn::PreHandler = new WarnPreHandler sub {
#...
};

This works identically to $Warn::Handler, except that it forms a separate chain that is invoked before the WarnHandler chain. Since you can use last to abort all the handlers and return to the program, or change the messages or scope details, this can be useful for modifying data that all future handlers will see, or to dispose of some messages.

This is very useful, since you can just throw away warnings that you know arent needed.

libevnet library provides a suite of interfaces, all built around libevent [http://www.monkey.org/~provos/libevent] , useful to network daemons.
bufio.h: Non-blocking line and block buffered I/O routines, providing tail recursive behavior so callers cannot overflow their stack with multiple back-to-back I/O issues (i.e. attempting unbounded recursive I/O operations before falling into the event loop).
This feature preserves the natural way to code in an asychronous manner by safeguarding against certain types of pathological behavior and malicious attacks.
socket.h: Asychronous accept(2) and connect(2), supporting IPv4, IPv6 and Unix Domain sockets transparently. Also supports encapsulated host address lookups for "one-shot" connection handling with automatic fallback (for MX and SRV hosts).
tls.h: OpenSSL interface which plugs into the buffered I/O API in bufio.h and socket.h API.
thread.h: Threading implementation for running "blocking" routines asychronously. Run a function in a separate thread, and have the return value collected and passed back asynchronously to the original caller.
lookup.h: Comprehensive DNS resolver with a dead simple interface. Supports PTR, A, AAAA, CNAME, NS, MX, TXT, SOA and SRV records, as well as "compound queries".
A lookup of A+AAAA+SRV first queries the SRV records, sorts them, then resolves each SRV host to an A and/or AAAA host (with a configurable CNAME chaining limit). The response is a linked list of lookup structures, beginning with an SRV record, associated A/AAAA sockaddr structures, the next SRV record, and so on. A+MX has similar behavior. This feature actually reduces network traffic, since most of the time the initial DNS query response contains all the necessary information in the additional section.
DNS SRV records are compliantly sorted according to RFC 2782 [http://rfc-ref.org/RFC-TEXTS/2782/]
Enhancements:
- The platform compatibility library was refactored.

wxSand is a Falling Sand Game is a particle toy - you can play with different elements, explore how they interact, and, in some reimplementations, make your own elements.

It is great fun to make interactive structures, ecosystems, and toys in a Falling Sand Game.

First of all, mad props go out to the original creator of this game. Great idea. I only wish I could read Japanese... Heres a link to the original, or at least as close to the original as I can find (Again, without knowing how to read Japanese.)
http://ishi.blog2.fc2.com/blog-entry-158.html

Having wasted hours of productivity on the Java verison of the Falling Sand Game, I began to think of improvements that could be made from the original. No source was available for the original, and Java isnt my choice programming language, that I decided to start de novo with C/C++ and the cross-platform wxWidgets.

(I leave it to you Java fans out there to make your own improved Falling Sand Game.)

I tend to feel that The Falling Sand Game should be more of a Zen experience than anything else. I also belive that the game should be as cyclic as possible, so that environments can run and evolve for long periods of time. Finally, I realized the close connection of The Sand Game with the game of Life: Whereby, with a few very simple rules, and some starting conditions, you can create a very unpredictable outcome.
Of course, the original is pretty sweet. So Ive make a version with my own rules, and one with the original rules, and then one with the original rules plus some neat extra items. I have implemented many, many more interactions and elements than the original version. Discover them as you play.

Version 2 has no fire (Versions 3 & 4 do, though.) I dont like how easy it is to destroy everything. It also doesnt have any free-moving characters. I feel they distract attention from the evolution of the field.

Originally, I didnt want to make this Open Source. I think it takes away from the mysticism of the game. Those of you that are so inclined should be able to see the simple algorithm. Note the close connection with the game of Life. Also note the impossible situations, like unequalized water levels. These arent shortcomings of the game, but instead interesting artifacts of the rules of this alternate reality!

Epiphany project is a multiplatform clone of the game Boulderdash.

It is written entirely in C++, using Clanlib as its graphic library.

The player must collect all valuable minerals scattered in levels, while avoiding being hit by a falling boulder or a bomb.