Free lost island software for linux

LOST island is a superb KDM theme featuring a LOST wallpaper.

Lost Labyrinth is a so-called "roguelike" RPG playing computer game.
Main features:
- relatively short gameplay (about 10-20 minutes)
- very high replayability; nearly everything in the game is randomly generated
- Sketelona lot of options during the character generation; each character type requires another strategy to survive
- game focus on exploration; killing monsters does not give an experience bonus (but makes fun nonetheless)
- Multiplayer games on the same machine (up to 3 players with keyboard, mouse and joystick)
- "Zelda"-like graphics, sound and animation; smooth scrolling of game screen
- FreeWare
Enhancements:
- You can pick up items with the mouse (the pointer changes when you can interact with something).
- You can scroll spells with the mouse (up/down buttons).
- A text entry bug (could enter only one character since the new compiler) has been fixed.
- German special letters and spells have been fixed.
- An issue where the trader left you one field to the right (in the wall sometimes) has been fixed.
- The borders of the credits and high score screens have been fixed.
- The language of the help screen has been fixed.
- A merchant will wait a while before buying/selling is possible.

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.

MovieSlave is a very simple cross-platform (Windows, Linux) movie manager.

MovieSlave project can automatically fetch movie details (tagline, runtime, rate, year, plot, director) from the IMDb.

From its clean user interface you can easily add, edit, delete and search for any title without being lost in useless options.

Ever lost an hour worth of writing an email due to a crashing browser? LiveSaver is a save-as-you-write mechanism for your browser written in Javascript.
It saves form input over browser and operation system crashes, power failures, and session timeouts. It is easy to add to any existing Web site. LiveSaver is particularly useful for blog software, Web mail systems, or any Web site that deals with user input.
Enhancements:
- A MediaWiki Extension was added that allows you to integrate LiveSaver in every MediaWiki installation very easily.
- Self-configuration was added to decrease installation issues.
- The API was simplified.
- Operability was tested with a suite of the latest browsers on Mac OS X and Windows.

PJSIP and PJMEDIA is the Open Source, high performance, small footprint SIP and media stack written in C language.
It has many SIP and media features such as a layered API, dialog usages, high level invite session abstraction, an event framework, SIP presence/SIMPLE, instant messaging, RTP/RTCP, a conference bridge, silence detection, PLC, and so on, as well as extensive documentation.
Enhancements:
- This release fixes a build error on MacOS, memory alignment problems on ARM, and a crash which occurred on STUN keep-alive when network connectivity was lost.

PHP::Strings is a Perl module to implement some of PHPs string functions.

SYNOPSIS

use PHP::Strings;

my $slashed = addcslashes( $not_escaped, $charlist );
my $wordcount = str_word_count( $string );
my @words = str_word_count( $string, 1 );
my %positions = str_word_count( $string, 2 );
my $clean = strip_tags( $html, );
my $unslashed = stripcslashes( abfnrxae );

PHP has many functions. This is one of the main problems with PHP.

People do, however, get used to said functions and when they come to a better designed language they get lost because they have to implement some of these somewhat vapid functions themselves.

So I wrote PHP::Strings. It implements most of the strings functions of PHP. Those it doesnt implement it describes how to do in native Perl.

Any function that would be silly to implement has not been and has been marked as such in this documentation. They will still be exportable, but if you attempt to use said function you will get an error telling you to read these docs.