Free red robin software for linux

Red Hat Linux is probably the best-known Linux distribution. Red Hat Linux is well-supported by commercial software, and tends to be easy to install and have good hardware support out of the box.

Compaq has taken over the maintenance for Red Hat for their Alpha processor - theres a link to their Alpha Red Hat page below.

Red Hat 9 is the last version of Red Hat Linux per se, and Red Hat will stop supporting it soon. Instead they offer a commercial Linux distribution, "Red Hat Enterprise Edition", and a free distribution, "The Fedora Project".

Red Carpet is a software management tool for RPM-based Linux distros.

Red Carpet is a suite of applications that allows easy installation and update of software on Linux systems. Red Carpet project features both command-line and graphical GNOME interfaces.

These days Red Carpet is part of the Novell ZenWorks solution.

Beyond the Red Line project is a stand-alone total conversion for the award-winning Freespace 2 released by Volition and Interplay for the PC. It is based on the popular new tv-show Battlestar Galactica. No, not the one from the 70s.
Will I need Freespace 2 to play it?
No, Beyond the Red Line is a stand-alone conversion and will not require Freespace 2. All you need for playing will be included in the download.
Is it free?
Absolutely. The game is made by fans for the fans, no profit is being made from any part of the project. Although we could use some pizzas and coke to keep our mortal bodies running.
That about covers it... a BSG total conversion of FS2 that has just released a demo version. it plays really well and looks amazing. a must for any BSG fan.
Enhancements:
- This demo contains spoilers for the second season of BSG, so if you havent seen that season yet you should pass on this game for now.

libredblack is a library to provide the RedBlack balanced tree searching and sorting algorithm.

The algorithm was taken from the book "Introduction to Algorithms" by Cormen, Leiserson & Rivest. Frankly I never entirely understood it, but it most definately works!

What is the problem with normal binary trees?: A standard binary tree only works well if the original data is provided in a random order (random in terms of the key being sorted on). If however the data is provided in order, then the tree becomes very un-balanced and searches degrade into nothing more than a linked list.

How is the RedBlack tree different?: The RedBlack tree acts in a way to keep the overall tree fairly balanced as new data is loaded in.

How does it work?: The tree is always organised such that it has the following properties:

Every node is either Red or Black.

A leaf node (a dummy empty node at the end of the tree) is always Black.
If a node is Red then its children are Black.

Every path from the root to a leaf contains the same number of Black nodes.
So from 3 & 4 above, we can see that the longest path (alternating Red and Black nodes) is only twice as long as the shortest path (all Black nodes). Thus the tree remains fairly balanced.

Great! How does it maintain those properties?: Ah, well, thats where I get a bit hazy. I know that it does this by adding Red nodes and then rotating the tree elements and changing the colours to sort out times when two Red nodes become parent-child (breaking rule 3).

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.

AddTraction project is a SDL 2-player board game with numbers.

Two players ("red" and "green") take their turns on a 6x6 board. In the beginning, the board is empty except for a red "1" in the upper left and a green "1" in the lower right.

Taking a turn means setting one field of the board. Setting a field makes it assume the sum of the points of the 8 surrounding fields. But there is a catch: if the field is of the opponents color, their score is subtracted rather than added. If the resulting score is positive, the field will get your color, else your opponents color.

The same happens to the global score, which is just a colored difference of the score of all fields on the board. If the score in the end is red, red wins. If it is green, green wins. If it is black (0), it is a draw.

Hexxagon project is an Ataxx clone.
The goal of the game is to conquer as much of the board as possible, which is done by capturing the opponents pieces or by cloning your own.
The goal of the game is to get more pieces than your opponent before the board is full. The pieces can clone or jump. All the opponents pieces that lies next to a moved piece will become yours.
Game Rules:
- A piece (red) can be cloned to all empty cells (green) next to it.
- A piece (red) can jump to all empty cells (green) one cell away from it.
- Cloning or jumping next to one of your opponents pieces will capture it. Cloning the middle red piece in the picture to the empty green cell will result in the board represented in the second picture.