Free games googlewhack 1.4 software for linux

Games::GoogleWhack is a Perl module that finds, verifies, and/or submits GoogleWhacks.

SYNOPSIS

use Games::GoogleWhack;

my $googlewhack = Games::GoogleWhack->new();
my $is_googlewhack = $googlewhack->is_googlewhack(foo, bar);

die $googlewhack->errstr if $googlewhack->errstr;

print "Youve found a GoogleWhack! Congrats! :-)n" if $is_googlewhack;

NOTE: THIS MODULE MAKES EXTERNAL CONNECTIONS TO GOOGLE.COM, DICTIONARY.COM, and/or GOOGLEWHACK.COM. IT IS THE USERS RESPONSIBILITY TO ENSURE THAT THEY ARE IN COMPLIANCE WITH ANY RESPECTIVE TERMS OF USE CLAUSES FOR SITE USAGE. THE AUTHOR ASSUMES NO LIABILITY FOR THE USE OR MISUSE OF THIS MODULE.

Games::Blackjack is a Perl module with Blackjack Utility Classes.

SYNOPSIS

use Games::Blackjack;

# Create new shoe of cards
my $shoe = Games::Blackjack::Shoe->new(nof_decks => 4);

# Create two hands, player/dealer
my $player = Games::Blackjack::Hand->new(shoe => $shoe);
my $dealer = Games::Blackjack::Hand->new(shoe => $shoe);

# Two dealer cards
$dealer->draw();
print "Dealer: ", $dealer->as_string(), "n";
$dealer->draw(); # 2nd card not shown

$player->draw();
$player->draw();
print "Player: ", $player->as_string, "(",
$player->count_as_string, ")n";

# Lets assume player decides to stand. Dealers turn.

# Dealer plays Las Vegas rules
while(!$dealer->busted() and
$dealer->count("soft") < 17) {
$dealer->draw();
}

# Show winner (-1: Dealer, 1: Player, 1.5: Player Blackjack)
print "Player score: ", $player->score($dealer), "n";

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

SYNOPSIS

# automatical computer-vus-computer play script
use Games::Checkers::Constants;
use Games::Checkers::Board;
use Games::Checkers::BoardTree;

my $board = new Games::Checkers::Board;
my $color = White;
my $numMoves = 0;
print $board->dump;

while ($board->canColorMove($color)) {
sleep(2);
# allow 100 moves for each player
die "Automatical drawn" if $numMoves++ == 200;
my $boardTree = new Games::Checkers::BoardTree
($board, $color, 2); # think 2 steps ahead
my $move = $boardTree->chooseBestMove; # or: chooseRandomMove

$board->transform($move);
print $move->dump, "n", $board->dump;
$color = ($color == White)? Black: White;
}

print "n", ($color == White? "Black": "White"), " won.n";
ABSTRACT ^
Games::Checkers is a set of Perl classes implementing the Checkers game play. Several national rule variants are supported. A basic AI heuristics is implemented using the Minimax algorithm. Replay of previously recorded games is supported too.
DESCRIPTION ^
This package is intended to provide complete infrastructure for interactive and automatic playing and manipulating of Checkers games. Some features are not implemented yet.

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::Object is a Perl module to provide a base class for game objects.

SYNOPSIS

package MyGameObject;
use Games::Object;
use vars qw(@ISA);
@ISA = qw(Games::Object);

sub new {
# Create object
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new(@_);
bless $self, $class;

# Add attributes
$self->new_attr(-name => "hit_points",
-type => int,
-value => 20,
-tend_to_rate => 1);
$self->new_attr(-name => "strength",
-type => int,
-value => 12,
-minimum => 3,
-maximum => 18);
...

return $self;
}

package MyObjectManager;
use Games::Object::Manager;
use vars qw(@ISA);
@ISA = qw(Games::Object::Manager);

sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my $self = $class->SUPER::new( , @_);
bless $self, $class;
...
return $self;
}


my $world = new MyObjectManager;
my $object = new MyGameObject;
$world->add($object);

ABSTRACT

The purpose of this module is to allow a programmer to write a game in Perl easily by providing a basic framework in the form of a module that can be either subclassed to a module of your own or used directly as its own object class. The most important items in this framework are:

Attributes

You can define arbitrary attributes on objects with rules on how they may be updated, as well as set up automatic update of attributes whenever the objects process() method is invoked. For example, you could set an attribute on an object such that:

It ranges from 0 to 100.

Internally it tracks fractional changes to the value but accessing the attribute will always round the result to an integer.

It will automatically tend towards the maximum by 1 every time process() is called on the object.

A method in your subclass will be invoked automatically if the value falls to 0.
This is just one example of what you can do with attributes.

Flags

You can define any number of arbitrarily-named flags on an object. A flag is a little like a boolean attribute, in that it can have a value of either true or false. Like attributes, flags can be created independently on different objects. No "global" flag list is imposed.

Load/Save functionality

Basic functionality is provided for saving data from an object to a file, and for loading data back into an object. This handles the bulk of load game / save game processing, freeing the programmer to worry about the mechanics of the game itself.

The load functionality can also be used to create objects from object templates. An object template would be a save file that contains a single object.

Object Managers

New to version 0.10 of this module is object managers. An object manager is a Perl object that allows you to manage groups of related game objects. The object manager allows you to relate objects together (for example, you could define a relationship that allows certain objects to act as containers for other objects). In effect, the object manager acts as your world or universe.
Like the game object class, the manager class can be subclassed, allowing you augment its functionality. An object manager can be loaded and saved, which in turn performs a load or save of the objects being managed by it.

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::PerlWar is a Perl variant of the classic Corewar game.

This is a sparring program, similar to the programmed reality of the Matrix.
It has the same basic rules, rules like gravity. What you must learn is that
these rules are no different than the rules of a computer system. Some of
them can be bent, others can be broken. - Morpheus

PerlWar is inspired by the classic http://www.corewar.info/|Corewar game. In this game, players pit snippets of Perl code (called agents) against each other in order to gain control of the vicious virtual battlefield known as... the Array.

GAME PARAMETERS

Size of the Array

The number of cells that the Array possesses. Each cell can hold one agent.

Agent Maximal Size

The maximal length, in characters, of an agent. If an agent is or becomes larger than this limit, it automatically segfaults upon execution.

Game Maximal Number of Iterations

The maximal number of rounds that can be played before a game is declared over.