Free game of skate software for linux

Games::Mastermind is a simple framework for MasterMind games.

SYNOPSIS

use Games::Mastermind;

# the classic game
$mm = Games::Mastermind->new;

# make a guess
$marks = $game->play(qw( Y C W R ));

# results
print "You win!n" if $marks->[0] == $mm->holes();

# the game history is available at all times
$history = $mm->history();
$last_turn = $mm->history()->[-1];

# reset the game
$mm->reset();

Games::Mastermind is a very simple framework for running Mastermind games.

Golly project is an open source, cross-platform Game of Life simulator currently under development by Andrew Trevorrow and Tomas Rokicki.
Our goal is to write a world-class Life simulator, solicit ideas and help from the planets best Life hackers, and share some of our excitement.
Main features:
- Unbounded universe (limited only by memory).
- Fast, memory-efficient conventional algorithm.
- Super fast hashing algorithm for highly regular patterns.
- Responsive even while generating or garbage collecting.
- Reads RLE, Life 1.05/1.06, and macrocell formats.
- Can paste in patterns from the clipboard.
- Auto fit option keeps patterns sized to the window.
- Full screen option (no menu/status/tool/scroll bars).
- Built-in HTML help system (thanks to wxWidgets).
Enhancements:
- The X11 version of Golly has a number of bugs and limitations, so use the GTK version if you can (it requires GTK+ 2.x).
- If you want to build Golly from the source distribution then to avoid various bugs use wxGTK 2.7 or later.

Games::Othello is a Perl extension for modelling a game of Othello.

SYNOPSIS

use Games::Othello;

my $game = Games::Othello->new();

while( !game->over ) {
printf "It is presently %ss move",
($game->whos_move eq b) ? black, white;
my @possible_moves = values $game->possible_moves();

if ( ! @possible_moves ) {
print "You have no moves available, you must pass.
$game->pass_to_opponent;
} else {
foreach ( my $move ) @possible_moves ) {
printf
"You will take %d of your opponents chips if you place your chip on %d,%d",
scalar @{ $move->{chips} }, $move->{x}, $move->{y};
}
my ($locx, $locy) = get_move();
my $flipped = $game->place_chip( $locx, $locy );
}

my $layout = $game->chip_layout();
foreach my $row ( @$layout ) {
foreach my $pos ( @$row ) {
printf %3s,
($pos eq b) ? B # Black occupied square.
: ($pos eq w) ? W # White occupied square.
: # Un-occupied square.
}
print "nn";
}
}
my ($black_score, $white_score) = $game->score;

Game::Life - Plays Conways Game of Life.

SYNOPSIS

use Game::Life;
my $game = new Game::Life( 20 );
my $starting = [
[ 1, 1, 1 ],
[ 1, 0, 0 ],
[ 0, 1, 0 ]
];

$game->place_points( 10, 10, $starting );
for (1..20) {
my $grid = $game->get_grid();
foreach ( @$grid ) {
print map { $_ ? X : . } @$_;
print "n";
}
print "nn";
$game->process();
}

Conways Game of Life is a basic example of finding living patterns in rather basic rulesets (see NOTES). The Game of Life takes place on a 2-D rectangular grid, with each grid point being either alive or dead. If a living grid point has 2 or 3 neighbors within the surrounding 8 points, the point will remain alive in the next generation; any fewer or more will kill it. A dead grid point will become alive if there are exactly 3 living neighbors to it. With these simple rules, fascinating structures such as gliders that move across the grid, glider guns that generate these gliders, XOR gates, and others have been found.

This module simply provides a way to simulate the Game of Life in Perl.

In terms of coordinate systems as used in place_points, toggle_point and other functions, the first coodinate is the vertical direction, 0 being the top of the board, and the second is the horizontal direaction, 0 being the left side of the board. Thus, toggling the point of (3,2) will switch the state of the point in the 4th row and 3rd column.

The edges of the board are currently set as "flat"; cells on the edge do not have any neighbors, and thus will fall off the board. Future versions may allow for warp edges (if a cell moves off the left side it reappears on the right side).

Web of Life is a life simulation game.

An isometric game done with C++ and SDL.

In this game you control some beings in an ecosystem, the goal is to make only that the beings you control survive.

Your beings should survive fighting with other beings, reproducting to make a massive attack and eating.
But sometimes you will have to eat some of your own live beings so that others could stay alive, well its life.

Pizza Game project is a 3D, real-time game in which you manage a pizza restaurant.
As manager, you must build a restaurant, buy the various objects and furniture that the restaurant requires, hire/fire/manage your employees, buy advertising, buy ingredients, set prices, and make sure your restaurant keeps your customers happy.
You start out with nothing more than an empty lot and a loan. Will you transform that lot into a thriving pizza business or fail to attract customers and watch your debt pile up?
Main features:
- Build your restaurant by placing walls, putting in doorways, installing windows.
- Decorate your restaurant by choosing from numerous paint colors and wallpaper designs.
- Put in tiles for your floors by choosing from a large selection of colors and designs.
- Buy the items and objects that your restaurant needs: tables, chairs, ovens, lights, and various miscellaneous objects that can make your restaurant the pizza parlor of choice for customers.
- Hire (and fire) the right employees that will perform the necessary tasks for running a pizza restaurant.
- Manage advertising for your pizza business.
- Buy the necessary ingredients for making pizzas and selling money-making side orders.
- Choose the opening and closing times for your restaurant in order to have your restaurant operate most efficiently.
Linux users: if you downloaded the binary version, and get an error when attempting to run the game that is related to Plugin_GuiElements.so, perform the following steps to remedy it:
1) create an OGRE subdirectory in /usr/lib
2) copy the Plugin_GuiElements.so in the libs subdirectory in the pizzagame directory to the OGRE subdirectory you just created

Games::Goban is a board for playing go, renju, othello, etc.

SYNOPSIS

use Games::Goban;
my $board = new Games::Goban (
size => 19,
game => "go",
white => "Seigen, Go",
black => "Minoru, Kitani",
referee => &Games::Goban::Rules::Go,
);

$board->move("pd"); $board->move("dd");
print $board->as_sgf;

This is a generic module for handling goban-based board games. Theoretically, it can be used to handle many of the other games which can use Smart Game Format (SGF) but I want to keep it reasonably restricted in order to keep it simple.

Games::Poker::TexasHoldem is an abstract state in a Holdem game.

SYNOPSIS

use Games::Poker::TexasHoldem;
my $game = Games::Poker::TexasHoldem->new(
players => [
{ name => "lathos", bankroll => 500 },
{ name => "MarcBeth", bankroll => 500 },
{ name => "Hectate", bankroll => 500 },
{ name => "RichardIII", bankroll => 500 },
],
button => "Hectate",
bet => 10,
limit => 50
);
$game->blinds; # Puts in both small and large blinds
print $game->pot; # 15

$game->call; # Hecate puts in 10
$game->bet_raise(15) # RichardIII sees the 10, raises another 5
...

This represents a game of Texas Holdem poker. It maintains the state of the pot, whos in to what amount, whos folded, what the bankrolls look like, and so on. Its meant to be used in conjunction with Games::Poker::OPP, but can be used stand-alone as well for analysis.