Free round round software for linux

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.

Sunergos Blue is a simple Login Manager for Gnome.

Simple and clean, with nothing distribution specific, The sunergos gdm theme features round-cornered, semi-transparent box for logins, a semi-transparent round-cornered bar at the bottom for restarting or halting the system, and a semi-transparent round-cornered top bar displaying the hostname and time.

QMetronome is a skinnable metronome for Qt licenced under the GPL.
The qualitiy of the prepackaged skins are questionable but it is easy to make your own. I made this metronome when I was learning the rythms of Flamenco on the guitar.
Therefore, it has up to twelve beats per "bar" and clicks with accents.
Main features:
- Three click sounds: one, accent and ordinary. Configurable.
- Four to twelve beats per round.
- Timing precision only limited by your soundcard and drivers.
Version restrictions:
- All three click sounds must be in the same format (bits, hz, mono/stereo),
- otherwise strange things will happen. Will be fixed in the next version.

poink provides a TCP/IP-based ping tool.

poink is a TCP/IP-based ping implementation that does not require special privileges and is designed for multiuser shell systems. It is intended to be a secure replacement for the standard IPv4 network monitoring tool.

Not much to say... This is a nosuid, so quite secure, version of ping utility
for IPv4. It uses dirty trick - TCP linear SYN/RST challenge instead of
ICMP echo/echo reply. It wont allow any flood-pings (others than connect
flood you could achieve anyway), security compromises etc.

Currently, basic ping parameters are implemented (compatible with
original ping):

ping [ -i delay ] [ -c count ] [ -t timeout ] hostname

-i delay - delay between pings in seconds (default 1, min. 1)
-c count - number of packets to send (default: 0 - until break)
-t timeout - packet timeout in seconds (default: 4, min. 1)

NOTE: longer timeouts might result in slightly inaccurate results because of TCP/IP retransmits.

When finished or stopped with Ctrl+C (SIGINT), poink prints some statistics
about round-trip times, jest like the original ping does. Round-trip times
are displayed in miliseconds (1/1000 of second, ms), but unlike its setuid
counterpart, nosuid ping additionally displays time in microseconds
(1/1000000 of second, usec) if trip time is really low (well, I think that
more recent versions of ping are doing it now, too).

Currently, Linux is the only supported platform, but BSD port should
be really easy to develop.

xquarto project is a two-player board game based on logic.

Xquarto is a board game designed for the X windows environment. The game is a two-player game, although for the moment,it is only possible to play against the computer. The board is composed of 4x4 squares and 16 pieces. Each piece has four
properties: black or brown, horizontal or vertical, solid or hollow, round or square. This makes up 16 possible combinations and there is exactly one piece for each possibility.

Initially, the board is empty and it is successively filled with pieces. The game is over when a row, a column or a diagonal has four pieces carrying a common property in it, e.g. four black (brown) pieces, four square (round) pieces, four filled
(hollow) pieces, four horizontal (vertical) pieces. In the original quarto rules, the player who is the first to complete a row, column or diagonal as described above wins. This is the implicit mode under which xquarto runs. A variant of the game (tic rules) consists rather of avoiding alignments, i.e. the player who is forced to complete
an alignment loses.

The game is a two-player game. Player 1 chooses one of the 16 pieces. Player 2 then places this piece on one of the 16 squares of the board and chooses a piece out of the remaining 15 pieces which he gives to player 1, who places this piece on one of the remaining 15 squares on the board, etc...

Xquarto supports three different player combinations: human vs computer, computer vs human and human vs human (possibly through the local network in the latter case). The default combination is human vs computer, i.e. the human player starts the game against the computer. This can be changed by clicking on the "Actions" menu (see below for more details).

The rules are really very simple - believe me!

SDLPong project is a Pong clone.
SDLPong is a Pong clone that is intended to feel "authentic", while adding additional features to extend gameplay.
In other words, SDLPong is striving to be a purists pong.
For those of you with a more contemporary outlook, other features are in the planning stage. (These features will be toggable, for those who want to play a pure pong)
How to play:
Bounce the ball back and forth, not too hard.
For more options, type ./sdlpong --help
Enhancements:
- Added transparencies spport.
- Ball is now round!
- Started menu programming.
- Removed SDL_ttf support (now you have no excuse to try this tisaak).
- Fixed Player Twos controls for a qwerty keyboard.

Open Conference Systems or OCS for short, is a free Web publishing tool that will create a complete Web presence for your scholarly conference.
Main features:
- create a conference Web site
- compose and send a call for papers
- electronically accept paper and abstract submissions
- allow paper submitters to edit their work
- post conference proceedings and papers in a searchable format
- post, if you wish, the original data sets
- register participants
- integrate post-conference online discussions
Enhancements:
- manage conferences that occur more than once (e.g. yearly)
- an expanded, multiple-round review system
- e-mail template system
- localization & translation tools
- credit card payment for registrations
- automated "thanks-for-submitting" messages
- accept login/password for participants
- Creative Commons licensing of presentations
- more customizable, scalable and secure code
- ...and much more.