Free island software for linux

Set::IntSpan::Island is a Perl extension for Set::IntSpan to handle islands and covers.

SYNOPSIS

use Set::IntSpan::Island

# inherits normal behaviour from Set::IntSpan
$set = Set::IntSpan::Island->new( $set_spec );
# special two-value input creates a range a-b
$set = Set::IntSpan::Island->new( $a,$b );

# equivalent to $set->cardinality($another_set)->size;
if ($set->overlap( $another_set )) { ... }

# negative if overlap, positive if no overlap
$distance = $set->distance( $another_set );

# remove islands shorter than $minlength
$set = $set->remove_short( $minlength );

# fill holes up to $maxholesize
$set = $set->fill( $maxholesize );

# return a set composed of islands of $set that overlap $another_set
$set = $set->find_island( $another_set );

# return a set comopsed of the nearest non-overlapping island(s) to $another_set
$set = $set->nearest_island( $another_set );

# construct a list of covers by exhaustively intersecting all sets
@covers = Set::IntSpan::Island->extract_cover( { id1=>$set1, id2=>set2, ... } );
for $cover (@covers) {
($coverset,@ids) = ($cover->[0], @{$cover->[1]});
print "cover",$coverset->run_list,"contains sets",join(",",@ids);
}

This module extends the Set::IntSpan module by Steve McDougall. It implementing methods that are specific to islands and covers. Set::IntSpan::Island inherits from Set::IntSpan.

Terminology

An integer set, as represented by Set::IntSpan, is a collection of islands (or spans) on the integer line

...-----xxxx----xxxxxxxx---xxxxxxxx---xx---x----....

Islands are disjoint and contiguous, by definition, and may be represented by their own Set::IntSpan object. Regions not in the set that fall between adjacent spans are termed holes. For example, the integer set above is composed of 5 islands and 4 holes. The two infinite regions on either side of the set are not counted as holes within the context of this module.

METHODS

$set = Set::IntSpan::Island->new( $set_spec )

Constructs a set using the set specification as supported by Set::IntSpan.

$set = Set::IntSpan::Island->new( $a, $b )

Extension to Set::IntSpan new method, this double-argument version creates a set formed by the range a-b. This is equivalent to

$set = Set::IntSpan::Island->new("$a-$b")

but permits initialization from a list instead of a string.

$set_copy = $set->duplicate()

Creates a copy of $set.

$overlap_amount = $set->overlap( $another_set );

Returns the size of intersection of two sets. Equivalent to

$set->intersect( $another_set )->size;

$d = $set->distance( $another_set )

Returns the distance between sets, measured as follows. If the sets overlap, then the distance is negative and given by

$d = - $set->overlap( $another_set )

If the sets do not overlap, $d is positive and given by the distance on the integer line between the two closest islands of the sets.

$d = $set->sets()

Returns all spans in $set as Set::IntSpan::Island objects. This method overrides the sets method in Set::IntSpan in order to return sets as Set::IntSpan::Island objects.

$set = $set->excise( $minlength )

Removes all islands within $set smaller than $minlength.

$set = $set->fill( $maxlength )

Fills in all holes in $set smaller than $maxlength.

$set = $set->find_islands( $integer )

Returns a set containing the island in $set containing $integer. If $integer is not in $set, an empty set is returned.

$set = $set->find_islands( $another_set )

Returns a set containing all islands in $set intersecting $another_set. If $set and $another_set have an empty intersection, an empty set is returned.

$set = $set->nearest_island( $integer )

Returns the nearest island(s) in $set that contains, but does not overlap with, $integer. If $integer lies exactly between two islands, then the returned set contains these two islands.

$set = $set->nearest_island( $another_set );

Returns the nearest island(s) in $set that intersects, but does not overlap with, $another_set. If $another_set lies exactly between two islands, then the returned set contains these two islands.

$cover_data = Set::IntSpan::Island->extract_covers( $set_hash_ref )

Given a $set_hash reference

{ id1=>$set1, id2=>$set2, ..., idn=>$setn}

