Ikhan McClarty Devin Gaines Graham Gimbert James Cefaratti Kwang Kim Monarch Shah Exploration of Design Alternatives

Graphic User Interface Ikhan McClarty

Confirmation boxes  void confirmClose() This method is called if the player chooses to close without saving and after the confirmation proceeds to close or gives the player the option to save  void confirmOverwiteSave() This method is called if the player chooses to save using a filename that already exists It either cancels the command or proceeds to overwrite the already present file

Confirmation boxes Cont’d  void confirmLoadGame() This method is called if there is a game currently in progress and the player asks to load a saved game It then gives the player the option to load the game or cancel the request

Table Features Monarch Shah

Table Features Functionality:  Includes ongoing action on the table  Mainly it’s just a conversation bubble  Bubble will pop next to the player Icon.  Snap shot of this is shown below.

Different Kind’s of bubble includes Check, Raise, Fold, Call, Flop, Turn, River. Shown Below:

Functionality:  Going to Use C and Allegro for coding.  Idea is whenever user select “check” button, check bubble will pop up for particular player.  Its going to communicate with all the buttons, and going to respond accordingly.  Only active when some particular action calls them and respond to this action.  Disabled Rest of the time.

Implementation:  Table Features Class  showBubble (playerName, selectedButton button);  Interacts with both player and button so both attributes are needed in this function.  hideBubble (playerName, selectedButton button);  Flop, turn and river bubbles are not associated with player, they are associated with table so they will have table attributes.

Player/Player Icons:  You can choose from 20 given Icons and computer will be given icons randomly.  It will Look something like this:

Computer Playing Intelligence Kwang Kim

Function Implementation  Each player has all the same functions in order to play.  These include call, bet, raise, fold, check, pre- flop strategy, post-flop strategy.  How to implement?

Implementation  Create a hierarchy of classes.  Superclass is a general player, includes all the functions.  Function specifications are described in each subclass: weak, tight, aggressive.

Function Specification  Functions which are used in each style. void preFlop() //execute preflop strategy void postFlop() //execute postflop strategy int getHandRanking(Hand h) //returns strength of a hand void check() //do nothing, action passed to next player in hand

Function Specification void callBet(Bet b) //call b amount of chips void bet() //bet fixed amount of chips void raise(Bet b) //bet b + fixed amount of chips void fold() //surrender hand

Function Specification bool inHand() //return true if player is in the hand void showDown() //show cards at showdown end of hand void updateChips(int x) //update chip count by x int getChipCount() //return number of chips player has

Implementation Plan  Superclass has definitions for the following functions: call, bet, raise, fold, check, getHandRanking, inHand, showDown, getChipCount, updateChips.  The only functions needed in the subclass are pre- flop and post-flop strategy.

Button Functionality James Cefaratti

Button Class class Button Public:  getX();  getY();  setX(int newX);  setY(int newY);  setSkin(BITMAP* putSkin);

Button Class (cont.) Public:  getHeight();  getWidth();

Point of Functions Should be able to move the button anywhere on the screen using the setX and setY Should be able to get the button’s x and y coordinates and the height and width value to tell if the mouse is over the button If the mouse is over the button and the mouse button is pressed, another function can be called

Save/Load Feature This will be a function in the main class that stores information about the current game and saves it / reads it from a file When “Save Game” is clicked on the screen the current game values such as player name, player chip count, button holder, pot size, etc… will be saved to an array or arrays

saveGame Signature void saveGame(String[] names, int[] values)  Save to a file in some logical order

loadGame Signature First the game screen will have to be loaded and setup then function should be called to setup the game exactly how it was Void loadGame()  Read values in from the file, the order of the values is known so the game can be setup corresponding to those values

Sample Player Data File James 5 10,000 True A, hearts ; A, spades Player Name Position at table Player Chip Count Button Current Hand

Sample Computer Data John false Jill false Ryan false Sarah False 500 Computer Player Name Position at Table Chip Count Button Computer Player Name Position at table Chip count Button Computer Player Name Position at Table Chip Count Button Computer Player Name Position at Table Chip Count Button Pot Size

Best Hand Algorithm Graham Gimbert

Store and sort via a Bi-directional doubly-linked lists  Using the lists check for things such as cards of equal value, same suit, incrementing value, and high cards

class Cardnode { private: Cardnode *next; Cardnode *prev; Cardnode *down; Card *data; public: Cardnode* getNext(); Cardnode* getPrev(); Cardnode* getDown(); Card* getData(); void setNext(Cardnode *temp); void setPrev(Cardnode *prev); void setDown(Cardnode *temp); Cardnode (Card *temp, Cardnode *tnext, Cardnode *tprev, Cardnode *tdown); }

