So, here is a class I wrote today. Jesse Freeman asked me to do this project, so I did. He showed me the approach that this class uses for being a singleton.
/**
* <p>Original Author: aidan coyne</p>
* <p>Class File: PokerLogic.as
*
* <p>Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:</p>
*
* <p>The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.</p>
*
* <p>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.</p>
*
* <p>Licensed under The MIT License</p>
* <p>Redistributions of files must retain the above copyright notice.</p>
*
* <p>Revisions<br/>
* 0.1 Initial version Aug 28, 2008</p>
*
*/
package //com.wordpress.raptros
{
/** written by (raptros-v76) Aidan Coyne while working at @radical.media.
*/
//import flash.display.Sprite; //this isn't actually a sprite.
/** Logic singleton for a simple poker dice game.
* At first I intended to do a lookup table system
* but I soon learned I would have to hand write every combination.
* No. Instead, I did this.
*/
public class PokerLogic //extends Sprite //not anymore!
{
private static var __instance:PokerLogic;
private static var __primes:Array = new Array(2, 3, 5, 7, 11, 13);
/** this is supposed to be a singleton
*
*/
public function PokerLogic(enforcer:SingletonEnforcer)
{
}
public static function get instance():PokerLogic //use this to get an`instance of PokerLogic.
{
if(PokerLogic.__instance == null)
{
PokerLogic.__instance = new PokerLogic(new SingletonEnforcer());
}
return PokerLogic.__instance;
}
/** @param hand1 array containing dice rolls
* @param hand2 array containing dice rolls
* @return 1 for hand1, 2 for hand 2, 0 if tied
*/
public function compareHands(hand1:Array, hand2:Array):int
{
var rank1:Object = rankHand(hand1);
var rank2:Object = rankHand(hand2);
if (rank1.rank == rank2.rank)
return 0;
else if (rank1.rank > rank2.rank)
return 1;
else
return 2;
}
/** @param hand array containing dice rolls
* @return an object ranking the hand.
* first number (object.rank) will be between 16 and 6 hundred million
* under 100:high card; 1000 to 7000: 1 pair
* 10,000 to 70,000: 2 pairs; 100,000 to 700,000; 3 of a kind
* 1,000,000 to 7,000,000: full house; 8,000,000 or 9,000,000: straight
* 10,000,000 to 70,000,000: 4 of a kind;
* 100,000,000 to 600,000,000: 5 of a kind.
* second number (object.type) see findHandType
*/
public function rankHand(hand:Array):Object
{
//count number of each type of card
var counts:Array = new Array(0, 0, 0, 0, 0, 0);
for each (var card:int in hand)
{
counts[card - 1]++;
}
var type:int=findHandType(counts);
var rank:int=0;
switch (type)
{
case 0: //high card
for (card=0; card < counts.length; card++)
{
//in high card, there are no repeats
if(counts[card] == 1)
rank+=card;
}
break;
case 1: //1 pair
rank=rankOnePair(counts);
break;
case 2: //2 pairs
rank=rankTwoPairs(counts);
break;
case 3: //3 of a kind
rank=rankThree(counts);
break;
case 4: //full house
rank=rankFullHouse(counts);
break;
case 5: //straight
rank=rankStraight(counts);
break;
case 6: //4 of a kind
rank=rankFour(counts);
break;
case 7: //5 of a kind
rank=rankFive(counts);
break;
}
return {rank:rank, type:type};
}
/** finds the type of the hand: (going from 0 to 7)
{high card, 1 pair, 2 pair, 3kind, fullhouse, straight, 4kind, 5kind}
*/
private function findHandType(counts:Array):int
{
var flags:Array= new Array(1, 0, 0, 0, 0, 0, 0, 0);
var ones:int=0;
for (var die:int = 1; die <= counts.length; die++)
{
var diceCount:int = counts[die-1];
switch(diceCount)
{
case 1:
ones++;
break;
case 2:
if (flags[1] > 0)
flags[2]++;
if (flags[3] > 0)
flags[4]++;
flags[1]++;
break;
case 3:
if (flags[1] > 0)
flags[4]++;
flags[3]++;
break;
case 4:
flags[6]++;
break;
case 5:
flags[7]++;
break;
}
}
//test for a straight
if (ones == 5)
{
if (counts[0] == 0 || counts[counts.length -1] == 0)
flags[5]++;
}
for (var flag:int = flags.length - 1; flag >= 0; flag--)
{
if (flags[flag] > 0)
{
return flag;
}
}
return -1; //should not be reached. might be a good idea to actually test for...
}
private function rankOnePair(counts:Array):int
{
var rank:int=0;
var multi:int=1;
//using the primes trick, plus knowledge that non-pair cards
// are unique in hand
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 1)
multi *= PokerLogic.__primes[card-1];
else if (counts[card-1] == 2)
rank = card * 1000;
}
rank += multi;
return rank;
}
private function rankTwoPairs(counts:Array):int
{
var rank:int=0;
var multi:int=0;
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 1)
multi = card;
else if (counts[card-1] == 2)
{
if (rank > 0)
rank += card*10000;
else
rank +=card*1000;
}
}
rank += multi;
return rank;
}
private function rankThree(counts:Array):int
{
var rank:int=0;
var multi:int=1;
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 1)
multi *= PokerLogic.__primes[card-1];
else if (counts[card-1] == 3)
rank = card * 100000;
}
rank += multi;
return rank;
}
private function rankFullHouse(counts:Array):int
{
var rank:int=0;
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 3)
rank+=card*1000000;
else if (counts[card-1] == 2)
rank+=card*100000;
}
return rank;
}
private function rankStraight(counts:Array):int
{
var rank:int=8000000;
if (counts[0] == 0)
rank=9000000;
return rank;
}
private function rankFour(counts:Array):int
{
var rank:int=0;
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 4)
rank+=card*10000000;
else if (counts[card-1] == 1)
rank+=card;
}
return rank;
}
private function rankFive(counts:Array):int
{
var rank:int=0;
for (var card:int=1; card<=counts.length; card++)
{
if (counts[card-1] == 5)
rank+=card*100000000;
}
return rank;
}
}
}
//singleton stuf borrowed from Jesse Freeman over at flashartofwar.com
internal class SingletonEnforcer { }
Here is a test class.
package
{
import flash.display.Sprite;
public class DicePokerTest extends Sprite
{
public function DicePokerTest()
{
var types:Array = new Array("High Card", "One Pair", "Two Pair", "Three of a Kind", "Full House", "Straight", "Four of a Kind", "Five of a Kind");
var logic:PokerLogic=PokerLogic.instance;
for (var run:Number=0; run < 5; run++)
{
trace("Test " + run);
var hand1:Array = makeRandomHand();
var hand2:Array = makeRandomHand();
var rank1:Object = logic.rankHand(hand1);
var rank2:Object = logic.rankHand(hand2);
trace("Hand 1: " + hand1 +" has value: " + rank1.rank + ", and is a " + types[rank1.type]);
trace("Hand 2: " + hand2 +" has value: " + rank2.rank + ", and is a " + types[rank2.type]);
var winner:Number=logic.compareHands(hand1, hand2);
trace("Winner is hand"+winner);
}
}
private function makeRandomHand():Array
{
var hand:Array = new Array(diceRoll(), diceRoll(), diceRoll(), diceRoll(), diceRoll());
return hand;
}
private function diceRoll():int
{
return ((Math.random()*1000)%6)+1;
}
}
}
Enjoy.
comments