Free game tree software for linux

Image Tree is a complete and versatile photo publishing system in less than 200 lines of code.

ImgTree is based only on three files:

index php : contains all the php and html code. Must be put, unmodified in every folder of the directory tree.
data.php : contains the specific settings of every folder
style.css : the css style sheet

Every folder of the folder tree must contain the three files. Clearly index.php and style.php should be simply linked:

imgtree/
|-- data.php
|-- index.php
|-- style.css
|-- Section-A
| |-- data.php
| |-- index.php -> ../index.php
| |-- style.css -> ../style.css
| |-- 01-thumb.jpg
| |-- 01.jpg
| |-- 02-thumb.jpg
| |-- 02.jpg
| `-- ...
`-- Section-B
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 00.jpg
|-- Subsection-B1
| |-- data.php
| |-- index.php -> ../index.php
| `-- style.css -> ../style.css
| |-- cover.jpg
`-- Subsection-B2
|-- data.php
|-- index.php -> ../index.php
|-- style.css -> ../style.css
|-- 01-thumb.jpg
|-- 01.jpg
|-- 02-thumb.jpg
|-- 02.jpg
`-- ...

Every folder act as a section and the behaviour can be choose between:

index : Contains a list of links to every subfolder of the current folder. For every section an image and a description are shown.
thumb : Thumbnails page. Shows every image file of the folder. Thumbnail must be named "xxx-thumb.jpg" for the xxx.jpg file. Ex: 01-thumb.jpg -> 01.jpg ; tramonto-thumb.jpg -> tramonto.jpg ; ecc.
cover : Cover page. Shows an image, a text and an associated link

The file data.php contin the settings specific for every section:

$gallerystart : is the gallery start to generate the back-menu. The path must be relative to the starting folder of the site
$name : name used to link the current section in the menus
$title : page title
$description: description, used as subtitle and for brief description in index pages
$indeximage : image used in index pages to link this section
$type : type of the page (cover|thumb|index)
$imgtitle : associtive array of the images descriptions. Used only by "thumb" pages
$coverimage : image used by "cover" pages
$covertext : text used by "cover" pages
$coverlink= : link used by "cover" pages
$covertitle : title used by "cover" pages

NEEDS a web server (Apache or similar) with PHP support

gewee game is a Go-like board game with "next generation" graphics.

This is a game between a human ("player") and a computer ("opponent"). The players objective is to accumulate as many points as possible. When the player wins a game, a point is added to his/her score. When the player loses a game, a point is subtracted from his/her score. The competitor with the most pieces on the board at the end of the game is the winner. A game is finished when a competitor forfeits, or has no valid empty square to place a piece on. The opponent is granted additional moves at the start of a game based on the players score.

Each competitor has a distinct set of pieces of the same shape and color. The competitors take turns placing one piece on an empty square on the board. A piece or group of pieces that has no empty square adjacent to it is removed from the board.

GGTL is a library designed to make it easier to program games in C. Generic Game-Tree Library provides an AI that is able to play most 2 player strategic games.
Nim, Tic-Tac-Toe, Reversi (aka Othello), Connect-4 and Chess are all examples of games that can all be implemented using GGTL.
GGTL comes with game-specific extensions that enables it to play Nim and Reversi almost out of the box. Please see the documentation for details.
Enhancements:
- "clock()" is used as a fallback for sub-second timing if "gettimeofday()" is not found.
- An internal typedef was dropped, and a header declaration for a function that didnt exist was removed.
- Some build system refactoring was done.

game is a simple Tetris-like game.
The objective of the game is to keep the level of colored blocks down as long as possible.
New blocks are falling down at an increasing rate, blocks can be removed by creating rows of three or more blocks of the same color. The longer the row,
the more points you get.
Usage:
The objective of the game is to keep the level of colored blocks down as long as possible. New blocks are falling down at an increasing rate, blocks can be removed by creating rows of three or more blocks of the same color. The longer the row, the more points you get.
space - Flip two neighbour blocks.
arrow keys - Move cursor
h,j,k,l - Move cursor (vi-fans)
escape - Quit game, no questions asked.
s - Starts the game. If a game is in progress, a new game
will be started instantly.
p - Pause game. To avoid cheating, the game will be hidden
during pause.
e - Generate earthquake. This can be used as a last resort in
case of panic, and will remove approximately 30 blocks from
the field. It might help you. Then again, it might not.
Can be used once per game and costs 50 points.
Installation:
Linux:
Make sure the SDL, SDL_image and SDL_mixer runtime libraries are installed
$ tar -zxvf game- -linux.tgz
$ cd game
$ ./game
Enhancements:
- Added better error handling on SDL img load failures

AJAX Tree Control is a modified version of SilverStripes tree control. It adds dynamic loading of child nodes via AJAX.

The default implementation uses the prototype library to make dynamic requests, but this behavior can be overridden by setting functions on the global Tree object.

There are a few demo Ruby on Rails applications included in the distribution that show how to use and customize the tree.

Eclipse is a set of C++ classes designed to give beginner developers a head start in developing their first games as well as more experienced developers who dont want to have to write code for mundane tasks like fonts, sprites, and image loading.

Eclipse 2D Game Engine provides bitmap fonts, window management, audio capabilities, image loading, error logging, and zip file support.

XML::Simple::Tree is a tree object extension for XML::Simple data structures.

SYNOPSIS

## script 1
## create XML::Simple::Tree object and do a preorder traversal

## create XML::Simple::Tree object from an xml document ($xml_file)
my $xml_obj = XML::Simple::Tree->new(file => directory.xml,
node_key => dir,
target_key => name);

## sub set_do_node() method takes subroutine reference to be executed at current node
$xml_obj->set_do_node(
sub {
my $self = $xml_obj;

my $cnode = $self->get_cnode();
my $level = $self->get_level();
my $padding = * x ($level + 1);

print "$padding$cnode->{name}[0]n";
}
);

## sub set_do_leaf() method takes subroutine reference to be executed at leaf node
$xml_obj->set_do_leaf(
sub {
my $self = $xml_obj;

print "n";
}
);

## Tree pre order traversal method that executes do_node() at each node and do_leaf() at each leaf
$xml_obj->traverse();


## script 2
## find a node and retrieve a parameter.

my $xml_obj =
XML::Simple::Tree->new(
file => $xml_file,
node_key => directory,
target_key => name
);

my $want_node = $xmlObj->find_node($target_directory);
my $mtime = $want_node->{mtime}[0];

## script 3
## find a node and cut (remove) it from tree.

my $cut_name = bin;

my $mainXml =
XML::Simple::Tree->new( file => $xml_file,
node_key => directory,
target_key => name);

$mainXml->cut_node($cut_name);

## script 4
## take XML::Simple::Tree object and paste it into a target node of another
## convert it back to xml

my $target_dir = xxx;

my $cut_tree =
XML::Simple::Tree->new(file => $cut_xml_file,
node_key => directory,
target_key => name);

$config_tree->paste_node($target_dir, $cut_tree->get_cnode()->{directory}[0]);

## convert to xml
my $xml = $config_tree->toXML();

## Additional examples can be found in the included tests.

This module extends XML::Simple by taking the data structure returned by XML::Simple::XMLin($xml_file, forcearray => 1) and putting it in a class complete with tree manipulation and traversal methods. Important to know is that XMLin is called with the option ForceArray => 1. This option forces nested elements to be represented as arrays even when there is only one.

Chess::Game is a class to record and validate the moves of a game of chess.

SYNOPSIS

use Chess::Game;

$game = Chess::Game->new();
$clone = $game->clone();
$move = $game->make_move("e2", "e4");
$move_c = $clone->make_move("e2", "e4");
$true = ($move->get_piece() ne $move_c->get_piece());
$move = $game->delete_move();
...
while (!defined($result = $game->result())) {
# get a move
$move = $game->make_move($sq1, $sq2);
if (!defined($move)) {
print $game->get_message();
}
}
if ($result == 1) {
print "White wins!n";
}
elsif ($result == 0) {
print "Draw!n"
}
else {
print "Black wins!n";
}

The Chess module provides a framework for writing chess programs with Perl. This class forms part of that framework, providing move validation for all moves recorded using the Chess::Game class. The Game contains a Chess::Board, 32 Chess::Pieces and a Chess::Game::MoveList that contains a series of Chess::Game::MoveListEntrys that record the exact state of the game as it progresses. Moves can be taken back one-at-a-time to allow for simple movelist manipulation.