pkras3

    package lib.sapphire.game.math {

    	//import lib.sapphire.data.Satellite;
    	import lib.sapphire.iface.LanguageFilter;

    	public final class HandEvaluator {

    		private static const PAIR:String = "PAIR";
    		private static const TWO_PAIR:String = "TWO PAIR";
    		private static const TRIP:String = "TRIP";
    		private static const THREE_OF_A_KIND:String = "THREE OF A KIND";
    		private static const STRAIGHT:String = "STRAIGHT";
    		private static const STRAIGHT_TO:String = "STRAIGHT TO";
    		private static const FLUSH:String = "FLUSH";
    		private static const FULL:String = "FULL";
    		private static const FULL_HOUSE:String = "FULL HOUSE";
    		private static const FOUR:String = "FOUR";
    		private static const FOUR_OF_A_KIND:String = "FOUR OF A KIND";
    		private static const STRAIGHT_FLUSH:String = "STRAIGHT FLUSH";
    		private static const ROYAL_FLUSH:String = "ROYAL FLUSH";
    		private static const WILD_ROYAL_FLUSH:String = "WILD ROYAL FLUSH";
    		private static const FIVE_OF_A_KIND:String = "FIVE OF A KIND";
    		private static const NATURAL_ROYAL_FLUSH:String = "NATURAL ROYAL FLUSH";

    		private static const BACK:String = "back";



    		public static function cardToNum(c:String):Number {
    			var ac:Object = {"A":14,"K":13,"Q":12,"J":11};
    			if (isNaN(Number(c))) {
    				return (ac[c]);
    			}
    			return (Number(c));
    		}

    		public static function cardFromNum(n:int):String {
    			if (n<11) return (String(n));
    			var ac:Array = ["J","Q","K","A"];
    			return (ac[n-11]);
    		}

    		public static function cardFromID(id:int):Object {
    			var suits:Array = ["C","D","H","S"];
    			return ({val:cardFromNum((id%13)+2),suit:suits[Math.floor(id/13)]});
    		}

    		public static function HiCard(a:Object,b:Object):Number {
    			return cardToNum(a["val"]) > cardToNum(b["val"]) ? -1 : 1;
    		}


    		private static function sr(c:Array):String {
    			var s:String = "";
    			for each (var a:Object in c) {
    				s+=a.val+a.suit;
    			}
    			return (s);
    		}

    		public static function Poker(playercards:Array,housecards:Array,byRank:Boolean = false,skipIncompleteHands:Boolean = true,
    									 																			hasSplit:Boolean = false,
    																												seat:int = -1):String {
    			//clocks at about 0.000298 seconds per eval, or about 3348/sec. on a 1.83Ghz Core (1) Duo.
    			//Note that 1 full Omaha table has to run this 540 times every 2 seconds. That's 0.16092 seconds of processing time each time,
    			//not counting the Omaha overhead.
    			if (!playercards || playercards.length<1) {
    				return ("");
    			}

    			playercards = playercards.slice();
    			housecards = housecards.slice();

    			var cards:Array = new Array();

    			for each (var hc:Object in housecards) {
    				if (!hc.dealt) {
    					continue;
    				}
    				if (skipIncompleteHands && hc.val == BACK) {
    					return ("");
    				} else if (hc.val != BACK) {
    					cards.push(hc);
    				}
    			}

    			for each (var tc:Object in playercards) {
    				if (!tc.dealt) {
    					continue;
    				}
    				if (skipIncompleteHands && tc.val == BACK) {
    					return ("");
    				} else if (tc.val != BACK) {
    					cards.push(tc);
    				}
    			}


    			if (cards.length<2) {
    				return ("");
    			}

    			var pairs:Array = new Array();
    			var found:Boolean = false;
    			var frontcount:Number = 0;

    			for each (var cp:Object in cards) {

    				//if (cp.val == "back") {
    				//	return (""); //return blank for any hand with even one back in it.
    				//}

    				found = false;
    				for (var pk:String in pairs) {
    					if (pairs[pk].val == cp.val) {
    						pairs[pk].cards.push(cp);
    						found = true;
    					}
    				}
    				if (!found) {
    					pairs.push({val:cp.val,cards:[cp]});
    				}
    			}

    			for (var pk2:String in pairs) {
    				pairs[pk2]["val"] = cardToNum(pairs[pk2].val);
    				pairs[pk2]["num"] = pairs[pk2].cards.length;
    			}

    			pairs.sortOn(["num", "val"],[Array.DESCENDING | Array.NUMERIC, Array.DESCENDING | Array.NUMERIC]);
    			var pair:Boolean = false;
    			var twopair:Boolean = false;
    			var three:Boolean = false;
    			var fullhouse:Boolean = false;
    			var four:Boolean = false;

    			if (pairs[0].num>=4) {
    				four = true;
    			} else {
    				switch (pairs[0].num) {
    					case 3:
    						three = true;
    						if (pairs[1] && pairs[1].num >=2) {
    							fullhouse = true;
    						}
    						break;
    					case 2:
    						pair = true;
    						if (pairs[1] && pairs[1].num == 2) {
    							twopair = true;
    						}
    						break;
    				}
    			}

    			//flush check//
    			var flush:String;
    			var suits:Object = {S:[],D:[],C:[],H:[]};
    			cards.sort(HiCard);
    			for each (var cf:Object in cards) {
    				suits[cf.suit].push(cf);
    				if (suits[cf.suit].length>4) {
    					flush = cf.suit;
    					break;
    				}
    			}

    			//straight check//
    			var straight:Boolean = false;
    			var cardCheck:Array;
    			if (flush) {
    				cardCheck = new Array();
    				for each (var cs:Object in cards) {
    					if (cs.suit == flush) {
    						cardCheck.push(cs);
    					}
    				}
    			} else {
    				cardCheck = cards.slice();
    			}
    			cardCheck.sort(HiCard);
    			var straightcards:Array = [cardCheck[0]];
    			var lastC:Number = cardToNum(cardCheck[0].val);
    			for each (var ccs:Object in cardCheck) {
    				if (cardToNum(ccs.val) == lastC-1) {// || (cardToNum(ccs.val) == 5 && lastC == 14)) {
    					straightcards.push(ccs);
    					//new fix:
    					if (cardToNum(ccs.val) == 2 && cardCheck[0].val == "A" && straightcards.length == 4) {
    						straightcards.push({val:"A",suit:cardCheck[0].suit});
    					} //#
    					if (straightcards.length == 5) {
    						straight = true;
    						break;
    					}
    				} else if (cardToNum(ccs.val) != lastC) {
    					straightcards = [ccs];
    				}
    				lastC = cardToNum(ccs.val);
    			}

    			//resort the wheel.
    			//DEPRECATED w/ the new fix... this was right for 5-card hands, but failed on 7-card hands...
    			/*if (straight && straightcards[0].val == "A" && straightcards[1].val == 5) {
    				straightcards.push(straightcards.shift());
    			}*/

    			//output//
    			var out:String;
    			var finalCards:Array;
    			if (straight && flush) {
    				if (straightcards[0].val == "A") {
    					out = byRank ? "0x9" : LanguageFilter.Translate(ROYAL_FLUSH);
    				} else {
    					out = byRank ? "0x9" : LanguageFilter.Translate(STRAIGHT_FLUSH);
    				}
    			} else if (four) {
    				out = byRank ? "0x8" : LanguageFilter.Translate(FOUR);
    			} else if (fullhouse) {
    				out = byRank ? "0x7" : pairs[0].cards[0].val+" "+LanguageFilter.Translate(FULL)+"/"+pairs[1].cards[0].val;
    			} else if (flush) {
    				out = byRank ? "0x6" : cardCheck[0].val+" "+LanguageFilter.Translate(FLUSH);
    			} else if (straight) {
    				out = byRank ? "0x5" : LanguageFilter.Translate(STRAIGHT_TO)+" "+straightcards[0].val;
    			} else if (three) {
    				out = byRank ? "0x4" : LanguageFilter.Translate(TRIP)+" "+pairs[0].cards[0].val+"s";
    			} else if (twopair) {
    				out = byRank ? "0x3" : LanguageFilter.Translate(TWO_PAIR)+" "+pairs[0].cards[0].val+"/"+pairs[1].cards[0].val;
    			} else if (pair) {
    				out = byRank ? "0x2" : LanguageFilter.Translate(PAIR)+" "+pairs[0].cards[0].val+"s";
    			} else {
    				out = byRank ? "0x1" : cardCheck[0].val+"-"+cardCheck[1].val+" "+LanguageFilter.Translate("HIGH");
    			}

    			if (byRank) {
    				var c:Number = 0;
    				for each (var bhc:Object in cards) {
    					c++;
    					if (c>5) {
    						break;
    					}
    					var hx:uint = uint(cardToNum(bhc.val));
    					out += hx.toString(16);
    				}
    			}
    			return (out);
    		}


    	}
    }