Tuesday, January 14, 2020

Video Poker, Part 2

Selecting the Cards


Now the player is in a position to select cards to use. We need a way of letting the player know that the card is selected which is why we have the draw movies. This movie is a single frame movie which contains the word “DRAW” in bold red letters. It is placed over each of the cards and is set to be hidden until made visible. These movie clips were placed in the “Info” layer on the first frame and, if you recall, were hidden in the game initialization method. The movie clips are labeled, “draw1_movie,” “draw2_movie,” “draw3_movie,” “draw4_movie,” and “draw5_movie.”

The logic to handle selecting and unselecting code was already written above but before the game can actually let the player select or unselect a card the game needs to tell the program that selections are allowed. We also need a way for the player to tell the game that it is finished selecting cards so the game can continue. This is the select button on the bottom right of the screen which we add in frame 50 and name “draw\_btn”.  On frame 50 we tell the global video poker game class to activate card selection and the select button using the following two lines of code.

this.stop();
videoPokerGame.activateSelectButton();

The activateSelectButton method is a function that we need to write in the global script. It simply sets the global variable “selecting” to true and then activates the draw button to enable the player to start the game. Clicking on the draw button calls a handleSelect event which simply removes the listener from the button and continues playing the video poker movie.

VideoPokerGame.prototype.activateSelectButton = function()
{
this.selecting = true;
this.drawHandler = this.handleSelect.bind(this);
this.vpMovie.draw_btn.addEventListener("click", this.drawHandler);
}
VideoPokerGame.prototype.handleSelect = function()
{
this.selecting = false;
this.vpMovie.draw_btn.removeEventListener("click", this.drawHandler);
this.vpMovie.play();
}

The movie from frame 51 to frame 155 handles the drawing of the cards which we will cover next.


Drawing the Cards


The drawing of new cards to replace selected cards is done on a per card basis so that Adobe Animate CC can animate the cards being replaced. The code to handle the drawing of the cards is similar for all the cards so we can create a simple utility function to handle the drawing. As this function needs to be accessed by code in different frames, we will make this utility function part of the VideoPokerGame class so the code is in the global script. As you can see, this function simply removes the draw state, hides the draw movie, and then sets the card’s value to the next card in the deck.

VideoPokerGame.prototype.drawCard = function(slot)
{
this.drawMovie[slot].visible = false;
this.hand[slot].setCard(this.myDeck.draw());
}

The draw animation consists of the card being removed followed by the new card being moved into place. This is simply a motion tween going from the full sized card to the small card hidden at the bottom of the screen. This is followed by a small card at the top of the screen motion tweened to a full size card. For the “FLCard” layer the removal tween is on frames 56 to 65 and the drawing tween is on frames 66 to 74. The “Lcard” layer has the removal tween on frames 76 to 85 and the drawing tween is on frames 86 to 94. For the “CCard” layer the removal tween is on frames 96 to 105 and the drawing tween is on frames 106 to 114. The “Rcard” layer has the removal tween on frames 116 to 125 and the drawing tween is on frames 126 to 134. Finally, the “FRCard” layer has the removal tween on frames 136 to 144 and the drawing tween on frames 146 to 154. The Figure \below shows the second half of the video poker timeline where drawing happens.



Right now all the cards are being drawn, and the value of the drawn card is the same value that the card already was. To fix these problems we are going to need to add some java script as well as a few more labels. Let us start by adding some code to the “Code” layer of  frame 55 which was labelled “Draw_1.” This code simply checks to see if the card is one of the cards that was selected to be replaced and if it is not skips over the replacement animation for this card. 

if (this.draw1_movie.visible == false)
this.gotoAndPlay("Draw_2");

