Free f prototype software for linux

Open Space Shooter is a simple 2D space shooter like asteorids.

Just a small spaceship, some Asteorids and some enemies. You got lasers and rockets and try to fight the enemy ships, not more.

It is simple but funny.

All is just a prototyp of a game I want to write later. But I have no time at the moment...

Class::Prototyped::Mixin Perl module contains Mixin Support for Class::Prototyped.

SYNOPSIS

Usage one: whip up a class and toss it in a scalar
package HelloWorld;

sub hello {
my ($self, $age) = @_;
return "Hello World! I am $age years old"
}


package HelloWorld::Uppercase;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
uc $ret
}
);


package HelloWorld::Bold;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
"< b >$ret< /b >";
}
);


package HelloWorld::Italic;
use base qw(Class::Prototyped);

__PACKAGE__->reflect->addSlot(
[qw(hello superable)] => sub {
my $self = shift;
my $ret = $self->reflect->super(hello, @_);
"< i >$ret< /i >";
}
);

# script.pl - now the whipping begins
use Class::Prototyped::Mixin qw(mixin);
my $runtime = mixin(
HelloWorld => HelloWorld::Uppercase, HelloWorld::Italic
);

print $runtime->hello(74);
< i >HELLO WORLD! I AM 74 YEARS OLD< /i >
Usage two: create hierarchy and install in a Class::Prototyped package
package CompileTime;
use Class::Prototyped::Mixin qw(mixin);

my $uclass = mixin(
HelloWorld => HelloWorld::Uppercase, HelloWorld::Bold
);

__PACKAGE__->reflect->addSlot(
* => $uclass
);


# script.pl
use CompileTime;

print CompileTime->hello(88);
< b >HELLO WORLD! I AM 88 YEARS OLD< /b >

Freebooters project is a "Pirates!" clone based on SDL.
Freebooters is a strategy/action game set in the Caribbean Sea during the golden age of piracy.
It is based on the game mechanics of Sid Meiers "Pirates!", but is not an exact clone and uses neither code nor copyrighted material from the original.
The Caribbean Sea in the late 16th century: The Dutch, French, English and Spanish crown aim to expand their areas of influence.
You as an suspicious young captain are trying to make the best of it, as you may either become a brave merchant soul, a freebooting hero of your crown or a bloodlusty dreaded pirate leader.
Freebooters will hopefully become a free clone of the Sid Meier classic Pirates!. Its written in C++ using SDL and licensed under the GNU General Public License.
Main features:
- Gameplay:
- Some of the crucial game mechanisms already work, but they need to be improved a lot, both with regard to features (refine the mechanisms, simulate more realistically) and to playability (how hard is a game, do certain features make sense at all?)
- Several core elements are missing (e.g. fencing duels with other captains, attacking a harbour from the seaside)
- Therell be a lot more harbours all over the Caribbean Sea
- Most game data is bogus (such as features of the ships, harbours, history etc.) and has to be replaced with realistic ones
- Therell be a career mode and a mission mode
- Tech:
- The current menus are mostly prototypes, theyll be replaced with clickable images maps, which are yet to be raytraced. However, the game will always be comfortably playable with the keyboard only.
- The current selection of targets on the map is a prototype as well. It will be replaced with a navigatable sea map as in the original game. There is already a demo world as a separate binary called seapassagedemo. For the 0.3 release this will be integrated along with the full map data.
- Lots of tuning and other improvements are needed
- Multiplayer capabilities over IP will be tackled once the game is properly in shape for single player games and the game mechanisms are fully established
- This is an item for the very far future, for a foreseeable timeframe Freebooters will be singleplayer only like the original.

Prothon is a new dynamic object-oriented language that improves upon the excellent language Python. While not compatible with Python, Prothon is close enough for Python code to be easily ported to Prothon.

Over time the Python language has been enhanced while maintaining compatibility with earlier versions. This process has resulted in complex features such as the metaclass. Even Python experts admit that metaclasses are brain-achingly complex.

