Free falling up 004 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.

Falling is a fast-paced survival game involving a ball falling through wooden planks.

Falling is a survival game where the user controls a small steel ball and tries to roll it through holes in floors which are constantly moving up.

Avoid being crushed between the top of the window and a floor, avoid mechanical sticks of TNT that explode on contact, and avoid magnetic balloons which pull you to the top of the screen.

Collect jewels for extra points. Try to survive as long as possible!

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.

V language is a tiny concatenative language implemented for experimentation.
The source is under Public Domain (un-copyrighted.)
The full featured language is on top of JVM, A native version (in alpha state) is also there in the codebase.
To run it, extract the distribution in any directory and do #gmake run.
gmake
gmake run
V
|
The language is a close relative of postscript, forth and joy. and is stack based. ie:
|2 3 *
=6
|2 3 * 5 +
=11
See status for a tutorial and more info.
The Functions available in V are available in this page: functions
(The releases are out of date and multiple fixes have gone in. Please check out and build rather than use them.)
Example functions in V. getting the roots (with out using the stack shuffling word view)
[quad-formula
[a b c] let
[minisub 0 b -].
[radical b b * 4 a * c * - sqrt].
[divisor 2 a *].
[root1 minisub radical + divisor /].
[root2 minisub radical - divisor /].
root1 root2
].
|2 4 -30 quad-formula ??
=(-5.0 3.0)
using view
[quad-root
[a b c : [0 b - b b * 4 a * c * - sqrt + 2 a * /]] view i
].
|2 4 -30 quad-root ??
=(3)
contrast this with the definition in scheme here
(define quadratic-formula
(lambda (a b c)
(let ([minusb (- 0 b)]
[radical (sqrt (- (* b b) (* 4 ( * a c))))]
[divisor (* 2 a)] )
let ([root1 (/ (+ minusb radical) divisor)]
[root2 (/ (- minusb radical) divisor)])
(cons root1 root2)))))
Definition of Qsort.
[qsort
#definitions
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
#args starts for binrec. notice that 2 arguments (termination condition
#and its result) are on first line.
[small?] []
[split_on_first_element]
#binrec recurses on the result of split_on_first_element before applying joinparts.
[joinparts]
binrec].
Some explanations.
The first and second lines (terminated by .) are internal function definitions
(Notice how qsort is also terminated by .) . is the definition syntax in V.
The first function joinparts
============================
The function joinpart contains just an application of the operator view.
view is list translator. It takes a list of the form [template : result]
then it tries to apply the template to the current stack. If it can be applied on the
stack, then the arguments named in the template are bound to values in stack. The result is then processed, and all the bound elements in result are replaced by their values.
[pivot [*list1] [*list2] : [*list1 pivot *list2]] view expects 3 arguments on the stack,
the first a single element pivot, then two lists list1 and list2.
It returns a list that is composed of elements of list1 followed by pivot
followed by elements of list2 (as defined in result - RHS of :).
ie:
44 [1 2 3] [5 6 7] [pivot [*list1] [*list2] : [*list1 pivot *list2]] view ??
=> [1 2 3 44 5 6 7]
(The function ?? is used to print out the elements in the stack now.)
The second function split_on_first_element
==========================================
The definition is [uncons [>] split&]
The uncons splits a list into the first element and the rest of the list.
ie:
[1 2 3 4 5] uncons ??
=1 [2 3 4 5]
split& takes two arguments, the first is the function F to split a list with,
and the second the list itself. All elements in the list that passes the function F
is put into the first list, and all that do not are put into the second list.
ie:
[1 2 3 4 5 6 7] [4 >] split& ??
=[5 6 7] [1 2 3 4]
The function F can also take an argument from the stack. so this also works.
4 [1 2 3 4 5 6 7] [>] split& ??
=[5 6 7] [1 2 3 4]
Thus the split_on_first_element takes the first element of a list, and split that
list based on that element as a filter.
binrec
=======
binrec expects 4 arguments,
Arg1 is the terminating condition,
Arg2 is the result if the terminating condition is met.
Arg3 is an executable statement that returns two entities.
The entire binrec statement is performed on each of the
two entities until the terminating condition is met.
Arg4 is what to do with the result of the previous statement.
Algorithm.
Here, the small? checks if the list is empty or contains just one element.
if it is, then the result is arg2 - []
ie:
[] small? ??
=true
[1] small? ??
=true
[1 2 3 4] small? ??
=false
split_on_first_element takes is executed on all lists that are larger than size 1
and as explained above, splits them into two based on the first element.
on the resultent lists, the entire qsort is performed again due to binrec.
The last joinparts takes these elements (pivot list1 list2) which are present now
on the stack, and combines them to produce a single sorted list.
A slightly friendlier function (with out the binrec.)
[qsort
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
[small?]
[]
[split_on_first_element [list1 list2 : [list1 qsort list2 qsort joinparts]] view i]
ifte].
The binrec and friends are more powerful than the explicit recursion done above, but for people new to concatenative languages, this kind of recursion may look more intuitive.
Enhancements:
- The language has become relatively stable.
- Lots of bugfixes were made in scope handling.
- Tree operations were added.
- Generic combinators were moved out into a separate library.