class Cardlist { private: Cardnode *head; int size; public: Cardnode* getHead(); Cardnode* getNext(Cardnode *temp); Cardnode* getPrev(Cardnode *temp); Cardnode* getDown(Cardnode *temp); int getSize(); void insert(Cardnode *temp); Cardlist(); }

class Hand { private: Card *first; public: void addCard(Card *temp); Card* getFirstCard(); Card* getNextCard(Card *temp); Hand(); }

class BestHand { private: Cardlist *numberList; Cardlist *suitList; Hand *receivedHand; Hand *bestHand; void parseNumbers(); void parseSuits(); public: Hand* getBestHand(); BestHand(Hand *toBeSorted); }

Shuffling & AI Functions Devin Gaines

Where to Begin… The main question that I am posing to this part of the project is “what makes a good shuffling randomizer?” After tossing around a few ideas, some of the qualities needed for this shuffling program to work are… Reliability of Randomness  Is the function creating truly random numbers and are they being nicely distributed among the cards? Efficiency of Code  Is the code efficient enough for the program not to lag? Repetitive of Randomization  Can this shuffling function be easily used during each hand?

Methods In Creating a Shuffling Function Currently, I’m playing around with different randomization formats for the shuffling program. One of the first ideas was developing a simple ordered deck. It seems fairly realistic in terms of the shuffling mechanism and it’s really clear cut as far as coding.

Random Ordered Shuffling void shuffle(Card *playDeck)/*basic coding*/ { for(int i=0; i<52; i++) { int j=rand() % 52; Card temp = playDeck[i]; playDeck[i] = playDeck[j]; playDeck[j] = temp; }

Advantages and Disadvantages This method is more traditional and simple in coding. Also it allows for random numbers to be first produced and then cards are randomly placed in accordance to their random number. The good thing about this type of code is that it allows for the shuffle to simulate how we, as humans, really shuffle.  We do a simple swap to the cards in terms of positions. So a top card might be then place towards the bottom of the deck or maybe somewhere in the middle, who knows? The problem, though, with this idea is that it relies too heavily on randomizing technique, but it’s not entirely reliable as a good randomizer.

Another Method Look Up Table  This solution involves simple assigning a random number to each card, and then picking cards out by random numbers.  There is a chance that two of the cards are assigned the same number. This can be checked each time you assign a number, or even better this can be checked when you sort the cards. If two cards are assigned to the same number, then one could either assign the next number or choose another random number to be assigned to the card.  This would form a lookup table each hand and have a card linked with a particular random number.

Look Up Method Functions Assignment Function /*Assigning a random number to a certain card */ Declare variables for DECK_SIZE and a CARD ID; Declare an array CARD_ASSIGNED From 0 to DECK_SIZE cardID = (rand()%DECK_SIZE); /* Get rand numbers between 0 and 51 */ if(cardID == any of the previous number in CARD_ASSIGNED array) card1 = (rand()%DECK_SIZE); /*repeat finding a new number*/ else when we find a new number, hold this number is CARD_ASSIGNED array and continue distributing the rest of the numbers out.

Look Up Method Functions Sorting Function (Bubble Sort) int flag = 1; // set flag to 1 to begin initial pass From 0 to DECK_SIZE { flag = 0; From 0 to DECK_SIZE – 1 if (random CardID x > random CardID y) { Swap CardID in ascending order flag = 1; // indicates that a swap occurred. }

Look Up Method Functions From here, all we would then need to do is have a ChooseRand() function to choose a random number for each player when picking a card at the beginning of each round. Some of the benefit with this type of code would be the fact that we could easily pull information out at random. The only problem with this method is when programming it we rely heavily on the rand() function for choosing a good random number. This is problematic because some random number generators like rand(), have bias on some of bits in a number. This makes the rand() function semi-predictable.

Look Up Method A possible solution…I’m still playing around with that. But I’m looking into playing with weighted arrays and random functions to see if that makes the rand() function less predictable.

AI Functions I’m also working on part of the AI player functions for one of template styles that the players will be going up against. I’m personally in charge of the weak style strategy and I been contemplating a few ideas for a few functions needed to create this player style.

Player Modules I want to make the function very much related to how actual players would take in and process information, so I will most likely use the following function…  STIMULUS() //Defines the weak player’s betting style…when they’ll be likely to raise or fold  RESPONSE() //A response to a player’s action in the game  JUDGE_WEAK() //A statistical function that takes in the stimulus and formulates whether the player should bet, how much they should bet, or if to fold.  STATS_WEAK() //Function carries all the likelihoods that they will bet, fold, raise, etc.