Also, Pythons existing codebase has kept it from taking full advantage of its own new features such as iterators, generators, and properties. Pythons creator and other Python experts also have a laundry list of features in Python that they wish could be changed. Prothon, by breaking compatibility with Python, is able to fix most of these problems in a clean, fresh new start.

Prothon is built upon the more flexible foundation of Prototypes rather than the classes of Python, while still fully supporting classes. This allows other object paradigms than classes to be used like acquisition and maybe even aspects.

Prothon is built on top of .Net from Microsoft and the compatible Mono from Novell (for Linux). This stable architecture has an unmatched runtime library available. .Net also allows Prothon to interoperate with many other languages and tools.

Generic Protocol Framework aims to allow users to rapidly prototype different emerging communications protocols. Implementations can be easily "dropped in" and tested independant of a finished product. Testing on both the end product, and the protocol itself can be easily accomplished. The tool aims to provide the developer and end user with a robust solution which can track the size of messages, how rapidly they will be generated, and how many of each type can be seen.
Why the GPF:
There are many similar tools available. The problem with many of these tools is that they are 1) closed source, 2) not easily adaptable to a specific implementation (they use custom languages), 3) expensive. The advantages of the GPF are its open source nature, the ease of which it can be adapted, and the cost: free!
Basic Flow:
Modification of the GPF is fairly simple. Tool-opts.h contains the basic options that will be applied to the packet while it is being built. To transmit a packet, the system calls the tx_message() function, and passes the message ID as well as the option block. This is then passed to the custom function: tx_message_custom() in tx.c. From the message id, the system selects an appropriate tx_* function (to be implemented by the user) and passes an unsigned char **, where the buffer will be written, and the option block. In turn, that function will make heavy use of the add_buf_tu*() functions, which will allow the user to add a tubyte8, tuint16, or tuint32 number to the buffer.
In daemonize mode, the basic options are set, and the system then listens for incomming packets. When a packet arrives, the system calls basic_parse() on the packet. This function then calls basic_parse_custom(), found in parse.c. In turn, this can call any appropriate parsing helpers, including the get_tu*() functions, which allow the user to retrieve a tubyte8, tuint16, or tuint32 from the buffer. CAVEAT: if the first two bytes of the buffer are zerod, it will be treated as an END message. However, recovery is available. In the basic_parse_custom() message, you can set the end_signal_caught variable of the option_block to 0. In this case, it will not stop the daemon from running.
Enhancements:
- Currently, TCP support is somewhat experimental.
- Testing for that portion will be ongoing.
- No clear examples are provided.
- The examples/ directory contains the precursors to a MIP example.

DHCPsql projects implements the RFC2132 and at least RFC3046 as a dynamic configurable SQL-based DHCP server, based on the udhcpd code, extended to mask-and-select by client DHCP packets.
Targets:
- Discover, start with a working pre prototype, always send first ip in subnet
- Leases, SQL implementation should be done for storing and recieving leases. To send next free ip in subnet.
- Static leases, fixed leasetime
- Request, basics send ACK/NAK
- Webfrontend, initial frontend for viewing the database
Enhancements:
- This version of DHCPsql supports OPTION_LIST with OPTION_IP.
- This allows administrators to add multiple IP addresses to their DHCP options.
- This feature was lacking in the previous releases where only one IP address was allowed, and this limited the use of the nameserver field.

Teeter Torture project is a simple shooting game (similar to "Space Invaders", "Galaga" or "Galaxian"), but with a unique twist.

Your cannon is sitting atop a teeter totter. If it leans too far in either direction, a barrel of TNT explodes!

"Weight monsters" appear at the top of the screen, and randomly fall towards the teeter totter. If they attach to it, theyll weigh it down, making it more difficult to keep it balanced. (If they hit the cannon, it explodes and you lose a life.)

Note:This is New Breed Softwares rendition of a classic arcade game prototype of the same name, created in 1982 by Larry Hutcherson of Exidy.