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;

Games::Bingo::Card is a helper class for Games::Bingo.

SYNOPSIS

use Games::Bingo::Card;

my $b = Games::Bingo-E new(90);
my $card = Games::Bingo::Card-E new($b);

my $bingo = Games::Bingo-E new(90);
$card-E validate($bingo);

use Games::Bingo::Print::Card;

my $p = Games::Bingo::Print::Card-E new();
$p-E populate();

The Games::Bingo::Card class suits the simple purpose of being able to generate bingo cards and validating whether they are valid in during a game where a player indicate victory.

It is also used by Games::Bingo::Print to hold the generated bingo cards before they are printed.

Games::Alak is a simple game-tree implementation of a gomoku-like game.

SYNOPSIS

% perl -MGames::Alak -e Games::Alak::play
...Or just run Alak.pm as if it were a program...
...Program responds with output, and a prompt:

Lookahead set to 3. I am X, you are O.
Enter h for help
X moves from 1 to 5, yielding .xxxx..oooo
alak>
...and now you enter the commands to play.

This module implements a simple game-tree system for the computer to play against the user in a game of Alak. You can just play the game for fun; or you can use this module as a starting point for understanding game trees (and implementing smarter strategy -- the modules current logic is fairly simple-minded), particularly after reading my Perl Journal #18 article on trees, which discusses this modules implementation of game trees as an example of general tree-shaped data structures.

Space Mines project is a game where one makes money by building mines.

Space Mines is a game where one needs to make money by building mines and by keeping ones workers happy.

INSTALLATION

make all
make install
make clean

USAGE

Build mines (but not too many) and create profits by selling the ore!

You need to pay your workers wages to keep them happy. Mining on other worlds is a dangerous business, and workers are at risk from exploding mines, radiation leaks, etc.

Limitations:

· There is very little error checking for if someone enters the wrong data type (like letters where there should be numbers).

Whats New in This Release:

· Decided to release it to the world
· Made it GPL
· Included some documentation

IGE - Outer Space is an on-line strategy game with SciFi theme.

IGE - Outer Space is an on-line strategy game which takes place in the dangerous universe. You must become the commander of many stars, planets, and great fleets and you will struggle for survival with other commanders.

Outer Space communicates with the server in the same way as your browser, but you will need a special client to play it. Using this client you can create an account on the server and you can start to explore the world of the Outer Space.

Space Commander is a game that aims to be similar to Elite and Privateer, with maybe a bit of Trade Wars thrown in.

The project is a remarkably functional space simulation with under 200 lines of code in the main file.

DEPENDENCIES

You need a recent version of Python and some support libraries. The game is currently being written using Python v 2.4.3 but it may work with newer or older versions with some minor tweaking. I intend to be using Python 2.5 and PyGame 1.8 shortly.

· Python 2.4.3
· PyGame 1.7
· Numeric 22.0

Basically you need a pretty complete Python kit. Most Linux distributions should have everything that you need and Windows / OSX users will be able to install it all with a small bit of effort.

To play the MIDI score in Linux you have to install and configure Timidity due to some old code in sdl-mixer which is a pre-dependency of PyGame. If the game crashes and
complains about midi, just comment out the MIDI line in spacecommander.py to disable it.

As to performance issues. I pass the buck. If it runs too slowly then get a faster computer, better graphics card, better operating system, whatever.

The idea of writing this in Python is to have a compromise between ultimate performance and the ability to understand and tinker around with the code.

You could try reducing the number of stars in the galaxy by editing bigbang.py also.

Feel free to re-write the game in hand optimized assembler, but you must send me a copy of your code per the LICENSE.

RUNNING THE GAME

Linux: ./spacecommander.py

KEYBOARD COMMANDS

ESC / Q: Quit the game
Left / Right: Yaw
Up / Down: Pitch
PgUp / PgDN: Roll

Whats New in This Release:

· The main engine was completely rewritten and now supports flying a spaceship around a randomly generated galaxy. 2D rendering of objects using PyGame is supported.
· Mouse flight control is featured.

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.

Crystal Space is a free and portable 3D Game Development Kit written in C++. It supports: true six degrees of freedom, colored lighting, lightmapped and stencil based lighting, shader support (CG, vertex programs, fragment programs, ...), mipmapping, portals, mirrors, alpha transparency, reflective surfaces, 3D sprites (frame based or with skeletal animation using cal3d animation library), procedural textures, particle systems, halos, volumetric fog, scripting (using Python, Perl, Java, or potentially other languages), 16-bit and 32-bit display support, OpenGL, and software renderer, font support (also with freetype), hierarchical transformations, physics plugin based on ODE, ... See the extensive list of features for more details.