SDLjump is a clone of the Xjump game. Jump as long as you can!

SDLjump is a clone of the simple yet addictive game Xjump, adding new features like multiplaying, unlimited FPS, smooth floor falling, themable graphics etc...

The goal in this game is to jump to the next floor so you dont fall down. As you go upper in the Falling Tower the floors will fall faster.

Try to survive longer than anyone. It might seem too simple but once youve tried youll realize how addictive this is.

Enhancements

• Some bugs are fixed
• A menu is added

Requirements:

• Python
• Pygame

Dial-Up Bot project aims to be a fully functional automated replacement for the /etc/ppp/ip-{up,down}.d hierarchy. Its supposed to be started by cron at night. It cant satisfy the requirements of impatient roots. Its not designed for hosts with a permanent Internet connection.
Enhancements:
- This is the first public release since dubot reached minimal useful functionality and stability. Installation mech is minimally stable (at least for install in /usr/local hierarchy).

Conjury::C is a Perl Conjury with C/C++ compilers, linkers and archivers.

SYNOPSIS

c_object
Source => Isource-file>,
Directory => Idirectory>,
Includes => [ Idir1>, Idir2>, ... ],
Defines => { Ivar1> => Ival1>, Ivar2> => Ival2>, ... },
Compiler => I< compiler>,
Options => [ I< opt1>, I< opt2>, ... ],
Factors => [ I< factor1>, I< factor2>, ... ];

c_executable
Directory => I< directory>,
Name => I< output-filename>,
Order => [
Searches => [ I< dir1>, I< dir2>, ... ],
Objects => [ I< obj1>, I< obj2>, ... ],
Libraries => [ I< lib1>, I< lib2>, ...] ],
Linker => I< linker>,
Options => [ I< opt1>, I< opt2>, ... ],
Factors => [ I< factor1>, I< factors2>, ... ]

c_static_library
Directory => I< directory>,
Name => I< output-filename>,
Objects => [ I< obj1>, I< obj2>, ...],
Archiver => I< archiver>,
Options => [ I< opt1>, I< opt2>, ... ],
Factors => [ I< factor1>, I< factors2>, ... ]

c_compiler
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>,
Flag_Map => { I => I< include-flag>, D => I< define-flag>,
c => I< source-flag>, o => I< object-flag> },
Suffix_Rule => sub { my ($name) = @_; ... return $result },
Scanner => sub { my ($c_file, $args) = @_; ... return @result };

c_compiler Vendor => I< vendor>, ...

c_linker
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>,
Flag_Map => { l => I< link-flag>, L => I< search-flag>,
o => I< output-flag> },
Bind_Rule => sub { my ($lib, $bind) = @_;
... return @result },
Search_Rule => sub { my ($lib, $rule, $bind, @search) = @_;
... return @factors };

c_linker Vendor => I< vendor>, ...

c_archiver
Program => I< program>,
Options => [ I< opt1>, I< opt2>, ... ],
Journal => I< journal>,
Flag_Map => { r => I< replace-flag> };

c_archiver Vendor => I< vendor>, ...

Spells for compiling and linking C/C++ software are constructed using c_object, c_executable and c_static_library. The compiler, linker and archiver used in the resulting actions are the same compiler, linker and archiver that were used to build Perl itself, unless otherwise specified.

Specializations of the general classes of compiler, linker and archiver can be created using c_compiler, c_linker and c_archiver.