Free battlestar galactica beyond the red line software for linux

Snoopy vs. the Red Baron is an open-source one/two player combat game, available for Mac OS X, Linux, BeOS, QNX and Windows.
The original Snoopy was a tiny game for the Apple Macintosh, with black and white graphics, but already almost all the levels of the new Snoopy/SDL were implemented.
Snoopy could be played by two opponents, sharing a single screen and keyboard, and although it had poor graphics and tough controls, we very much liked to play it.
While we learned programming, we constantly sought for simple, yet interesting projects. If you have ever tried to learn a new language or API, you will have recognized that the simplest way in mastering the stuff is simply reprogramming an existing application, without losing much thought on design and originality.
So my friend reprogrammed Snoopy, in Object Pascal, using SAT, the Sprite Animation Toolkit, on his Classic II. That version of Snoopy features a fully functional AI, network play, but only the first level ( weapons drop).
While he was at it, he also implemented a "missing feature", the bombs, for which there where graphics and sounds in the game, but which could not be thrown.
When I discovered SDL, I recognized that it would be ideal for the job. Running on Windows, Linux, MacOS, BeOS and many other platforms, it is my new toolkit of choice for multimedia programming. It took us several weeks to port Snoopy (besides going to school, but now the work is almost done, with only the finishing touches to be made.
I can only encourage everyone to try SDL; it is really easy and portable (if worked right).

Variable::Strongly::Typed is a Perl module to let some variables be strongly typed.

SYNOPSIS

use Variable::Strongly::Typed;
my $int :TYPE(int); # must have an int value
my $float :TYPE(float); # must have a float value
my $string :TYPE(string); # must not be a reference
my $file :TYPE(IO::File); # must be an IO::File
my @array_of_ints :TYPE(int); # Each slot must contain
# an int
my %hash_of_floats :TYPE(float); # Each value must be a float

my $int_own_error :TYPE(int, &my_own_error_handler);
# Roll my own error handler

my @array_of_rgb :TYPE(&red_green_blue); # my enumerated type

# For subs!!
sub return_an_int :TYPE(int) {
# .. do some stuff ..
return $something;
}

# ... and later ...

$int = 23; # All is well
$int = howdy!; # This line will croak with a good error message

$float = 3.23; # All is well, nothing to see here
$float = new XML::Parser; # croak!

$array_of_ints[23] = 44; # Groovy
$array_of_ints[12] = yah; # croak!

$hash_of_floats{pi} = 3.14159; # no problem
$hash_of_floats{e} = new IO::File; # croak!

# Return 1 if this val is RED, BLUE, or GREEN
# 0 otherwise
sub red_green_blue {
local $_ = shift;

/A RED z/xms || /A BLUE z/xms || /A GREEN z/xms;
}

$array_of_my_very_own_types[23] = 99; # croak!
$array_of_my_very_own_types[2] = BLUE; # OK!

$int_own_error = lksdklwe; # The sub my_own_error_hanlder
# will be # called with the
# offending value

my $got_it = return_an_int(); # Will croak (or call your error
# function) # if this sub doesnt
# return an int

This modules allow you to strongly type your variables. Also known as the no fun module - it can greatly enhance you codes quality and robustness.

By enforcing types on some (or all) of your variables you will eliminate a large class of careless (& not so careless) errors.

This could also aid an editor or code-browsing tools to verify code correctness without having to execute the script.

STX B+ Tree project is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree.
The tree algorithms are based on the implementation in Cormen, Leiserson and Rivests Introduction into Algorithms, Jan Janninks paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementations correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments btree.h.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster.
Enhancements:
- This release introduces the demonstration program wxBTreeDemo.
- This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes.
- It allows the user to select different types of B+ tree instantiations: integer or string keys and different slot numbers.
- The user may insert and erase key/data pairs from the tree and run different search operations.
- The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows, and Mac OS X.

The poster plug-in is a Gimp plug-in that combines image layers by attaching them in rows and columns. This is useful especially for films.

The plug-in attaches the layers of a RGB or grayscale image row by row from the left to the right. The frames are separated by lines of selectable width in the current foreground color. If the row/column matrix is too small for all layers, the last layers are skipped. If the row/column matrix is too huge for the layers, additional slots are filled with the current background color.

Now, how does this look like???

Lets take the well-known high-speed film of an oscillating cavitation bubble... For a better visibility we choose a red foreground and a blue background color and select "< Image >/Filters/Animation/Poster" afterwards.

EZ Red Skin Fix is a script-fu based on a technique by lylejk of dpreview.com that can be used to improve skin that has a reddish tint.

Convert::Wiki::Node::Line is a Perl module that represents a horizontal line (aka ruler).

SYNOPSIS

use Convert::Wiki::Node::Line;

my $hr = Convert::Wiki::Node::Line->new( );

print $hr->as_wiki();

A Convert::Wiki::Node::Line represents a horizontal line (aka ruler).