Crystal Space currently runs on GNU/Linux, general Unix, Windows, Windows NT, and MacOS/X. It can optionally use OpenGL (on all platforms), SDL (all SDL platforms), X11 (Unix or GNU/Linux) and SVGALIB (GNU/Linux). It can also optionally use assembler routines using NASM and MMX.

Crystal Space is a large open source project. There are about 700 people subscribed to the Crystal Space mailing list.

The second important feature of Crystal Space is that it is written to run under a wide variety of hardware and software platforms. As of this writing Crystal Space has been known to run on the following systems. Note that if a system is listed here it does not necessarily mean that it is 100% supported:

· Windows (Windows 9x/NT/ME/2000/XP)
· Unix (Linux, FreeBSD, etc.)
· MacOS/X

Here are some key features of "Crystal Space":

· Geometric utility library with handy classes such as 2D and 3D vectors, matrices, transforms, quaternions, kdtree, axis aligned and oriented bounding box routines, rectangle subdivision, etc. See section 6.3 Geometry Library (csGeom).
· General utility library with stuff like templated arrays, smart pointer, hashmap, object registry, plugin manager, radix sort, bit array, optimized allocators, strings, etc. See section 6.1 Utility Library (csUtil).
· Higher level tool library containing things like some example procedural textures (plasma, fire, and water), full screen effects, collider support, texture generation tools, etc.
· Graphics library with simple utilities to do mipmapping, color quantization, calculation of color gradients, simple bumpmapping, etc.
· 2D and 3D polygons
· Shared Class Facility SCF. See section 6.2 Shared Class Facility (SCF). See section 5.1 Developing a Crystal Space Application.
· Smart Pointers. See section 5.8.1 Correctly Using Smart Pointers.
· Flexible plug-in system. See section 6.2 Shared Class Facility (SCF). See section 5.8.20 Create Your Own Plugin.
· Virtual file system and transparent support for ZIP files. See section 7.2 Virtual File System (VFS).
· Configuration files. See section 3.2 Configuration File.
· Command-line parsing. See section 5.1 Developing a Crystal Space Application.
· Event system.
· Full screen effects (fading, whiteout, etc).
· Procedural textures. See section 7.3.1 Procedural Texture System. See section 7.5.6 Texture Mapping.
· Level of Detail. See section 7.5.11 Level of Detail.
· Animated 3D models (3D sprites). See section 7.9 Animation.
· 2D animations.
· Quake MD3 and MDL to Crystal Space convertor. See section 5.6 md32spr Tutorial.
· The `sprcal3d plugin is able to load Cal3D models. See section 7.7.6 SpriteCal3D Mesh Object.
· Crystal Space native windowing system(s). See section 7.11 Alternate Windowing System (AWS). See section 6.4 Crystal Space Windowing System (CSWS).
· 2D canvases (OpenGL, DirectDraw, X11, CoreGraphics, Cocoa, null, memory)
· 3D renderers (OpenGL, software, null). See section 7.3 Graphics Drivers.
· Playing AVI streams (DivX 4, OpenDivX) on a texture.
· Various image loaders (BMP, GIF, JPG, PNG, SGI, TGA, WAL).
· Portals and sectors. See section 7.5.2 Portal Engine.
· Lighting: static, pseudo-dynamic, dynamic, halos, shadows, stencil shadows. See section 7.5.3 Lighting. See section 5.8.9 Pseudo-dynamic Lights.
· Bezier curves.
· Visibility culling based on kd-tree with coverage buffers (Dynavis). See section 7.5.7 Visibility Culling In Detail.
· Multiple cameras. See section 5.8.7 Camera Movement.
· Textures, materials, and shaders. See section 7.5.6 Texture Mapping.
· Sound drivers (CoreAudio, OSS, and WaveOut). See section 7.4 Sound Drivers.
· Sound renderers (software, DirectSound 3D, EAX, aRts). See section 7.4 Sound Drivers.
· Sound loaders (WAV, AU, IFF, AIFF, MOD, MP3, OGG). See section 7.4 Sound Drivers.
· Thing and other mesh objects. See section 7.7 Mesh Object Plug-In System. See section 7.7.19 Thing Mesh Object, See section 5.8.5 Creating a Thing Mesh. See section 7.7.7 Genmesh Mesh Object. See section 5.8.6 Creating a Genmesh Mesh.
· 2D and 3D sprites. See section 7.7.5 Sprite3D Mesh Object. See section 7.7.4 Sprite2D Mesh Object.
· Terrain engines with support for texture splatting (dynamically merging multiple textures on a terrain and LOD). See section 7.7.18 Terrain Mesh Object.
· Particle systems (fire, explosions, rain, snow, spirals, fountain). See section 7.7.10 Particle Systems in General.
· Haze mesh (a bit like volumetric light). See section 7.7.17 Haze Mesh Object.
· Pull-down console that you can integrate in your own games. See section 3.4.5 Console Configuration.
· Collision detection (using RAPID or OPCODE). See section 5.8.2 Doing Collision Detection.
· Powerful sequence manager to control movement, animation and other features in a world. See section 7.5.12 Sequence Manager.
· Bitmapped and vector fonts (FreeFont). See section 5.8.22 Using a Custom Font.
· Map file loader and converters. See section 7.6.1 Format of Map File (XML), See section 5.4 Simple Tutorial 3: Map Loading. See section 7.6.2 Old Format of Map File.
· Scripting bindings (Python, Perl, Java). See section 7.8 Scripting Languages.
· Skeletal animation. See section 7.7.6 SpriteCal3D Mesh Object.
· Object movement. See section 5.8.4 Mesh Movement.
· Movie Recording plugin. See section 5.8.23 Recording Movies.
· Debugging system

Whats New in This Release:

· Various smaller fixes.

Games::AlphaBeta::Reversi is a Reversi position class for use with Games::AlphaBeta.

SYNOPSIS

package My::Reversi;
use base qw(Games::AlphaBeta::Reversi);

# implement drawing routine
sub draw { ... }

package main;
use My::Reversi;
use Games::AlphaBeta;

my ($p, $g);
$p = My::Reversi->new;
$g = Games::AlphaBeta->new($p);

while ($p = $g->abmove) {
$p->draw;
}

This module implements a position-object suitable for use with Games::AlphaBeta. It inherits from the Games::AlphaBeta::Position base class, so be sure to read its documentation. The methods implemented there will not be described here.

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.

Space Racer project is a OpenGL Car Game in a galactic environment.

It aims to be a clone of the well known Stunt Car Racer developed by Geff Crammond, author of Grand Prix I and II.

To play a 3dfx is recommanded. But TNT and Matrox Cards should now work.

If you have a 3dfx, you can take advantage of OpenGL 1.1 in adding this line in config.h:

#define SP_OPENGL_1_1

Games::Euchre is an Euchre card game for humans and computers.

SYNOPSIS

Simply run my game wrapper:

% euchre.pl

or write your own:

use Games::Euchre;
use Games::Euchre::AI::Simple;
use Games::Euchre::AI::Human;

my $game = Games::Euchre->new();
foreach my $i (1..3) {
$game->setAI($i, Games::Euchre::AI::Simple->new());
}
$game->setAI(4, Games::Euchre::AI::Human->new());
$game->playGame();
my @scores = sort {$b $a} $game->getScores();
print("The winner is " . $game->getWinner()->getName() . " with a score of " .
"$scores[0] to $scores[1]n");

This software implements the card game of Euchre. The game is played with four players composing two teams. Any of the four players can be human or computer players, but more than one human is not well supported yet.

The Games::Euchre::AI module implements a simple framework for adding new classes of human interfaces or computer opponents. I recomment that AI writers use Games::Euchre::AI::Simple (a REALLY dumb computer opponent) as starting point.
Aside from the ::AI class and its descendents, this package also implements the following classes: Games::Euchre::Team, Games::Euchre::Player and Games::Euchre::Trick.

Games::Chess Perl module represent chess positions and games.

SYNOPSIS

use Games::Chess qw(:constants);
my $p = Games::Chess::Position->new;
$p->at(0,0,BLACK,ROOK);
$p->at(7,7,WHITE,ROOK);
print $p->to_text;

The Games::Chess package provides the class Games::Chess::Piece to represent chess pieces, and the class Games::Chess::Position to represent a position in a chess game. Objects can be instantiated from data in standard formats and exported to these formats.

NOTATION

See Games::Chess::PGN for full details of the notations.

SAN

Standard Algebraic Notation. The modern international notation for chess games. For example,

1. e4 e5
2. f4 exf4
3. Nf3 g5

FEN

Forsythe-Edwards Notation. A compact representation for chess positions. FEN specifies the piece placement, the active color, the castling availability, the en passant target square, the halfmove clock, and the fullmove number as six fields separated by spaces. For example, the opening position is described in FEN as follows:

rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1

PGN

Portable Game Notation. A notation for chess games, including the moves, commentary, variations, and metadata such as the players, the event, the round number, and the date of the match. For example,

[Event "F/S Return Match"]
[Site "Belgrade, Serbia JUG"]
[Date "1992.11.04"]
[Round "29"]
[White "Fischer, Robert J."]
[Black "Spassky, Boris V."]
[Result "1/2-1/2"]

1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1
b5 7. Bb3 d6 8. c3 O-O 9. h3 Nb8 10. d4 Nbd7 11. c4 c6
12. cxb5 axb5 13. Nc3 Bb7 14. Bg5 b4 15. Nb1 h6 16. Bh4 c5
17. dxe5 Nxe4 18. Bxe7 Qxe7 19. exd6 Qf6 20. Nbd2 Nxd6
21. Nc4 Nxc4 22. Bxc4 Nb6 23. Ne5 Rae8 24. Bxf7+ Rxf7
25. Nxf7 Rxe1+ 26. Qxe1 Kxf7 27. Qe3 Qg5 28. Qxg5 hxg5
29. b3 Ke6 30. a3 Kd6 31. axb4 cxb4 32. Ra5 Nd5 33. f3 Bc8
34. Kf2 Bf5 35. Ra7 g6 36. Ra6+ Kc5 37. Ke1 Nf4 38. g3 Nxh3
39. Kd2 Kb5 40. Rd6 Kc5 41. Ra6 Nf2 42. g4 Bd3 43. Re6
1/2-1/2

EPD

Extended Position Description. An extensible notation based on FEN. Intended for data interchange between chess-playing programs and for the construction of opening databases. Not used by Games::Chess.

Games::3D is a package containing an object system for (not only) 3D games.

SYNOPSIS

use Games::3D::World;

my $world = Games::3D::World->new();

$world->save_to_file( $filename );

my $loaded = Games::3D::world->load_from_file( $filename );

my $thing1 = $world->add ( Games::3D::Thingy->new( ... ) );
my $thing2 = $world->add ( Games::3D::Thingy->new( ... ) );

$world->link($thing1, $thing2);

Games::3D::World provides you with a container class that will contain every object in your game object system. This are primarily objects that have states, change these states and need to announce the states to other objects.

The Games::3D::World container also enables you to save and restore snapshots of your objects system.

Basic things that you object system contains are derived from a class called Games::3D::Thingy. These can represent physical objects (buttons, levers, doors, lights etc) as well as virtual objects (trigger, sensors, links, markers, sound sources etc).

You can link Thingys together, either directly or via Games::3D::Links. The links have some more features than direct linking, which are explained below.

This package also provides you with Games::3D::Sensor, a class for objects that sense state changes and act upon them. Or not, depending on the sensor. Sensors are primarily used to watch for certain conditions and then act when they are met. Examples are the death of an object, values that go below a certain threshold etc.

State changes are transported in the object system with signals.

Games::Console Perl module provide a 2D quake style in-game console.

SYNOPSIS

use Games::Console;

my $console = Games::Console->new(
font => $font_object,
background_color => [ 1,1,0],
background_alpha => 0.4,
text_color => [ 1,1,1 ],
text_alpha => 1,
speed => 50, # in percent per second
height => 50, # fully opened, in percent of screen
width => 100, # fully opened, in percent of screen
backbuffer_size => 100, # keep so many messages
prompt => >,
cursor => _,
);

$console->screen_width($width);
$console->screen_height($height);
$console->toggle($current_time);
$console->message(Hello there!);
$console->input(a);

This package provides you with a quake-style console for your games. The console gathers messages and lets you scroll trough them. It also can display a command line.

This package is just a base class setting up everything, but doesnt actually render anything.

See Games::Console::SDL and Games::Console::OpenGL for subclasses that implement the actual rendering to the screen via SDL and OpenGL, respectively.