where $setj is a finite Set::IntSpan::Island object and idj is a unique key, extract_covers performs an exhaustive intersection of all sets and returns a list of all covers and set memberships. For example, given the id/runlist combination

a 10-15
b 12
c 14-20
d 25

The covers are

10-11 a
12 a b
13 a
14-15 a c
16-20 c
21-24 -
25 d

The cover data is returned as an array reference and its structure is

[ [ $cover_set1, [ id11, id12, id13, ... ] ],
[ $cover_set2, [ id21, id22, id23, ... ] ],
...
]

If a cover contains no elements, then its entry is

[ $cover_set, [ ] ]

$island = $set->num_islands

Returns the number of islands in the set.

$island = $set->at_island( $island_index )

Returns the island indexed by $island_index. Islands are 0-indexed. For a set with N islands, the first island (ordered left-to-right) has index 0 and the last island has index N-1.

If $island_index is negative, counting is done back from the last island (c.f. negative indexes of Perl arrays).

$island = $set->first_island

Returns the first island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the first island.

If the set is empty, returns undef.

$island = $set->last_island

Returns the last island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the last island.
If the set is empty, returns undef.

$island = $set->next_island

Advances the iterator forward by one island, and returns the next island. If the iterator is undefined (e.g. not previously set by first()), the first island is returned.
Returns undef if the set is empty or if no more islands are available.

$island = $set->prev_island

Reverses the iterator backward by one island, and returns the previous island. If the iterator is undefined (e.g. not previously set by last()), the last island is returned.

Returns undef if the set is empty or if no more islands are available.

$island = $set->current_island

Returns the island at the current iterator position.

Returns undef if the set is empty or if the iterator is not defined.

Perilar is a simple, fast computer role-playing game (CRPG), with an epic quest! You will cross a vast monster-infested wilderness to the dungeons to recover ancient weapons and artifacts, then to the dragons lairs, then face the final challenge...

Version 0.4 is a beta release for designing the gameplay, and future versions will have additional art, music, and sound effects.

Save Game Warning: Savefiles from previous versions will not be compatible with later versions until 1.0. At that point, Ill make sure they are always forward-compatible, but it hampers rapid development until then. Sorry for the trouble, but at least youll get to see the new world features in each version!

History

Over a thousand years ago, the world was a peaceful but primitive place. Humans lived in tribal societies, rarely warred, and there were few dangerous animals and no monsters. Your kingdom, Perilar, was one of the safest, as it was protected by four great dragons of Air, Earth, Fire, and Water.

Where the Vampire King came from, nobody knows. He appeared in the far north and turned peaceful farmers into berserker raiders. After conquering the island kingdom of Oradon, he turned their druids to necromancy, raising armies of the dead to war on the next kingdom. Kingdom after kingdom fell, and in each, the people were slain and raised as undead warriors to assault the next kingdom.

As the army of the undead approached Perilar, the dragons closed the kingdom off with a magical seal. For a thousand years, the kingdom has been trapped inside, and none know the fate of the outside world.

In recent times, the seals have begun to fail. The Dragons have not been seen in centuries. Undead and monsters march in towards the castle of King Phalan and the village of Perilar, home to the last free people in the world. A great hero must do something about this, and you are determined to be that hero!

libasyncns provides a C library for Linux/Unix for executing name service queries asynchronously. It is an asynchronous wrapper around getaddrinfo and getnameinfo from the libc.
In contrast to GNUs asynchronous name resolving API getaddrinfo_a(), libasyncns does not make use of UNIX signals for reporting completion of name queries. Instead, the API exports a standard UNIX file descriptor which may be integerated cleanly into custom main loops.
In contrast to asynchronous DNS resolving libraries like libdenise, skadns, adns, libasyncns is just an asynchronous wrapper around the libcs synchronous getaddrinfo() API,
which has the adva ntage of allowing name resolution using techniques like Multicast DNS, LDAP or NIS using standard libc NSS (Name Service Switch) modules.
libasyncns is compatible with IPv6 if the underlying libc is.
libasyncns is very tiny, consisting of just one header and one source file. It has no dependencies besides libc.
By default libasyncns spawns a number of worker threads (LWPs) to process name queries. Alternatively or when POSIX Threads are not supported, libasyncns can fork() off worker processes instead.
Installation:
As this package is made with the GNU autotools you should run ./configure inside the distribution directory for configuring the source tree. After that you should run make for compilation and make install (as root) for installation of libasyncns.
Enhancements:
- This version properly detects res_query() on Linux/AMD64 and supports older autoconf versions.

