Free games like runescape 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::Dice is a Perl module that can be used to simulate dice rolls.

SYNOPSIS

use Games::Dice roll;
$strength = roll 3d6+1;

use Games::Dice roll_array;
@rolls = roll_array 4d8;

Games::Dice simulates die rolls. It uses a function-oriented (not object-oriented) interface. No functions are exported by default. At present, there are two functions which are exportable: roll and roll_array. The latter is used internally by roll, but can also be exported by itself.

The number and type of dice to roll is given in a style which should be familiar to players of popular role-playing games: adb[+-*/b]c. a is optional and defaults to 1; it gives the number of dice to roll. b indicates the number of sides to each die; the most common, cube-shaped die is thus a d6. % can be used instead of 100 for b; hence, rolling 2d% and 2d100 is equivalent. roll simulates a rolls of b-sided dice and adds together the results.

The optional end, consisting of one of +-*/b and a number c, can modify the sum of the individual dice. +-*/ are similar in that they take the sum of the rolls and add or subtract c, or multiply or divide the sum by c. (x can also be used instead of *.) Hence, 1d6+2 gives a number in the range 3..8, and 2d4*10 gives a number in the range 20..80. (Using / truncates the result to an int after dividing.) Using b in this slot is a little different: its short for "best" and indicates "roll a number of dice, but add together only the best few". For example, 5d6b3 rolls five six- sided dice and adds together the three best rolls. This is sometimes used, for example, in roll-playing to give higher averages.

Generally, roll probably provides the nicer interface, since it does the adding up itself. However, in some situations one may wish to process the individual rolls (for example, I am told that in the game Feng Shui, the number of dice to be rolled cannot be determined in advance but depends on whether any 6s were rolled); in such a case, one can use roll_array to return an array of values, which can then be examined or processed in an application-dependent manner.

This having been said, comments and additions (especially if accompanied by code!) to Games::Dice are welcome. So, using the above example, if anyone wishes to contribute a function along the lines of roll_feng_shui to become part of Games::Dice (or to support any other style of die rolling), you can contribute it to the authors address, listed below.

Game Server Startup Script project is a startup script to manage dedicated game servers like Quake3.
Game Server Startup Scripts is a startup script to manage a wide variety of Linux dedicated game servers. It can start/stop/restart/fix dedicated game servers like Quake3, Half Life, Tribes 2, UT2K4, BF1942 and others.
It uses qstat through cron to validate that a game is running as expected. If a game is not running as expected, the game is automatically restarted from the script through cron.
GSSS was written becuase I wanted a way to start up a variety of games in a standard way. Then I also wanted to make sure the games stayed running even after a crash.
So I wrote this perl script. It will start games and through a cron job make sure they stay running. If you have qstat installed it can also verify the game is running like it is suppose to be and not in some strange state where no one can play.
If the game is running but unresponsive, it kills it and starts it again. You can also stop running games cleanly as well.
Games supported by "Game Server Startup Script":
- Quake2
- Quake3
- RTCW
- Half Life
- Unreal
- UT2K3
- UT2K4
- Tribes 2
- NWN
- BF1942
- ET
Enhancements:
- Very minor changes, minor readme changes, clean up

Games::Battleship - "You sunk my battleship!"

SYNOPSIS

use Games::Battleship;

$g = Games::Battleship->new(qw( Gene Aeryk ));
$g->add_player(Stephanie);
$winner = $g->play();
print $winner->name(), " wins!n";

@player_objects = @{ $g->players };

$player_obj = $g->player(Professor Snape);

A Games::Battleship object represents a battleship game between players. Each has a fleet of vessles and operates with a pair of playing grids One is for their own fleet and one for where the enemy has been seen.

Everything is an object with default but mutable attributes. This way games can have two or more players each with a single fleet of custom vessles. These vessles are pretty simple and standard right now...

A game can be played with the handy play() method or for finer control, use individual methods of the Games::Battleship::* modules. See the distribution test script for working code examples.

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::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.

Games::Quakeworld::Query is a class for querying QuakeWorld servers.

SYNOPSIS

use Games::Quakeworld::Query;

my $QWQ = Games::Quakeworld::Query->new("quake.server.com", "27500");
my %info = $QWQ->getinfo(); # obsoleted, use $qwq->get("") instead
print "Server uses map: ".$qwq->get("map")."n";

Hello, this is Games::Quakeworld::Query, a perl module. It is a class made for querying Quakeworld (Quake 1) game servers and getting their informations, that is map name, players, hostname and etc.

Games:Roshambo 1.01 is a brilliant module which manages a game of Rock/Paper/Scissors, aka Roshambo

Major Features:

1. You can specify an optional hashref containing configuration items.
2. Valid configuration items are: numthrows
3. The number of separate valid throws for a game, for example, in Rock, Paper, Scissors, there are 3 throws, while in a spirited game of RPS-101, there are 101 valid throws. If not specified, this defaults to 3.
4. sortable
5. OPTIONAL: Behold the madness of Chris Prather. Passing a TRUE value to new for this item will cause the judge method to return values of -1 if Player 1 wins, 0 for a tie and 1 for Player 2, instead of the 0, 1 and 2 it does normally.
6. The entirely dubious benefit of this is that the function can be used in conjunction with sort. It's his fault. He asked for it. Any questions as to the relative usefulness of this should be directed at him. The management disavows all knowledge.
7. This method will judge a game of RPS, returning a 1 for Player 1 winning, a 2 for Player 2, and a 0 for a tie.
8. It takes up to two arguments, indicating the throws for Player 1 and Player 2, as text representations.
9. If one or both arguments are omitted, the method will internally call $self->gen_throw to randomly generate one.
10. getaction
11. When called with two throws, this will return the text of the action for this combination. For example, if called as $rps-getaction("rock", "paper")> the returned value will be "covers".
12. This module contains actions for three throw (Rock, Paper, Scissors) and 101 throw games, in any other number of throws, this method will return undef.

Requirements: Perl