Free games googlewhack 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::Go::Dg2ASCII is a Perl extension to convert Games::Go::Diagrams to ASCII diagrams.

SYNOPSIS

use Games::Go::Dg2ASCII
my $dg2ascii = B convertDiagram($diagram);

A Games::Go::Dg2ASCII object converts a Games::Go::Diagram object into ASCII diagrams.

Games::Go::Dg2Tk is a Perl extension to convert Games::Go::Diagrams to perl/Tk windows.

SYNOPSIS

use Games::Go::Dg2Tk
my $dg2tk = B convertDiagram($diagram);

A Games::Go::Dg2Tk object converts a Games::Go::Diagram object into Tk::Canvas item. The close method calls Tk::MainLoop to dispays the collection of Canvases.

Bindings for the normal editing keys: Up, Down, Next (PageDown) and Prior (PageUp) traverse the NoteBook tabs. Tab and Shift-tab also work as expected.

Left and Right keys select the previous or next NoteBook tab, but dont display it. Space and Enter (carriage return) display the selected tab.

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::Go::SGF is a Perl module that can parse and dissect Standard Go Format files.

SYNOPSIS

use Games::Go::SGF;
my $sgf = new Games::Go::SGF($sgfdata);
print "Game played on ".$sgf->date."n";
print $sgf->white. " (W) vs. ".$sgf->black." (B)n";
print "Board size: ".$sgf->size.". Komi: ".$sgf->komi."n";

while ($move = $sgf->move($move_no++)) {
print "$move_no: ".$move->move,"n";
}

This is a very simple SGF file parser, of currently limited functionality. It can read and step through SGF files, follow variations, and so on. Its good enough for getting simple statistics about games of Go, and building up Games::Go::Board objects representing games stored as SGF.

$sgf->move returns either a normal Games::Go::SGF::Node or a Games::Go::SGF::Variation object. They behave exactly the same, but the variation object has the additional methods mainline() to get the main line of the game, variation($n) to get the first node in the nth variation, and variations to retrieve an array of variations. $variation->move will, by default, follow the mainline.

Games::Go::Dg2TkPs is a Perl extension to convert Games::Go::Diagrams to Postscript.

SYNOPSIS

use Games::Go::Dg2TkPs
my $dg2ps = B convertDiagram($diagram);

This is a real hack to get PostScript output from the Dg2Tk converter. All it does is use the built-in PostScript that a Tk::Canvas widget provides to convert the Dg2Tk canvas pages to PostScript. The resulting PostScript is fairly crude because the Canvas that it is drawn from is crude to begin with. See Games::Go::Dg2Ps for a better PostScript converter.

A Games::Go::Dg2TkPs inherits from Games::Go::Dg2Tk, and uses all its methods and options. The main difference is that after conversion to Tk is complete, each diagram Tk::Canvas is converted to PostScript via the Tk::Canvas->postscript method. Some minor massaging of the PostScript source is done to string the canvas pages together.

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