Free 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.

Gtk2::Ex::MindMapView::HotSpot::Grip::EllipseRound is a Perl module to manage a round grip type "hot spot" on a ellipse item. This grip differs from the standard grip with respect to where it is placed on the Gtk2::Ex::MindMapView::Item.

SYNOPSIS

use Gtk2::Ex::MindMapView::HotSpot::Grip::EllipseRound;

The Gtk2::Ex::MindMapView::HotSpot::Grip::EllipseRound is a round grip that may be used to resize a Gtk2::Ex::MindMapView::Border::Ellipse.

This special grip positions itself differently from the other grips.

INTERFACE

Properties

item (Gtk2::Ex::MindMapView::Item)

The item this grip is attached to.

enabled (boolean)

If enabled, this grip is ready for action.

side (string)

The side on which to attach the grip. May be left or right.

fill_color_gdk (Gtk2::Gdk::Color)

The color with which to fill in the hotspot.

outline_color_gdk (Gtk2::Gdk::Color)

The color with which to fill in the hotspot outline. Grips usually have the outline set to the same color as the item fill color.

hotspot_color_gdk (Gtk2::Gdk::Color)

The color of the hotspot once it is engaged. A hotspot becomes engaged when the mouse is placed close to it.

Methods

new (item=>$item)

Instantiates a Gtk2::Ex::MindMapView::HotSpot::Grip::EllipseRound hotspot.

hotspot_adjust_event_handler

Positions the grip at the lower left or right corner of the rectangle defined by the insets. This will change for the next release.

hotspot_get_image

Returns a circle (Gnome2::Canvas::Ellipse) as grip image.

Bralkomon is another system monitor Superkramba theme. It is based on Cynapses.

If you have a beautiful lady coming round, or maybe you just want to chill; put on some smooth jazz, put Bralkomon on your desktop, and let the good times roll.

Did I mention Bralkomon is scientifically designed to be the perfect accompaniment to smooth jazz? Oh yeah.

P.S. You might want to change the name of the network device. The .skz file is just a ZIP archive. Open it up, and edit the .theme file. Instructions lie within.

mod_cgi is an Apache module that turns a CGI program into a dynamically loaded library (.so) and runs it without forking. Gives the simplicity and portability of CGI without the overhead.

There is no documentation, beyond the source code comments. It will build cleanly with Apache 1.3b6+, and youll need some configuration: e.g.

AddHandler mod_ecgi .so

or

AddType x-embedded-cgi .so

As I said, see the source file.

Theres also a small harness for CGI programs, to get round the way many sloppy CGIs never return but call exit() instead. Its not absolutely necessary, but for most purposes youll want it.

Russian Mafia project is a multiplayer IRC game implementation of Russian Mafia.

Russian Mafia is a multiplayer IRC game implementation of the popular game, Russian Mafia, which is based on the Russian card game "MAFIA".

The peaceful civilians attempt to kill all the Mafia and maniacs, while the Mafia and maniacs attempt to kill all the civilians.

After the crush of the Soviet Union, Moscow was plunged into a mafia terror. Russian Goverment asking asking Italian parliament to send them the most talanted detective Commissar Katani, who keep in fear italian mafia Kosa Nostra. Katani arrives in Moscow and with civilians is trying to calm down the crime in the city.

This if fully atomatic game, on the over hande its very interesting and simple multiplayer game. All the game function processed by the IRC mafia bot, which also stores the statistic informations and game points, bank accounts.

The main goal in this game to win. Peaceful civilians have to find and kill all mafia men and maniac, or mafia men and maniac have to kill all civilians, Commissar Katani and other peaceful roles. This mean, peaceful roles have to guess who is bad and kill them - how they can kill them, look down.

Its a round game, with a stages. At the start of each round the mafia bot randomly distribute the roles. The round two stages - day and night, with are repeating until the one of the sides win or until the draw. During the night the roles make the commands, and during the day all players decide whom to kill because of the evidence or guessing, or to process without killing.

To start you have to type !reg during the round registration. After you just follow the mafia bot commands.

After the round registration you will receive a role.

During the night you will be asked about a order to the bot, concerning the role you have.

During the day you have to talk to other players to guess who is criminal, and making votes for the person to kill (codnamn to die).

After the vote the acused person will die. If no winners from civilians or mafia, the game starting again at night stage.

JSON::XS implements JSON (http://www.json.org) for Perl. Unlike other modules, its primary goal is to encode to syntactically correct JSON and flag invalid JSON while decoding.

It ensures round-trip integrity of datatypes while being intuitive to use. Currently being the fastest of the JSON encoders available for Perl, it supports a variety of format options, such as single-line, ASCII-only or pretty-printed and can be tuned for speed or memory usage.

The project comes with a wealth of documentation describing usage and implementation details.

AGATourn is a Perl extensions to ease the pain of using AGA tournament data files.

SYNOPSIS

use Games::Go::AGATourn;
my $agaTourn = Games::Go::AGATourn->new (options);

An AGATourn object represents a round or several rounds of an American Go Association tournament. There are methods for parsing several type of AGA file format:

tdlist

The entire list of AGA members including playing strength, club affiliation, and some other stuff.

register.tde

The starting point for a tournament. All players in a tournament must be entered in the register.tde file.

round results: 1.tde, 2.tde, etc.

Game results for each round of the tournament.

A note on IDs: in general, hashes in an AGATourn object are keyed by the AGA ID. An AGA ID consists of a three letter country specifier (like USA or TMP for temporary IDs) concatenated to an integer. Here we specify the three letter country specifier as the country and the integer part as the agaNum. The country concatenated with the agaNum is the ID. My ID for example is USA2122. IDs should be normalized (capitalize the country part and remove preceding 0s from the agaNum part) with the NormalizeID method (below).

Note also that some programs may accept limited integers in the agaNum part of the ID. Accelerat, for example, seems to accept only up to 32K (someone used a signed short somewhere?)