Free euchre 1.02 software for linux

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::Euchre::AI is a Player API for Euchre card game.

This class implements a skeletal Euchre player programming interface. Subclasses can be created quite easily as interactive interfaces or AI computer players.
If you wish to write your own computer player, I recommend you start with Games::Euchre::AI::Simple. If you wish to write your own human interface, I recommend you start with Games::Euchre::AI::Human.

CLASS METHODS

new

Create and initialize a new Euchre AI. This object is implemented as an empty hash. Subclasses may wish to use this hash for state storage.

INSTANCE METHODS

Actions

The following methods are called in the course of the game where the AI (or human) has to make a decision. The state of the game is always passed in a hashreference. The following fields are always available:

name is the name of the current player. This is useful for output messages.
names is a hash relating player number to player name for all four players.
debug is a boolean indicating if we are debugging game or the AIs. Your AI may wish to provide verbose output if debugging is going on.

bid STATEHASH

Choose trump or pass. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
passes => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
hangdealer => false,
notrump => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

turnedUp is the suit and value of the card on the top of the blind. This will be undef on the second round of bidding.

passes says how many people have passed so far
hangdealer is a boolean saying whether the hang-the-dealer optional rule is in effect

notrump is a boolean saying whether the no trump optional rule is in effect
This function must return one of: H, D, C, S, N, HA, DA, CA, SA, NA, or undef
N means no trump, A means alone, undef means pass. Not all of these are legal at any given round! Use the isLegalBid() method below if you are unsure.

pickItUp STATEHASH

If this is called, you are the dealer and someone called trump. Choose which card from your hand to discard in exchange for the top card of the blind. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
trump => H,
bidder => 2,
weBid => false,
usAlone => false,
themAlone => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

This method should return the 0-based index of the card to trade for the turnedUp card. Namely, this in the index of the hand array for the card that you choose.

playCard STATEHASH

Choose which card from your hand to play on this trick. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
trump => H,
bidder => 2,
weBid => true,
usAlone => false,
themAlone => false,
trick => 2,
ourTricks => 0,
theirTricks => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
played => [10H, 9H, QC],
playedBy => [2, 3, 4, 1],
hand => [JH, AH, AS, KS],
debug => false,
}

playedBy is an arrayref of numbers of the players in the order they will play. Without this, the alone possibility makes it hard to tell who played what.

Any needed information not stored here (like who was the dealer, what was the turn-up card, what happened in the first trick) is YOUR responsibility to collect and store in your instance.

This method should return the 0-based index of the card to play. Namely, this in the index of the hand array for the card that you choose.

Games::Euchre::Player is a player class for Euchre card game.

The four Player objects are used to interact with the humand and computer players, as well as to keep the state of the players hand, whether he bid and whether he went alone.

CLASS METHODS

new GAME NUMBER NAME
Create and initialize a new Euchre player. The number is 1-4.

INSTANCE METHODS

getGame

Return the Euchre game instance to which this player belongs.

setTeam TEAM

Record the Team instance that this player belongs to.

getTeam

Return the Team instance to which this player belongs.

setAI AI

Record the AI instance for this player.

getAI

Return the AI instance for this player.

setAlone

Indicate that this player has chosen to go alone in the current hand.

setBid

Indicate that this player has chosen to choose trump in the current hand.

wentAlone

Returns a boolean indicating whether this player chose to go alone on a bid.

isBidder

Returns a boolean indicating whether this player called the trump suit during bidding.

getName

Return this players name

getNumber

Return this players number, between 1 and 4

getHand

Return the Games::Cards::Hand object representing this players current hand.

getCards

Return an array of the Games::Cards::Card objects held in the players hand.

resetGame

Clear all of the state for the current game and get ready for the next one.

resetHand

Clear all of the state for the current hand and get ready for the next one.

bid TURN

Allow the player to choose trump or pass. Returns one of: H, C, D, S, N, HA, CA, DA, SA, NA, or undef. If the player has an AI instance set, that is invoked. Otherwise a pathetically simple AI decides the bid.

pickItUp

Allow the player, as dealer, to select which card to trade for the turned up card. This method performs the actual trade. If the player has an AI instance set, that is invoked. Otherwise a pathetically simple AI chooses the card.

playCard TRICK

Allow the player to select which card to play on the current trick. This method performs the actual play. If the player has an AI instance set, that is invoked. Otherwise a pathetically simple AI chooses the card.

isLegalBid TURNNUMBER BID