Thousand Parsec is a 4 Xs game (eXplore, eXpand, eXterminate, eXploit) but it is different in the sense that it is designed for long games supporting universes as large as your computer can handle. (Have a quad Xeon with 4 gig of ram? Well have a couple of million systems in your universe!.

Thousand Parsec also supports long term play with players joining and leaving throughout the game. As well the tech tree is easily expandable and can be extended during the game without effecting anybody already playing (ie introduction of new technology as the game progresses).

You can choose to have highly exotic universes where the laws of physics are totally different or universes that are very similar to our own.

The game is TURN BASED, this means that clicking quickly isnt vital but strategy is.

The game should also be highly extend-able. Allowing player customisation not found in the commercial games.

Anyway we have high hopes for what TP will become. We have currently stolen a lot of ideas from Stars!, VGA Planets an XPace.

SimpleMail is the easiest e-mail client there is! SimpleMail uses UAP (Unwanted Access Protection) exclusively to SimpleMail that automatically protects you from viruses in e-mails, malicious code in e-mails, and even pictures in spam that my be offensive in content. SimpleMail is compatible with many anti-virus programs, including:

Norton AntiVirus
McAfee VirusScan
Panda Tituanium AntiVirus
AVG AntiVirus (free and professional)
avast! AntiVirus (free and professional)

Normally, you can disable your e-mail protection in your anti-virus, because the UAP technology built in eliminates the need to keep the e-mail protection on.

Ogrian Carpet project is a 3D fantasy action/strategy game.
Ogrian Carpet is an outdoor first person shooter game with real time strategy elements, inspired by the game Magic Carpet.
It uses Ogre3D as the renderer and allows you to fly around an island casting spells, summoning monsters, collecting mana, and building castles.
The object of the game is to build a castle, collect mana, and destroy your enemies. To build a castle, select a location, look at the ground, and cast the build spell. Note, you cannot build castles very close to water or other castles.
Your castle starts out small, with only one turret. As more mana is added to your castle, it will gain more turrets. Each turret adds another crane to your castles defense and another spell to your arsenal.
Basically, the game consists of fighting for control of mana. Whenever you encounter another wizard, shoot them with fireballs. If you hit them enough, they will "die" and be sent back to their castle. You are then free to claim all the mana in the area for yourself.
Once all the mana has been claimed, attack your enemys castle to get mana out of it so you can claim it for yourself. Once you enemys castle is out of mana, you can eliminate it by killing its heart. When all of your opponents have been banished, youve won.
Enhancements:
- AI bot player for skirmish
- things can now be loaded from an image, rather then randomly
- option for old randomized maps
- trees can now always bee seen
- made castle mana drops aggregate more
- loosened the restrictions on summoning
- made the config menu better
- added victory conditions to skirmish: kill all enemy towers/castles
- made ticks and gnomes stay in the formation you put them in
- made monsters and towers drop less then their cost when they have no wizard
- made mana float higher
- made towers cheaper (50)
- made sentinels drop much less (3)
- changed speed behavior on lava maps
- added victory music
- new music

This tool uses multicast to find potential partners and TCP to actually "pair up" with them, meaning that both "sides" will know who their partner is. In addition, partners are given an "active" or "passive" designation which can be used to start client/server applications without further negotiation.

This tool is meant to be used from scripts that perform network benchmarking, automated software testing or similar activities.

Requirements:

• x86, x86_64 and alpha platforms running Linux 2.6