Free robin williams software for linux

ctrlxmms XMMS plugin is a small Perl script designed to increase the useability of XMMS. With it, you can use most of the common GUI functions of XMMS from the CLI.

You also have a few handy commands which are not available from the GUI. Together with lirc and a remote (eg. Anir Multimedia Magic), this is a wonderful tool.

zOGI project is the ZideStore OpenGroupware Interface.
zOGIs mission is to provide a clean and consistent XML-RPC API to the full suite of OpenGroupwares collaberation services.
Main features:
The initial focus is to support tasks and projects.
- These are the weakest sections of the older official XML-RPC.
- Surpasses functionality and performance of the older XML-RPC API.
- TODO Support BLOB retrieval (via URL?)
- TODO Support storing BLOBS (?)
The secondary focus is to support calendaring / scheduling functions,
- Conflicts are reported
- Access hints provided to client
- Permissions can be modified
- Participants can be modified
- Notes can be created, edited, and deleted
- TODO Still needs support for accept/decline
- TODO Still needs some proposal mechanism (very low priority)
The tertiary focus is to support contact management.
- As of r408 addresses and phone numbers can be put to the server.
- As of r411 contacts and enterprises can be created, edited, and deleted.
- As of r419 contacts and enterprise assignments are stored.
- TODO Assignment of contacts and enterprises to projects
The primary consumer of zOGI support is the Consonance groupware client.

Games::Tournament::RoundRobin is a Perl module for Round-Robin Tournament Schedule Pairings.

SYNOPSIS

$schedule = Games::Tournament::RoundRobin->new;

$pairings = $schedule->indexesInRound($roundm);
$round = $schedule->meeting($member1, [$member2, $member3]);
...

Every member of a league of 2n players can be paired with every other member in 2n-1 rounds.

If the league members are (Inf, 1 .. 2n-1), then in round i, i can be paired with Inf, and a can meet b, where a+b = 2i (mod 2n-1).

METHODS

new

Games::Tournament::RoundRobin->new( v => 5, league => [Ha, Be, He])
Games::Tournament::RoundRobin->new( league => {A => $a, B => $b, C => $c})
where v (optional) is the number of league members, and league (optional) is a list (or a hash) reference to the individual unique league members. One of v, or league (which takes precedence) is necessary, and if league is not given, the members are identified by the numbers 0 .. n-1.

If the league is a list (or hash) of n objects, they should be instances of a class that overloads both string quoting with a name method and arithmetical operations with an index method. The index method, called on the n objects in order, should return the n numbers, 0 .. n-1, and in that order if they are presented as an array. If they are presented as a hash, the hash is stored internally as an array and the keys are discarded.

If the league is a list of strings or numbers, indexes are constructed for the values on the basis of their positions in the list, and if a hash of strings or numbers, on the basis of the lexicographic order of their keys. Each string is expected to be unique.
If n is odd, an additional n-1, Bye or object (a Games::League::Member object, by default) member, depending on the type of the first member in the league, is added at the end and n is increased by 1.
indexesInRound

$schedule->indexesInRound($m)

Returns an array reference of the pairings in round $m. This method is useful if you are using numbers to represent your league members. It is not so useful if you are using strings or objects and you dont know their index numbers. Positions in the array represent members. The values represent their partners. Each member is thus represented twice.

roundsInTournament

$t = $schedule-> roundsInTournament;
$round1 = $t[0];
$inRound1FourthWith = $t->[0]->[3];
$inLastRoundLastWith = $$t[-1][-1];

Returns, as a reference to an array of arrays, the pairings in all rounds of the tournament. This method is useful if you are using the algorithm indexes.
partner

$schedule->partner($member, $m)

Returns the partner of $member in round $m.

membersInRound

$schedule->membersInRound($m)

Returns an hash reference of the pairings in round $m. This method is useful if you are using strings or objects. Keys in the hash represent league members. If the league members are objects, their names are used as keys. If 2 names are the same, the names are changed to $name.1, $name.2 etc. The values are their partners. Each player is thus represented twice.

memberSchedule

$schedule->memberSchedule($member)

Returns, as an array reference, the partners who $member is matched with in the order in which they meet, ie round by round.

meeting

$schedule->meeting($member,$partner)

Returns the rounds (TODO and the venue) at which $member meets $partner.

meetings

$schedule->meetings($member1,[$member2,$member3,...])

Returns, as an array reference, the rounds (TODO and the venue) at which $member1 meets $member2, $member3, ...

index

$schedule->index($member)

Returns $members index, the number which is used to pair it with other members. The index is the position, 0..n-1, of the $member in the league argument to the constructor (if an array) or the constructed array (if a hash.)
If $member is not a member of the array, or is itself an index, undef is returned.

