Free euchre card software for linux

Nebula Cards project is a card game engine.
Nebula Cards is a networked, modular card game engine written in pure Java.
The game rules, user interfaces, and computer players all take the form of pluggable Java classes, and most four-player, trick-taking games can be implemented.
It currently includes Spades and Hearts, with a computer player for Spades.
Enhancements:
- last release before a major restructuring.
- added Game class in a backward-compatible way.
- added util.proc to house the new GameProcedure library.
- added util.ui.GraphicalCardSelector (untested).

Penguin Cards project is a card game.
PenguinCards is a two-player card game. The aim is to find the pairs of cards on the board. The one who finds out more card pairs is the winner.
PenguinCards is a java-based game.
If you are unhappy with images on the cards, then simply copy your cards into images/pictures/penguins directory. That is it!
Enhancements:
- Initial release

.PHPMyEcards is a set of PHP pages that provides you with an e-card-sending service for your Web site.

The main features are automatic installation and an admin section to manage your e-cards and to set the site presentation

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.

PHP Greeting card class can be used to compose and send greeting cards by email.

PHP Greeting card class can compose and send an email message with a greeting either in text, in HTML with an image, or in HTML with Flash content.

The HTML version of the card may include a greeting picture.

Khalkhi cards allows you to have cards of the entries in your addressbook floating on the desktop, see the status in the several systems a person has an account in, and do a lot of things, like surfing to her homepage, starting an email or a chat, or dropping her a file/url.
A card lists all properties of an addressbook entry. Are status services installed for a property, the status is displayed below the property item. Actions services are available by the context menu (right click on a property item), and so called data action services by the drop menu (drag a file/url onto the card or an item).
The program is based upon the Khalkhi framework, thus endlessly extendable by plugins. It cannot be used directly, is only available by a service within the framework. So install also the framework and the Khalkhi applet for Kicker:
http://www.kde-apps.org/content/show.php?content=54450
http://www.kde-apps.org/content/show.php?content=54451
Needs 0.2.2 of the Khalkhi framework (see link above).
Enhancements:
- adaption to rename of Contacts framework to Khalkhi framework

Games::Cards is a Perl module for writing and playing card games.

SYNOPSIS

use Games::Cards;
my $Rummy = new Games::Cards::Game;

# Create the correct deck for a game of Rummy.
my $Deck = new Games::Cards::Deck ($Rummy, "Deck");

# shuffle the deck and create the discard pile
$Deck->shuffle;
my $Discard = new Games::Cards::Queue "Discard Pile";

# Deal out the hands
foreach my $i (1 .. 3) {
my $hand = new Games::Cards::Hand "Player $i" ;
$Deck->give_cards($hand, 7);
$hand->sort_by_value;
push @Hands, $hand;
}

# print hands (e.g. "Player 1: AS 2C 3C 3H 10D QS KH")
foreach (@Hands) { print ($_->print("short"), "n") }

$Hands[1]->give_a_card ($Discard, "8D"); # discard 8 of diamonds

This module creates objects and methods to allow easier programming of card games in Perl. It allows you to do things like create decks of cards, have piles of cards, hands, and other sets of cards, turn cards face-up or face-down, and move cards from one set to another. Which is pretty much all you need for most card games.