Free marble blast ultra half pipe elite software for linux

Tiny Marbles provides persistence for dynamic objects, through a data model that you can create, modify and extend at runtime.

It is useful for developers who need to create rapid prototypes with an unknown model and developers of applications that have inherently dynamic data models. Tiny Marbles project runs under Java 1.5, supports any database that Hibernate supports.

Simple UDP proxy/pipe is an advanced UDP proxy/datapipe/packets forwarder and modifier with multiple functions.

Multiple clients allowed (you can connect many clients you want to this proxy), creation of ACP files (tcpdump capture files, just like a sniffer), packets forwarding (chat style, each packet is forwarded to all the other clients and server connected), packets injection (the tool opens a specific UDP port where you can send your customized packets which will be sent to the server), hexadecimal visualization and plugins support for the modification and visualization of the packets with some example plugins already included (Zdaemon huffman, Doom huffman, Half-life decoding and one for the replacement of the text strings).

Plugins (which work on both Windows and Linux) are very basic to create and use, just take a look at example_sudp.c for more informations.

Star Trek Voyager: Elite Force is a modification to the icculus.org maintained quake3 engine
to make it possible to run EliteForce holomatch. This means: you can *not* play single player missions with this project.
This engine has full compatibility for the newer _and_ the original EliteForce protocol, clients using the original engine can use newer servers, and clients using my engine can use old servers, too.

Now, the next few paragraphs are just some random blabla about the advantages of this release, but if you want to you can just skip it and go right to the installation instructions.

What was the motivation for me doing this project?

It actually started pretty small.. The Quake3 source has been released more than half a year ago and I got the crazy idea to try the quake3 engine with EliteForce on my trusted Gentoo Linux.

When I started the program first the screen went black and nothing happened... nearly nothing. I heard some sounds and when I moved the cursor I heard random click-clicks from the mouse going over some menu buttons. This meant this stuff is not completely incompatible after all, it didnt crash right away though that was exactly what I expected it to do. I digged in Ravens multiplayer source that they released (only the virtual machine stuff, to allow for building modifications) and compared it to quake3s virtual machines and realized that there was a small
incompatibility in one of the data structures used to pass information between engine and virtual machine. It was nothing big and after fixing this the menu worked!

There were some quirks here or there, but most of the menu really worked. So it got me thinking: If I fix all these incompatibilities.. maybe I can finally play my beloved multiplayer game Ive been clinging to for over 5 years on my favorite OS natively.. and IPv6 support for EliteForce would be pretty cool too...

So a crazy idea was turned into a serious project. I had to add support for Ravens models, playing mp3s, EliteForces own network protocol. My goal was to make this release as close to the original as possible. Most of the time, I only could guess what names and functions would mean to the engine or I had to compare the original game and then try to make it work the same way in my engine.

The quake3 game relies heavily on floating point operations. Unfortunately, the original EliteForce engine does non-ISO compliant rounding of floating point numbers to integers in the VMs. The game VM uses that flaw which will result in higher jumping for certain com_maxfps settings. As with the new engine there are many platforms that can be supported, there are probably many different ways one has to take to revert the rounding to the old behaviour. This is nearly impossible to do, so I had to use a different approach: build new VMs.

LMarbles is an Atomix clone with a slight change in concept. Instead of assembling molecules you create figures out of marbles. Nevertheless, the basic game play is the same: If a marble starts to move it will not stop until it hits a wall or another marble.

To make it more interesting there are obstacles like one-way streets, crumbling walls and portals.

As Marbles is meant as a puzzle game you play against a move limit and not a time limit. This way you have as much time as you need to think.

Marbles is a simple board game. The objective is to take out as big groups of marbles as possible. Highscore system included. Ive also programmed some simple physics to make it look like the marbles fall.

If you hold the mouse over a cluster of marbles for a little while, then the potential score will show. You get bonuses if you remove eg. all the blue ones.

Installation:

./configure && make

su

./install_marbles.sh

exit

(Dont use "make install", if you did do a "make uninstall")

Start it by typing:

marbles

Its not programmed in QT, but it works in KDE.

Current record:

25960 points
- Held by a friend. Dont think anyone will beat that in a while:)

Platform Independent Petri Net Editor project (PIPE) creates and analyses Petri Nets quickly, efficiently, and effectively.

A key design feature is the modular approach adopted for analysis, enabling new modules to be written easily and powerfully, using built-in data layer methods for standard calculations.

Six analysis modules are provided, including Invariant Analysis, State-Space Analysis (deadlock, etc.), and Simulation Analysis and Classification.

PIPE adheres to the XML Petri net standard (PNML). The file format for saving and loading Petri Nets is extensible through the use of XSLT, the default being PNML.

Astro::Aladin::LowLevel is a Perl class designed to drive CDS Aladin Application.

SYNOPSIS

my $aladin = new Astro::Aladin::LowLevel( );

Drives the CDS Aladin Application through a anonymous pipe, expects the a copy of the standalone Aladin application to be installed locally and pointed to by the ALADIN_JAR environment variable.

REVISION

$Id: LowLevel.pm,v 1.2 2003/02/24 22:45:56 aa Exp $

METHODS

Constructor

new

Create a new instance from a hash of options

$aladin = new Astro::Aladin::LowLevel( );

returns a reference to an Aladin object.

Accessor Methods

close

Closes the anonymous pipe to the aladin application

$aladin->close();

it should be noted that if you DONT do this after finishing with the object youre going to have zombie Java VM hanging around eating up all your CPU. This is amougst the many reasons why you should use Astro::Aladin rather than Astro::Aladin::LowLevel to drive the Aladin Application.

reopen

Reopen the anonymous pipe to the aladin application

my $status = $aladin->reopen()

returns undef if the pipe if defined and (presumably) already active.

status

Prints out the status of the current stack.

$aladin->status()

sync

Waits until all planes are ready

$aladin->sync()

export

Export a plane to a file

$aladin->sync( $plane_number, $filename )

get

Gets images and catalogues from the server

$aladin->get( $server, @args, $object, $radius );
$aladin->get( $server, $object );

For example

$aladin->get( "aladin", ["DSS1"], $object_name, $radius );
$aladin->get( "aladin", ["DSS1", "LOW"], $object_name, $radius );
$aladin->get( "aladin", [""], $object_name, $radius );

the radius arguement can be omitted

$aladin->get( "aladin", ["DSS1"], $object_name );

or even more simply

$aladin->get( "simbad", $object_name );

always remember to sync after a series of request, or you might end up closing Aladin before its actually finished download the layers.