 |
||||||||||
| ||||||||||
| ||||||||||
Languages »
C# »
General
Intermediate
Poker Card Library and Poker Bot ChallengeBy Wesley Varela & Jonathan FeldkampAn article on poker bots and card libraries |
C#, Windows, .NET 1.0, .NET 1.1, .NETVisual Studio, VS.NET2003, Dev Posted: 8 Nov 2004 Updated: 8 Nov 2004 Views: 87,086 Bookmarked: 38 times |
||
|
|
|||
|
Advanced Search Sitemap |
|
|
|
||||||||||||||||
Introduction
A few weeks ago I read the article “Are poker ‘bots’ raking online pots?” on MSNBC’s website. Being an avid poker player/enthusiast I started toying with the idea of writing a Texas Hold’em bot just for the fun of it (ya, I know, geek). Although it seemed like a great idea at the time my enthusiasm for actually writing it wasn’t too high. Then I came across the article “Poker Bots: How Bad of a Problem are they?” that stated that “many computer programmers are going to try and fail in developing their poker bots.” Sadly, I took this as a personal affront and decided to write the bot.
However, with a slight twist. I am not trying to have my bot play in any online games or anything. I just want to see how it will do against bots created by other programmers. After enlisting several of my co-workers to write bots I started looking for other people to enter and thought that Code Project was a great place to start. So, I am posting this article in an attempt to get some of you programmers out there involved in our little tournament.
In this article I will go over the PlayingCardLibrary that I built to implement the cards and the evaluations of hands. As well as, the requirements for anyone wanting to submit a bot into the tournament. Not wanting to re-invent the wheel I decided to look around and see what was already out there. During my browsing around I found several libraries that were used to evaluate hands and implement the cards but I didn’t care for them. They often seemed long and confusing, so I decided to write my own.
The PlayingCardLibrary is a library that implements your standard 52 card deck.
Ace of Spades, down to the 2 of clubs. It has 4 classes of relevance. Card.cs,
Deck.cs, Hand.cs, and PokerGame5Cards.cs.
Understanding the Library
Card.cs,of course, represents the basic card in a 52 card deck. It
has a member (rank) and a suit with properties to access that information. Card
also has a public method that can be used to get the image of the card in JPG
format.
public Image CardImage()
{
return (new CardImages.ImageRetrival()).GetImage(cardValue);
}
Card.cs implements IComparable which allows the cards
to be sorted in two ways. If sortWithSuit is set to true, then the
sorting will be done with regards to suit first, then rank, meaning that if you
placed all the cards in an ArrayList and called its sort method
the cards would be arranged exactly like a new deck of cards: Ace of Spades
down to the Two of Spades, then hearts, diamonds and clubs. If sortWithSuit
is false, then the cards are sorted Ace’s, King’s, Queen’s, Jack’s, …, 3’s,
2’s.
Deck.cs is your basic 52 card deck. It has three public methods of
interest, Shuffle, which randomizes the cards in the deck. Resets the
deckIndex
to zero so new cards are dealt from the top of the deck (figuratively).
public void Shuffle()
{
// reset the index into the newly shuffled cards
deckIndex = 0;
// temp variable need to do the swaping
int temp = 0;
Card card;
// for every card in the deck switch it with another
for(int i = 0; i < cards.Length; i++)
{
temp = random.Next(0,cards.Length);
card = cards[temp];
cards[temp] = cards[i];
cards[i] = card;
}
}
The HasNext() and DealNext() methods work in
conjunction. HasNext() indicates if there is another card that can
be dealt and DealNext() deals that card. Calling DealNext()
without checking HasNext() can lead to an IndexOutOfRangeException
which is changed into a OutOfCardsException.
PokerGames5Cards.cs is where things get a little more interesting.
After searching for an existing library that could evaluate a set of cards to
determine the best possible 5 card (Hand) set, I found that most of the
existing code was more complicated then it needed to be, often consisting of
several hundred lines of code that was confusing to use. After a few hours of
searching and examining existing packages I decided to write this library.
Central to this library is the evaluation method. PokerGames5Cards.cs
has only one public method: Evaluate, it takes a Card[]
array of 5 or more cards and an object, it returns the best 5 card
hand. The basic idea behind Evaluate is that it makes every possible 5 card
combination and then sorts them based on the relative strength of the hand.
public Hand Evaluate(Card[] cards, object player)
{
if(cards.Length < 5)
{
throw new ArgumentException("Not enough Cards to perform evaluation");
}
ArrayList combinations = new ArrayList();
int len = cards.Length;
// iterate through all possible combinations
for(int i = 0; i < len - 4; i++)
for(int j = i+1; j < len - 3; j++)
for(int k = j+1; k < len - 2; k++)
for(int r = k+1; r < len - 1; r++)
for(int s = r+1; s < len; s++)
{
// create a new hand
Hand h = new Hand(player);
// add the cards
h.AddCards(new Card[]{cards[i],
cards[j],
cards[k],
cards[r],
cards[s]});
// evaluate the hand
EvaluateHand(h);
// add it to the group
combinations.Add(h);
}
// sort the compiled hands
combinations.Sort();
// return the largest
return (Hand)combinations[0];
}
The code needed to determine if a hand falls with in a certain category (flush, straight, …) is fairly straight forward and I’ll leave it up to the readers to examine the code directly. The interesting part is how we evaluate each hand. Because poker hands neatly partition themselves into categories and each category can be further partitioned into subcategories, I decided to map all possible hands into the set of integers. With this accomplished, any hand can be quickly and easily compared to any other hand, without having to go into all the checks (to see if they are both 2 pairs, then checking the pairs, then checking the kickers if needed) so prominent in other packages.
I start by evaluating each hand to determine what major category it falls into (Flush, straight, …), then I reorder the cards with the strongest cards relative to the major category in the front. (The reordering isn’t really necessary but it makes it easier to put on screen if they are already in order).
Example one: (AH) = (rank, suit) = Ace of Hearts
3H, 5H, JH, 8H 2H falls into the major category for flushes. The cards are then
reordered to JH, 8H, 5H, 3H, 2H and mapped into a 32 bit integer using the
following private method.
private int SetHandValue()
{
int handValue = 0;
handValue = ApplyMask(handValue, (int) type, 20);
handValue = ApplyMask(handValue, (int) cards[0].GetMember, 16);
handValue = ApplyMask(handValue, (int) cards[1].GetMember, 12);
handValue = ApplyMask(handValue, (int) cards[2].GetMember, 8);
handValue = ApplyMask(handValue, (int) cards[3].GetMember, 4);
handValue = ApplyMask(handValue, (int) cards[4].GetMember, 0);
return handValue;
}
private int ApplyMask(int origninal, int value, int shift)
{
int temp = value << shift;
return origninal | temp;
}
Where type is of Type enumeration
private enum Type
{
HighCard = 0,
Pair,
TwoPair,
ThreeOfAKind,
Straight,
Flush,
FullHouse,
FourOfAKind,
StraightFlush,
RoyalFlush
}
Example two:(already reordered)
(Hand 1)8H, 8D, 2H, 2D, KC = 0010 1000 1000 0010 0010 1101
(Hand 2)8S, 8C, 2S, 2C, AC = 0010 1000 1000 0010 0010 1110
now we can see that Hand 2 easily beats Hand 1 simply by checking it numerical
value.
Hand.cs is relatively simple, it is a place to hold the Card[]
for each hand, the numerical value of the hand, and implements the IComparable
interface so the hands can be compared against other hands.
In Summary, all of the classes in this library are short and to the point. Hands are easily partitioned possible into groups and subgroups (including kicker cards) that can be mapped directly to the set of integers for easy comparison.
BOT CHALLENGE 2K5 !!
Ok, so the fun stuff.... who is programmer enough to compete? On too, THE PROGRAMMERS CHALLENGE!!! I have written a little Texas Hold’em game. And I’d like to have as many people as possible submit their idea of a great poker bot. In January 05 we’ll have a series (around 1000) of tournaments to determine the winning bot. The reason for having more then one tournament is to give the bots a chance to learn the moves of the other bots (if desired), rather then to just rely on the statistics of the current hand, if they want to.
What your bot must do
Please Examine the second zip file. It contains all the files that you need in
order to complete your bot. Of course, you need the card library along with: AbstractPlayer.cs,
HoldemPlayer.cs, HoldemGameState.cs, HoldemActionEvent.cs,
ActivePlayer.cs.
AbstractPlayer.cs and HoldemPlayer.cs are to abstract
classes that provide a lot of the basic functionality of the player. Your bot
must extend HoldemPlayer.cs, inside the holdem player you have the
following information. Card[] cards contains your hole cards, you
can check isButton, isBigBlind, isSmallBlind
to determine if you are the dealer or one of blinds. Your inheriting class must
provide concrete implementation for the abstract methods in HoldemPlayer and
AbstractPlayer. That is, you must provide the functionality for the following
methods:
public override HoldemActionEvent
EvaluateCurrentAction(HoldemGameState state)
{
// Add your code here
}
In EvaluateCurrentAction you need to make some kind of move, you are passed the
current game state, which gives you PlayersChipCount (returns the
players chip count), AmountNeededToCall (returns the amounted
needed to call), GetPlayerList (returns a list of the active
players), GetCommunityCards (returns the table cards), GetBigBlind
(tells you what the current bigBlind is), GetPotSize (tells you
the current size of the pot) and GetLastAction (returns the last
action that was performed)
public override void HoldemActionUpdate(HoldemActionEvent action)
{
// your code here
}
ActionUpdate is a curtsy method that informs all the plays of
moves that are made, as they are made, including your moves. They can be used
to track the game. Then when you get the game state in EvaluateCurrentAction
you can verify your internal tracking.
public override void HoldemActionUpdate(HoldemActionEvent action)
{
// your code here
}
HoldemActionUpdate gives you access to the event of the player. Specifically,
the methods Actions and Amount. Actions returns
the event action and Amount returns the amount associated with
that action. where Actions is the following enumeration.
public enum Actions
{
FOLD = 1,
CALL,
RAISE,
ALLIN
}
OK, so, if you up for the action, email your bots (as text only - no
attachments) to the BotChallenge2k5@hotmail.com with the following subject
line: "BOT CHALLENGE 2K5 !!"
and the winner will be posted after the tournaments have been run... Good
programming and Good luck. These emails will be read in as text and placed into
a single file named after whatever you call your class that extend HoldemPlayer.cs.
so please be sure that all of the classes that you need are all working
properly... No extra text, if it doesn't compile, its deleted.
.
General 
News 
Question 
Answer 
Joke 
Rant 
Admin
|
PermaLink |
Privacy |
Terms of Use
Last Updated: 8 Nov 2004 Editor: Nishant Sivakumar |
Copyright 2004 by Wesley Varela & Jonathan Feldkamp Everything else Copyright © CodeProject, 1999-2008 Web15 | Advertise on the Code Project |