member

$schedule->member($index)
$schedule->member($name)
$bye = $schedule->member( $schedule->size-1 )

Returns the member represented by $index, a number which ranges from 0..n-1, or by $name, a string. If there is no such member, undef is returned.

partners

$schedule->partners($index)
$schedule->partners($name)

Returns an array reference of all the partners of the $indexed or $named member, in index order, or the order in the league argument.

realPartners

$schedule->realPartners($index)

Returns an array reference of all the partners of the $indexed member, excluding the Bye member. Dont use this if you have no Bye member, as it just leaves off the last member.

size

$schedule->size

Returns the number of members in the round robin. Sometimes this may not be the same as the number of league members specified, because the array of league members takes precedence if supplied, and a bye is added if the number is odd.

rounds

$schedule->rounds

Returns the number of rounds in the round robin. This equals the number of league members, minus 1.

fping is a ping like program which uses the Internet Control Message Protocol (ICMP) echo request to determine if a host is up. fping is different from ping in that you can specify any number of hosts on the command line, or specify a file containing the lists of hosts to ping.

Instead of trying one host until it timeouts or replies, fping will send out a ping packet and move on to the next host in a round-robin fashion.

If a host replies, it is noted and removed from the list of hosts to check. If a host does not respond within a certain time limit and/or retry limit it will be considered unreachable.

Unlike ping, fping is meant to be used in scripts and its output is easy to parse.

Problem and Issues:

With a large a number of IP addresses in use, its becomes more and more time consuming to check on which IP addresses are actively in use, and which critical machines (routers, bridges, servers, etc) are reachable. One example is we have a program which goes through all of our routers arp caches looking for IP addresses that are in use. After finding a list of IP addresses that arent in any arp caches fping can then be used to see if these IP addresses really arent being used, or are just behind the routers. Checking 2500 hosts (99% of which are unreachable) via ping can take hours.

fping was written to solve the problem of pinging N number of hosts in an efficient manner. By sending out pings in a round-robin fashion and checking on responses as they come in at random, a large number of hosts can be checked at once.

Unlike ping, fping is meant to be used in scripts and its output is easy to parse.

FreeNX Server project is the Free and GPLd NX server implementation by Fabian Franz, based on NoMachine.coms NX technology.
NoMachine have thankfully licensed the core of NX under the GPL (they provide a close-source commercial NX server product on top of that code, as well as professional support).
FreeNX is a set of Bash scripts (about 3000 lines of code altogether) and comes with no support other than that which you may or may not gain by participating in this mailing list.
For FreeNX to work, you not only need the FreeNX scripts, but you also need the compiled NX sources from NoMachine.com installed. (Linux-Distributions are starting to offer their own pre-compiled packages now).
kNX is the initial KDE NX Client implementation, that was written as a "proof-of-concept" within 2 half days of hacking during LinuxTag 2004.
FreeNX and kNX strife to stay compatible and inter-operable with NoMachines commercial NX products. We aim to let NoMachines (free-as-in-beer) NX Client to work with FreeNX server as well as let the kNX Client access any commercial NoMachine server product (Personal, SmallOffice and Enterprise Servers).
Some versions of FreeNX and kNX are "snapshot" releases for respective 1.5.x snapshots by NoMachine, and are not expected to run with any other NX version from NoMachine.
Enhancements:
- Support for NX client and backend versions 2.0.0 and 2.1.0 was implemented.
- "Round-robin" and "load" load balancing algorithms were added.
- Many significant fixes were made.

Boulderdash (BD4) is an X Client for online action/strategy game with global high scores and players.

The game is called BD4. It is a version of Boulderdash which is played online using central player records and global high scores.

Versions exist for UNIX/X, Windows (Win32) and Java.
The game has over 100 levels and allows teamwork mode. Offline play, level editor and new level sets now supported. Over 2 million games played worldwide so far.

Refer to the web page for full documentation, a list of current players, global high scores, news and information and much more. http://bd4.amristar.com.au/

File::Copy::Link is a Perl extension for replacing a link by a copy of the linked file.

SYNOPSIS

use File::Copy::Link;
copylink file.lnk;

use File::Copy::Link qw(safecopylink);
safecopylink file.lnk;

copylink

reads the filename linked to by the argument and replaced the link with a copy of the file. It opens a filehandle to read from the link, deletes the link, and then copies the filehandle back to the link.

safecopylink

does the same as copylink but without the open-and-delete manouvre. Instead, it uses File::Spec::Link to find the target of the link and copies from there.

This module is mostly a wrapper round File::Spec::Link::linked and File::Copy::copy, the functionality is available in a command line script copylink.