Given a bid, return a boolean indicating the validity of that bid. The bid is tested for structure (one of H, C, D, S, N, HA, CA, DA, SA, NA, or undef), tested against the bidding round (only the turned-up card suit can be called in round 1 , and may not be called in round 2), against the game options (hang-the-dealer, no-trump).
This is called from the bid() method.

The name scurvy comes from "screen/script" and "vi/vim"

Its a tool that lets you easily write screenplays or scripts in a simple text format, then scurvy will output them in the proper screenplay format.

Scurvy can also import some RTF and Final Draft formats, as well as outputting/converting to a variety of formats as well.

Finally, Ive included some vim syntax files to do coloring of the scurvy input and formal screenplay format.

iPup is a simplified build of Puppy Linux for use in institutional settings. iPups applications are limited to those typically used in libraries and schools. iPup comes with AbiWord, Firefox, gFTP and mtPaint.

The purpose behind building iPup has been to create a puplet (custom build of Puppy) that is easy for novice users to understand (at least when it comes to getting on the Internet or typing a paper), but not too user friendly when it comes to things like mounting flash drives, CD-ROMs and the like.

Instant messaging, CD ripping software and media players have not been included. Having said this, most, but not all, of the library files found in the standard version of Puppy have also been included in iPup. This allows you to add software with minimal headache.

MD5: 06635cd572deab1a02d764bdf2192281

RwdSchedule is an event database program using RubyWebDialogs.
It can list events, store events, and edit, rename, and delete events.
FTP can be used to sync events with multiple systems.
ICS files can be created. Context help is sent on some screens. It should run without changes on all platforms.
It is an rwdtinker program and can take additional plugins.
Enhancements:
- changed schedule configuration screen
- updated for rwdtinker 1.66
- new helpabout
- new documents list

xDash is a framework for application integration (EAI). xDash is using XMPP/jabber as the communication protocol and a set of agents. All the needed stuff is automatically generated from a CSV file, which can be comfortably edited in a spreadsheet editor.
xDash can be classified in marketing terms as:
- an Enterprise Application Integration (EAI) solution or
- an Enterprise Service Bus (ESB).
xDash is based on the concept of convergence between backend asynchronous messaging (like IBM MQSeries or JMS) and instant messaging (like IRC or Jabber).
Main features:
- You have to manage a fast integration project with little time and low budget;
- You are convinced, that integration has so many faces, that agile approach and flexible design are better than buying a "silver bullet" from big names;
- You are convinced, that integration is rather a continuous, never-ending process than a single act of some software implementation;
- You would like to concentrate on writing the integration logic in a well known environment and have no time to learn myriads of new options and APIs with little reuse;
- You need an open human readable communication protocol (XML), where you can see what is going on under the hood;
- You need a free open source multiplatform information bus for publish/subscribe integration;
- You are interested in a ground-breaking project dealing with the convergence of instant and backend asynchronous messaging.
What is the core of the xDash?
xDash is at basis every sort of an integration project, which sticks to the following rules:
- Communication over Jabber protocol;
- The extension of the message type to type=job for all relevant messages;
- The message sending schema, in which always participate a message sender, a message receiver and a message archivist ("integration chain").
- For each sort of event, triggering a Sender, there is only one integration chain defined on the server by a set of Jabber IDs and forwarding rules ("Who knows whom" schema).
- The client software of Sender and Receiver knows nobody but the Archivist.
- The jabber server forwards Senders messages sent to the Archivist, additionally to the Receivers.

openflash is an open source utility to (re)program flash BIOS chips. Initial support will be for the i-opener network appliance under Qnx since there is an immediate need.
Usage: qnxflash [-r < file >] [-w < file >] [-v < file >] [-iadlcV]
-r Read bios image from chip.
-w Write bios image to chip.
-v Verify chip data against image file.
-i display bios chips device Id.
-a report All verify errors.
-d Disable verify while programming.
-l List supported devices.
-c disable device id Check.
-V Verbose messages
Enhancements:
- Modifications to correct failures to exit Device ID mode on V4 Iopeners using RISE CPU. This problem was reported as an erase failure in 1.01.
- Changed the method used to exit Device mode from the one step method to the three step.
- Added code to check that Device ID mode was exited successfully. If the first attempt fails an additional 9 attempts will be made before giving up.
- Corrected a bug in WaitFlashComplete() which prevented timeout errors from being detected.
- Doubled the loop count in WaitFlashComplete().
- Added the -V switch to enable verbose error and status messages.
- Added -c switch to allow Device ID checks to be disabled.