Free global thermonuclear war software for linux

Global Assassin is a text-based action game.

The Global Assassin game is a multiplayer, shoot-em-up game set in the first person, and yet its text-based.

The year is 2035, and robots have taken over the Earth. Most humans died during the invasion or were forced to flee the planet. You are part of a small resistance that has managed to survive underground and is now prepared to strike back.

As a trained assassin, your objective is to return to the Earths surface, stealthily move through the worlds major cities, and systematically rid the planet of its invaders.

The details of the game are as follows.

The battlefield consists of 20 cities around the globe.

These cities have been connected for your mission by an ellaborate portal system.

Use the portals to move between cities as you search for and destroy the robots.

You are armed with a gun, bullets, and grenades.

To successfully strike an invader, you and your target must occupy the same city at the precise moment you attack.

You can lay a mine in a given city, and the very next player to enter that city trips the mine.

You remain alive as long as you have health points.

Over time, you automatically earn back health points, bullets, and grenades.

This is a multiplayer game. You may or may not be the only assassin on the planet!

MySQL Global User Variables UDF is a MySQL extension to store persistent variables.

This shared library adds simple user functions to MySQL in order to keep persistent shared variables in memory. These variables and their values are available to all clients. Any data can be stored into these persistent variables, including BLOBs. Since updates are atomic and way faster than MEMORY tables, this is an easy and efficient way to handle counters and sequences.

Usage:

Storing a value

An unlimited number of user variables can be created, as long as memory is available.
The GLOBAL_STORE(, ) stores a new shared global variable.

Examples:

mysql> DO GLOBAL_STORE("online_users", 42);
mysql> DO GLOBAL_STORE("secret_key", "pajfUyfnd");

The GLOBAL_STORE() function always returns 1 unless an error occurred.

Fetching a value

Reading the value of a variable is the job of the GLOBAL_GET() function.
The value is returned, or NULL is the variable is undefined.

Example:

mysql> SELECT GLOBAL_GET("online_users;);
42

mysql> SELECT id FROM pxs WHERE secret_key = GLOBAL_GET("secret_key");
1

Atomic increments

A single function call can read the previous value, add an integer (that can be negative), and store the new value into the variable.

The function is GLOBAL_ADD(, ) and the return value is the new value of the variable.
Updates are always atomic, if the old value is 18 and you add 1, you will always get back 19.

Example:

mysql> DO GLOBAL_ADD("online_users", 1);
mysql> SELECT GLOBAL_ADD("online_users", -4);
39

If the value of a variable was a string, the new value is the increment:

mysql> SELECT GLOBAL_ADD("secret_key", 12);
12

Adding a value to an undefined variable returns NULL.
A handy variant is GLOBAL_ADDP(, ). GLOBAL_ADDP() is similar to GLOBAL_ADD() but returns the PREVIOUS value of the variable instead of the new one.

Example:

mysql> DO GLOBAL_SET("xxx", 10);
mysql> SELECT GLOBAL_ADDP("xxx", 1);
10
mysql> SELECT GLOBAL_ADDP("xxx", 1);
11

Installation:

On most systems, compiling and installing the library should be as simple as typing (as root):

make install

The shared library is installed as /usr/local/lib/udf_global_user_variables.so

If the base directory of your MySQL installation is not in /usr/local, just type:

make

and then copy udf_global_user_variables.so to the right location for UDFs on your system (maybe /usr/lib/).

The name of a variable is limited to 256 bytes. If that limit is too low for your specific application, just edit the MAX_NAME_LENGTH variable on top of the .c file and reinstall. Variable names can contain binary characters.

Values are limited to 65536 bytes. If that limit is too low for you, edit the MAX_VALUE_LENGTH variable and reinstall.

Global Javadoc Viewer is a tiny application that allows you to conveniently browse multiple Javadoc sets simultaneously, using a single packages/classes hierarchy tree.

Global Javadoc Viewer pre-alfa version is not configurable, but useful, it allows to browse the next javadoc API sets:

- From the Internet: j2se 1.5, j2ee 1.4, hibernate and some others.
- From the local filesystem, in a UN*X box: all javadoc sets installed to the /usr/share/javadoc/ directory

AstroMenace project is a modern 3D scrolling space shooter with ship upgrade possibilities. You can improve your ship configuration by installing new weapons, defensive systems, power stations and much more.

To improve your ship, you must earn money by destroying throngs of enemies on every level. A friendly interface, easy controls, and fancy 3D graphics will bring you straight into the heart of galactic war. Enjoy!

AJAX Tree Control is a modified version of SilverStripes tree control. It adds dynamic loading of child nodes via AJAX.

The default implementation uses the prototype library to make dynamic requests, but this behavior can be overridden by setting functions on the global Tree object.

There are a few demo Ruby on Rails applications included in the distribution that show how to use and customize the tree.

Libircservice provides an event-driven API to develop IRC services working from a pseudo-server connection.
The library provides functions so that the developer does not need to care about the inter-server protocol and can keep the focus on the service programming logic.
Enhancements:
- This release adds timer stats, global messaging, and channel mode lock functions.
- The samples have been updated to compile with the latest API changes, and several bugs have been fixed.

vars::global is a Perl module that tries to make global variables a little safer.

SYNOPSIS

# In the place/package where we want to create globals
use vars::global create => qw( $foo @bar %baz );

# Add some more global symbols
vars::global->create(qw( $hello @world %now ));

# Somewhere else, where we need to access those globals
use vars::global qw( $foo @bar %baz );

# Dont try to use globals that do not exist
use vars::global qw( $Foo ); # typo, croaks
use vars::global qw( @inexistent ); # we dont create by default
# use create as above

# You can also import and create new globals
use vars::global qw( $foo %baz ), create => qw( $hey @joe );

# If youre lazy, you can import all the globals defined so far
use vars::global :all;

This module lets you define global variables and gain a slight advantage over blind use of package variables.

The global variables live inside the vars::global package, with the names given by the user. Where the advantage? Its two-fold:

there is an import mechanism that lets you access the global variable without the need to fully qualify its name (i.e. using $foo instead of $vars::global::foo);
the import mechanism ensures that you can import only the global variables that have been explicitly declared so far, which reduces the possibility of a typo.
If you have already "created" the global variable $foo, the import operation is equivalent to do:
*{__PACKAGE__ . ::foo} = $vars::global::foo;
that is, the package variable in the current package is made an alias for the global variable.

The anti-typo check is simply obtained by doing a check before the above import.
Typical usage is as follows:

creation

Early in the module or in the program you create variables prepending the create word, as follows:

use vars::global create => qw( $foo @bar %baz );

access

In the modules where you need to access a given global variable, you can import them very simply:

use vars::global qw( $foo %baz ); # I dont need @bar here ;)

The creation step above automatically imports all the new globals into the current package.