Free global warming 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!

Global Village project is a gnome application designed to place a front-end, or graphical user interface onto the CLI interface of Xplanet, by Hari Nair.
Originally intended to create and update the desktop wallpaper in a gnome environment, showing a traditional rectangular projection of the planet Earth, the scope of the project has been expanded. Global Village now provides as many of the features of Xplanet as seem reasonable, and with the ability for plugins the scope is nearly limitless. But do take it with a grain of salt...
Current Status
Currently, Global Village is barely functional. It can be considered in the pre-alpha stage of development.
It can currently show a preview of the final image, and then display that image on the desktop at user specified intervals (in seconds), and has an icon in the notification area of the Gnome panel.
Plugins are semi-working, but undergoing a lot of change as I decide what they do adn dont need to be capable of. The idea is that plugins will manage all the extra features users require, like cloudmaps, marker and arc files.
Main features:
- Select a planet.
- Select a projection.
- Bodys North Type.
- Rotate the bodys North Pole
- The Zoom level
- The Suns glare
- Latitude and Longitude, which can be set as:
- North Pole
- South Pole
- Equator
- Random Latitude and Longitude
- Or any number of user configerable locations.

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.

Devel::FindGlobals is a Perl module to find global variables and their size.

SYNOPSIS

use Devel::FindGlobals;
print print_globals_sizes();

This module just runs around and over the symbol table, finds global variables, gets their sizes with Devel::Size, and then prints them out.

find_globals() just finds the globals (and returns a hashref), and find_globals_sizes() returns the globals and the sizes in a hashref. print_globals_sizes() prints out that data in a pretty table.

find_globals() hashref is of the form $hash->{TYPE}{NAME}, where TYPE is SCALAR, ARRAY, HASH (types stored in @Devel::FindGlobals::TYPES).

find_globals_sizes() hashref is the same, except that the value of the record is not 1 but an arrayref of size and total_size (size is the size of the variable itself, and total_size counts up all the other members of the variable, for arrayrefs and hashrefs).

print_globals_sizes() accepts an OPTIONS hash. Currently recognized options are:

ignore_files

Ignore file globals (like $main::_
ignore_undef_scalars

Ignore scalars that exist, but are not defined. Default value is true.

exclude_match

An arrayref of strings to match; e.g., [^VERSION$, ^Debug]. Will not print variables matching any of the expressions.

include_match

Same as exclude_match, except for variables to exclusively include, instead of strings to exclude.

lexicals

A hashref of name = reference> for lexical variables to include in the report.

Eureka Encryption Global Edition contains file encryption, multiple encryption, merge encryption, multiple file encryption, embedded applications (Crypt Words, Steganographer, Interface) and other tools such as a file shredder and scrambler.

Eureka Encryption Global Edition is available for Windows, Mac and Linux. Other applications are available from the website.

GlobMoeSt means Global Motion eStimation.

Currently, the program works by determining the global motion vectors between each two subsequent frames via an exhaustive search within a specified motion search range, which can tweaked depending on the input data.

Nonlinear motion is supported. Motion vectors can be saved to a file, allowing for speedier tinkering with options (like construction mode or cropping of input frames), after a first pass.

The image difference function can use different color spaces (RGB and YUV) and can be influenced via user supplied coefficients, which allows the user to assign different weightings to different color components.

After determining the best motion vectors, the image is assembled, using one of currently three modes, one of which tries to avoid any intra-frame motion, while another one blends areas in which frames overlap.

The blending mode is able to reduce (film or compression) noise (especially for animated content, when there is little to no intra-frame motion, but only global motion), and can give a (blurry) impression of movement in case of intra-frame motion (which may, or may not be wanted). It can also be used to blend pictures, without using the motion estimation component.

beware project is a distributed global server load balancing system.

beware is a small DNS server that can have nameserver responsibility delegated to it and that can return a set of authoritative "IN A" records to a client.

Given a list of hosts for a certain domain name, it also tests for services specified and will only return IP addresses for currently reachable services.

JSignal is a loose port of the signal system implemented by GTKs GLib. JSignal project uses signals and handlers to allow for the registration of callback functions to events.
To use JSignal those classes which will emit signals (cause events) must register the signals that each class will emit. Note that if a class extends another class (has a superclass) it will inherit any signals registered by the parent class and can emit those signals as well. In addition a new global-type of signal can be registered which is class non-specific. Any class can emit a global signal.
After you have a class with registered signals you can begin connecting callback functions to those signals. Callback functions are connected (registered to listen for) to signals by specifying the signal and the object instance that will emit that signal; this registration results in the creation of a handler.
Multiple handlers can be configured for the same signal on the same object instance. In addition to instance-specific signal handlers a handler can also be registered to execute when a global signal (created using j_signal_new_global) is emitted; again, regardless of emitting instance. Note that when a global signal is emitted by an instance those handlers that are registered globally (using j_signal_handler_connect_global) will be executed BEFORE any instance-specific handlers.
To emit a signal - thus causing an event - the class which registered the signal should use the j_signal_emit function and pass any additional information to the callback function via the event detail argument. This detail object should be an array of name => value pairs.
Illustrative examples are provided below.
Note: In order for signal inheritance to work properly it is recommended that a classs prototype be given a parent member which points to the constructor of the classs superclass.
Main features:
- Multiple Handlers per Event
Multiple callback functions can be registered per signal per object instance.
- Signal Inheritance
The signals registered by an objects superclass are inherited by any extending child classes.
- Ordered Handler Execution
Like the DOM event handling system all handlers set to fire in response to a particular event fire in the order they were registered.
- Chained Handler Execution
Also like the DOM event handling model, when a handler returns a value of false any subsequent handlers will NOT be executed.
- Temporary Handler Blocking
Handlers can have blocks placed against them cumulatively; allowing for the selectively temporary disabling of handlers.
- Global Signals
Signals (as used in GLib) are class-specific. A signal registered under the class type of Integer can only be emitted by Integer instances. A global signal (registered using j_signal_new_global) can be emitted by any and all instances regardless of their class. This is essentially equivelant to registering a signal using the Javascript Object class type.
- Global Handlers
As signals are traditionally class specific it follows that handlers are instance specific. However global signals can be handled by both instance-specific handlers AND global handlers. A global handler is executed whenever a global signal is emitted, regardless of the emitting instance and its class type. Note that global handlers are executed BEFORE instance-specific handlers.