If the card is not being drawn, we are done. If the replacement animation plays, however then we need to draw a card to replace the draw card. Once the card has been removed from the screen, we can then draw a card. This is done by calling the function we created earlier in this section. Notice that we use the array index of the card in the function, which is one less than the card that we are on. This is one area where API design can bite you in a project. If this was a team project where non-programmers were calling our API then using the semantics that the artist was expecting would make sense. In this case, we could have had the draw card function assume that the caller was referring to the human number and deduct 1 from the passed number. Ideally you would want to document decisions within the API documentation, but surprisingly this rarely happens and has bitten me a number of times when working with third-party libraries. 

In addition to the code for replacing the card, on Frame 66, we add a draw card sound to the Sound layer so that the sound of a card being drawn is played while the card is being animated in.

playSound("drawwav");

The above procedure is used for the other 4 cards with the draw sound being played on frames 86, 106, 126, and 146. The code is probably self explanatory, but for the sake of completeness I will show the code.

Frame 75 which is labelled “Draw_2”:

if (this.draw2_movie.visible == false)
this.gotoAndPlay("Draw_3");

Frame 86:

videoPokerGame.drawCard(1);

Frame 95 which is also labelled “Draw_3”:

if (this.draw3_movie.visible == false)
this.gotoAndPlay("Draw_4");

Frame 106:

videoPokerGame.drawCard(2);

Frame 115 which is also labelled “Draw\_4”:

if (this.draw4_movie.visible == false)
this.gotoAndPlay("Draw_5");

Frame 126:

videoPokerGame.drawCard(3);

Frame 135 which is also labelled “Draw\_5”:

if (this.draw5_movie.visible == false)
this.gotoAndPlay("Results");

Frame 146:
videoPokerGame.drawCard(4);

Finally we extend all layers to frame 155, label this frame “Results”. Calculating the results of the hand is the most complicated part of the game which we will cover in the next section.

Calculating the Win


The results of the hand can now be calculated. While this work is all done in a single function, the work is kind of complicated. For that reason, I will be breaking the function into a series of sections so I can better explain the logic behind the function. It would have been possible to break down the function into a number of smaller and more specialized functions, which may be a good idea as it simplifies the logic but at a cost of a lot of overhead and duplicate code. If I was going to refactor this function, I would turn it into it's own class so duplicate code could be reduced and the steps broken into separate private methods.

The first thing that is done is the cards are sorted by their face values. Face values are calculated by using the modulus (remainder) of dividing the deck by 13. To make this work, the card ID is reduced by 1.

