Free games lineofsight 1.0 software for linux

Games::Lineofsight is a Perl module.

Many games (Ultima, Nethack) use two-dimensional maps that consists of the squares of the same size in a grid. Line-of-sight means that some of the squares may represent the items that block the vision of the player from seeing squares behind them. With this module you can add that behaviour to your games.

SYNOPSIS

use Games::Lineofsight qw(lineofsight);

# The map has to be a two-dimensional array. Each member (or "cell") of the array represents one
# square in the map. In this example each cell contains only one character but you can put strings
# to the cells also - practical with the graphical games.

my @map=(
[split //,"..:..::........."], # this is the map
[split //,".......:..X....:"], # . and : represents the ground
[split //,"...X.....:...:.."], # X is the barrier for the sight
[split //,".:...:....:....."],
[split //,"..X....:..X....."],
[split //,"..X..:........:."],
);

my($width)=scalar(@{@map[0]}); # the width of the map
my($height)=scalar(@map); # the height of the map
my($barrier_str)="X"; # string that represents the barrier
my($hidden_str)="*"; # string that represents a cell behind a barrier
my($man_str)="@"; # string that represents the viewer
my($man_x,$man_y)=(7,3); # view point coordinates - the player is here

# recreate the map with line-of-sight

@map=lineofsight(@map,$man_x,$man_y,$barrier_str,$hidden_str);

# draw the map

for(my $i=0;$i < $height;$i++){
for(my $j=0;$j < $width;$j++){
print $man_x == $j && $man_y == $i ? $man_str : $map[$i][$j];
}
print "n";
}
or
# The lineofsight() calls get_barriers() and analyze_map() each time its called. If the viewer
# moves around the map a lot, its much faster to read in the barriers once and call only
# analyze_map() each time before drawing it.

use Games::Lineofsight qw(get_barriers analyze_map);

# The map has to be a two-dimensional array. Each member (or "cell") of the array represents one
# square in the map. In this example each cell contains only one character but you can put strings
# to the cells also - practical with the graphical games.

my @map=(
[split //,"..:..::........."], # this is the map
[split //,".......:..X....:"], # . and : represents the ground
[split //,"...X.....:...:.."], # X is the barrier for the sight
[split //,".:...:....:....."],
[split //,"..X....:..X....."],
[split //,"..X..:........:."],
);

my($width)=scalar(@{@map[0]}); # the width of the map
my($height)=scalar(@map); # the height of the map
my($barrier_str)="X"; # string that represents the barrier
my($hidden_str)="*"; # string that represents a cell behind a barrier
my($man_str)="@"; # string that represents the viewer
my($man_x,$man_y)=(7,3); # view point coordinates - the player is here

# get_barriers() returns a hash with the information about barriers in the map. In this example we
# declare the "X"-character as a barrier. As well you can declare it to be a string in the graphical
# games; for example "barrier.jpg".

my %barrier=get_barriers($width,$height,@map,$barrier_str);

# analyze_map() returns an array containing the original map looked from the view point. The cells
# behind the barriers are replaced with given strings. The barriers should be told to the subroutine
# calling first get_barriers()-subroutine as we already did.

my @map2=analyze_map($width,$height,@map,%barrier,$man_x,$man_y,$hidden_str);

#draw the map with the lineofsight

print "nOriginal map:n";

draw($width,$height,$man_x,$man_y,@map2,$man_str);

# move the viewer two squares right

$man_x+=2;

# refresh the map

my @map2=analyze_map($width,$height,@map,%barrier,$man_x,$man_y,$hidden_str);

#draw the map again

print "nViewer has moved:n";

draw($width,$height,$man_x,$man_y,@map2,$man_str);

sub draw{
my($width,$height,$man_x,$man_y,$map,$man_str)=@_;
for(my $i=0;$i < $height;$i++){
for(my $j=0;$j < $width;$j++){
print $man_x == $j && $man_y == $i ? $man_str : $$map[$i][$j];
}
print "n";
}

}

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 Knoppix is a Knoppix based LiveCD with games.
The following games are included:
- Marble Blast Gold Demo (OpenGL)
- Mutant Storm Demo (OpenGL)
- Space Tripper Demo (OpenGL)
- Think Tanks Demo (OpenGL)
- Ufo AI (XMas Special) (OpenGL)
- Asciijump
- Atanks
- Bzflag (OpenGL)
- Bzflag-Server
- Crack-Attack (OpenGL)
- Crimson
- Crossfire-Client-GTK
- Crossfire-Client-X11
- Cube
- Empire
- Enigma
- Foobillard (OpenGL)
- Freeciv-Client
- Freeciv-Client-GTK
- Freeciv-Server
- Freesci
- Gltron (OpenGL)
- Gnuchess
- Gnugo
- JumpnBump
- Kbattleship
- Kmahjongg
- Kobodeluxe
- Ksokoban
- Lbreakout2
- Lgeneral
- Nethack-Console
- Nethack-Gnome
- Nethack-Lisp
- Nethack-Qt
- Nethack-X11
- Netpanzer (OpenGL)
- Neverball (OpenGL)
- Pysol
- Scorched3d (OpenGL)
- Tower Toppler
- Battle for Wesnoth
- Battle for Wesnoth Editor
- Battle for Wesnoth Server
- Xarchon
- Xblast
- Xblast-TNT
- Xboing
- Xgalaga
- Xskat
- Xsoldier

Games::Euchre::Trick is a trick class for Euchre card game.

Only one Trick instance is alive at one time per Euchre game. The Trick keeps track of which cards have been played, and provides useful functions to determine which cards are legal plays, as well as who is the winner of the trick.

The trick class makes the determination of which card beats which card, given the current trump and lead. The trick class knows how to handle an alone hand and it calls the playCard() method for each player in turn in its play() method, usually called from the Games::Euchre->playHand() method.

Games::Battleship::Craft is a Battleship craft class.

SYNOPSIS

use Games::Battleship::Craft;

my $craft = Games::Battleship::Craft->new(
id => T,
name => tug boat,
points => 1,
)

$points_remaining = $craft->hit;

A Games::Battleship::Craft object represents the profile of a Battleship

PUBLIC METHODS

new %ARGUMENTS

id => $STRING

A scalar identifier to use to indicate position on the grid. If one is not provided, the uppercased first name character will be used by default.

Currently, it is required that this be a single uppercase letter (the first letter of the craft name, probably), since a hit will be indicated by "lowercasing" this mark on a player grid.

name => $STRING

A required attribute provided to give the craft a name.

points => $NUMBER

An attribute used to define the line segment span on the playing grid.

position => [$X, $Y]

The position of the craft bow ("nose") on the grid.

Currently, the craft is assumed to have a horizontal or vertical alignment. Soon there will be diagonal positioning...

hit

$points_remaining = $craft->hit;

Increment the crafts hit attribute value and return whats left of the craft (total point value minus the number of hits).

JGachine project is a Java game machine/engine/browser.
JGachine is a networked game engine for 2D multi-player (networked) games.
It is written in Java and C++.
The games themselves are written in pure Java and can be loaded via the network.
Main features:
- easy game programing for beginners
- a game machine/engine/browser
- one client for multiple games
- you only write the game server (though the server may send bytecode to the client)
- secure client (though executing bytecode from the server
- writing multiplayer networked games within 2 hours
- portable
- try to allow output device independent games
- device independent coordinates
- help with different/changing aspect ratios

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.

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;