VideoPokerGame.prototype.findResults = function()
{
var sortedCards = new Array(5);
var cntr1, cntr2, temp, low, testA, testB;
for (cntr1 = 0; cntr1 < 5; ++cntr1)
{
sortedCards[cntr1] = this.hand[cntr1].getCard();
}
// sort, by face value
for (cntr1 = 0; cntr1 < 4; ++cntr1)
{
low = cntr1;
for (cntr2 = cntr1 + 1; cntr2 < 5; ++cntr2)
{
testA = (sortedCards[low] - 1) % 13;
testB = (sortedCards[cntr2] - 1) % 13;
if (testB < testA)
low = cntr2;
}
temp = sortedCards[low];
sortedCards[low] = sortedCards[cntr1];
sortedCards[cntr1] = temp;
}

Next, we prepare all the variables that we are going to need to find the results. We use pairFace to track which card we are trying to match for a pair or triple or quad. We assume at the beginning of our testing that we have a straight and a flush until either of these assumptions are proven wrong during our analysis of the hand. The run is the longest number of matching faces so a run of 2 is a pair, a run of 3 is three of a kind, and a run of 4 is four of a kind. The suit of the first card is the suit we are looking for in the other four cards to determine if we have a flush.

var pairFace = 0;
var isStreight = true;
var isFlush = true;
var longestRun = 0;
var numRuns = 0;
var targetSuit = Math.floor((sortedCards[0] - 1) / 13);
var curRun = 1;


To be a flush, all suits must be the same, so we simply check to see that the suit of the current card in the loop is the same as that of the first card. To see if we have a pair or better, we track the run length of the current card by counting how many cards in a row contain the same face value. As it is possible for more than one pair, we also count how many different face cards are matching. Likewise, to handle a full house, we need to know the length of the longest run of matching cards. Straights are simply a test to make sure that the face value of each card in the sorted hand increases by one (taking into account the fact that an ace can be in two possible positions).


for (cntr1 = 1; cntr1 < 5; ++cntr1)
{
if ( Math.floor((sortedCards[cntr1] - 1) / 13) != targetSuit)
isFlush = false;
testA = (sortedCards[cntr1 - 1] - 1) % 13;
testB = (sortedCards[cntr1] - 1) % 13;
if (testA == testB)
{
isStreight = false;
++curRun;
}
else
{
if (curRun > 1)
{
if (curRun > longestRun)
longestRun = curRun;
curRun = 1;
++numRuns;
pairFace = testA; // if only a pair, need to know face value
}
if (((testB-testA) != 1) && ((testA != 0) || (testB != 9)))
isStreight = false;
}
}
if (curRun > 1)
{
if (curRun > longestRun)
longestRun = curRun;
++numRuns;
pairFace = testA; // if only a pair, need to know face value
}

Analysing the results is the last stage of determining what the hand was. This is done by using the various variables that were set in the analysis phase above and going from the highest value hand down to the weakest hand checking at each hand to see if we meet the criteria for the hand continuing until we have met the criteria for a hand or have a high-card.

// Now analyse results
if ((isStreight & isFlush) == true)
{
if (((sortedCards[4] - 1) % 13) == 12)
{
this.message = "ROYAL FLUSH!!!";
this.lastWin = 250 * this.bet;
}
else
{
this.message = "Streight Flush";
this.lastWin = 50 * this.bet;
}
}
else if (longestRun == 4)
{
this.message = "Four of a Kind";
this.lastWin = 25 * this.bet;
}
else if (longestRun == 3)
{
if (numRuns == 2)
{
this.message = "Full House";
this.lastWin = 9 * this.bet;
}
else
{
this.message = "Three of a Kind";
this.lastWin = 3 * this.bet;
}
}
else if (isFlush)
{
this.message = "Flush";
this.lastWin = 5 * this.bet;
}
else if (isStreight)
{
this.message = "Streight";
this.lastWin = 4 * this.bet;
}
else if (numRuns == 2)
{
this.message = "Two Pairs";
this.lastWin = 2 * this.bet;
}
else if ( (numRuns == 1) && ((pairFace == 0) || (pairFace > 9)) )
{
this.message = "Jacks or Better";
this.lastWin = this.bet;
}
else
{
this.message = "Nothing";
this.lastWin = 0;
}
this.cash += this.lastWin;
return (this.lastWin > 0);
}

Of course, being able to determine the results of a hand is not of much use unless we do something with those results so in the next section we will actually call this method and handle the results of doing so.

Handing the Results


In the results frame we have code that will call the find results method we wrote in the previous section. This code goes to the bet loop immediately if the result of the hand wasn’t a winning hand, otherwise the movie continues playing to give us time to show the results.

var didWin = videoPokerGame.findResults();
videoPokerGame.updateText();
if (didWin == false)
this.gotoAndPlay("BetWait");

To make winning more exciting Video Poker machines have bells and whistles go off when you win anything. This is part of the psychology of gambling and is a reinforcement factor to make the player more excited so they keep playing the game. The bell sound I use is a bit more subtle but still emphasizes that the player has won something so that is placed in frame 156. 

Finally we skip over some frames (so the result message will be shown for a few seconds) and we then place our final “Code” layer key-frame, which simply contains one line of code which goes back to the “betWait” frame.

this.gotoAndPlay("BetWait");

With that we have a complete Video Poker game. For those who want to take this a bit further It is not that difficult to modify the game to support the different types of Video poker such as deuces wild or variants that include a joker. Likewise creating a better deck of cards and running the game at a high-definition resolution would also be simple enough to do.  For the more ambitious people out there, this could be expanded into a full poker game, possibly even a multi-player game.

Have fun and when you are ready come back and explore the world of board games with Pent Up Anger.