gamecanvas.java

几个不错的手机程序例子

						//再次抽取新牌
						i--;
						break;
					}
				}
			}
		}

		//以int值为基础，在Card数组的cards中设定值
		int index = 0;
		for(int i=0; i < cardsLeng; i++) {
			if(cards[i].getCardState() == Card.BACK_STATE) {
				cards[i].setUniqueNo(tmpCardNos[index]);
				index++;
			}
		}
	}

	/**
	 * 检查结果(牌面)的方法
	 * @return	short 传回结果的值
	 * Royal_Flush_Rate丄Five_of_a_Kind_Rate丄Straight_Flush_Rate丄Four_of_a_Kind_Rate丄
	 * Full_House_Rate丄Flush_Rate丄Straight_Rate丄Three_of_a_Kind_Rate丄Two_Pair_Rate丄
	 * Jacks_or_Better_Rate丄NOTHING偺偄偯傟偐
	 */
	private short doResultCheck() {
		//储存鬼牌的数目的变量
		int jokerCount = 0;
		//检查是否为Flush的标志
		boolean isFlush = true;
		int cardsLeng = cards.length;

		//寻找作为判定基准用的鬼牌以外的牌
		int checkBaseKind = cards[0].getUniqueNo() / 13;
		if(checkBaseKind > 3) {
		//鬼牌的时候
			//寻找鬼牌以外的牌
			for(int i=1; i < cardsLeng; i++) {
				if(cards[i].getUniqueNo() < 52) {
					//鬼牌以外
					checkBaseKind = cards[i].getUniqueNo() / 13;
					break;
				}
			}
		}

		//以数字的大小来排序
		int[] checkCardNos = new int[cards.length];
		for(int i=0; i < cardsLeng; i++) {
			//除以13来求得其种类
			int tmpKind = cards[i].getUniqueNo() / 13;
			boolean isInsert = false;
			if(tmpKind > 3) {
			//鬼牌的时候
				jokerCount++;
				for(int j=0; j < i; j++) {
					if(checkCardNos[j] > cards[i].getUniqueNo()) {
						isInsert = true;
						for(int k=i; k > j; k--) {
							checkCardNos[k] = checkCardNos[k-1];
						}
						checkCardNos[j] = cards[i].getUniqueNo();
						break;
					}
				}
				if(! isInsert) {
					checkCardNos[i] = cards[i].getUniqueNo();
				}
			}else {
			//鬼牌以外
				if(isFlush) {
				//有相同种类的扑克牌时
					if(checkBaseKind != tmpKind) {
					//种类不相同时
						isFlush = false;
					}
				}
				int tmpUniqueNo = cards[i].getUniqueNo() %13;
				for(int j=0; j < i; j++) {
					if(checkCardNos[j] > tmpUniqueNo) {
						isInsert = true;
						for(int k=i; k > j; k--) {
							checkCardNos[k] = checkCardNos[k-1];
						}
						checkCardNos[j] = tmpUniqueNo;
						break;
					}
				}
				if(! isInsert) {
					checkCardNos[i] = tmpUniqueNo;
				}
			}
		}

		int tmpCardNo, tmpCardNo2;
		int tmpJokerCount = jokerCount;
		int checkIndex = 0;
		if(isFlush) {
		//有可能为Flush时
			//检查是否为Royal Straight Flush
			tmpCardNo = checkCardNos[checkIndex];
			if(tmpCardNo == 0 || tmpJokerCount > 0) {// 检查是否为A
			//现在所检查的扑克牌为0(A)或者有1张以上的鬼牌时
				if(tmpCardNo != 0) {
				//现在所检查的扑克牌不是为0(A)时
					//使用1张鬼牌
					tmpJokerCount--;
				}else {
				//现在所检查的扑克牌为0(A)时
					//进行检查下一张扑克牌的准备
					checkIndex++;
					tmpCardNo = checkCardNos[checkIndex];
				}

				if(tmpCardNo == 9 || tmpJokerCount > 0) { //检查是否为10
				//现在所检查的扑克牌为9(10)或有1张以上的鬼牌时
					if(tmpCardNo != 9) {
					//现在所检查的扑克牌不是9(10)的时候
						//使用1张鬼牌
						tmpJokerCount--;
					}else {
					//现在所检查的扑克牌为9(10)的时候
						//进行检查下一张扑克牌的准备
						checkIndex++;
						tmpCardNo = checkCardNos[checkIndex];
					}

					if(tmpCardNo == 10 || tmpJokerCount > 0) { //检查是否为11
					//现在所检查的扑克牌为10(J)或有1张以上的鬼牌时
						if(tmpCardNo != 10) {
						//现在所检查的扑克牌不是10(J)时
							//使用1张鬼牌
							tmpJokerCount--;
						}else {
						//现在所检查的扑克牌为10(J)时
							//进行检查下一张扑克牌的准备
							checkIndex++;
							tmpCardNo = checkCardNos[checkIndex];
						}

						if(tmpCardNo == 11 || tmpJokerCount > 0) { //检查是否为12
						//现在所检查的扑克牌为11(Q)或有1张以上的鬼牌时
							if(tmpCardNo != 11) {
							//现在所检查的扑克牌为11(Q)时
								//使用1张鬼牌
								tmpJokerCount--;
							}else {
							//现在所检查的扑克牌不是为11(Q)时
								//进行检查下一张扑克牌的准备
								checkIndex++;
								tmpCardNo = checkCardNos[checkIndex];
							}

							if(tmpCardNo == 12 || tmpJokerCount > 0) { //检查是否为13
							//现在所检查的扑克牌为12(K)或有1张以上的鬼牌时
								//判定为Royal Straight Flush
								//没有必要再进行处理，直接传回Royal Straight Flush
								return Royal_Flush_Rate;
							}
						}
					}
				}
			}

			//Straight Flush的检查
			checkIndex = 0;
			tmpCardNo = checkCardNos[checkIndex];
			if(tmpCardNo < 9 || tmpJokerCount > 0) {
			//由於Straight Flush开始一定要为9(10)的牌以下才能成立，
			//因此只有在一开始的扑克牌为9(10)以下才进行处理
				tmpJokerCount = jokerCount;

				checkIndex++;
				tmpCardNo2 = checkCardNos[checkIndex];
				if(tmpCardNo2 == tmpCardNo +1 || tmpJokerCount > 0) { //第2张
				//第2张扑克牌为第1章扑克牌的值+1、或者是有鬼牌存在时
					if(tmpCardNo2 != tmpCardNo +1) {
					//第2张扑克牌不是为第1张扑克牌的值+1时
						//使用1张鬼牌
						tmpJokerCount--;
					}else {
					//第2张扑克牌为第1张扑克牌的值+1时
						//进行检查下一张扑克牌的准备
						checkIndex++;
						tmpCardNo2 = checkCardNos[checkIndex];
					}

					if(tmpCardNo2 == tmpCardNo +2 || tmpJokerCount > 0) { //第3张
					//第3张扑克牌为第1张扑克牌的值+2、或者是有鬼牌存在时
						if(tmpCardNo2 != tmpCardNo +2) {
						//第3张扑克牌不是为第1张扑克牌的值+2时
							//使用1张鬼牌
							tmpJokerCount--;
						}else {
						//第3张扑克牌为第1张扑克牌的值+2时
							//进行检查下一张扑克牌的准备
							checkIndex++;
							tmpCardNo2 = checkCardNos[checkIndex];
						}

						if(tmpCardNo2 == tmpCardNo +3 || tmpJokerCount > 0) { //第4张
						//第4张扑克牌为第1张扑克牌的值+3、或者是有鬼牌存在时
							if(tmpCardNo2 != tmpCardNo +3) {
							//第4张扑克牌不是为第1张扑克牌的值+3时
							//使用1张鬼牌
								tmpJokerCount--;
							}else {
							//第4张扑克牌为第1张扑克牌的值+3
								//进行检查下一张扑克牌的准备
								checkIndex++;
								tmpCardNo2 = checkCardNos[checkIndex];
							}

							if(tmpCardNo2 == tmpCardNo +4 || tmpJokerCount > 0) { // 5枃栚
							//第5张扑克牌为第1张扑克牌的值+4、或者有鬼牌时

								//这样就不可能是Five Card，因此传回Straight Flush
								return Straight_Flush_Rate;
							}
						}
					}
				}
			}

			//第5张扑克牌为第1张扑克牌的值+4、或者有鬼牌时
			//这样就不可能是Five Card，因此传回Straight Flush
			return Flush_Rate;
		}

		//Straight的检查
		checkIndex = 0;
		tmpCardNo = checkCardNos[checkIndex];
		if( tmpCardNo < 9 && jokerCount == 0 ||
			tmpCardNo < 10 && jokerCount == 1 ||
			tmpCardNo < 11 && jokerCount == 2) {
		//现在所检查的扑克牌若不是比9还小则Straight并不会成立
		//比9(10)还小时
		//比10(J)还小与有1张鬼牌时
		//比11(Q)还小与有1张鬼牌时
			tmpJokerCount = jokerCount;

			checkIndex++;
			tmpCardNo2 = checkCardNos[checkIndex];
			if(tmpCardNo2 == tmpCardNo +1 || tmpJokerCount > 0) { //第2张
			//第2张扑克牌为第1章扑克牌的值+1、或者是有鬼牌存在时
				if(tmpCardNo2 != tmpCardNo +1) {
				//第2张扑克牌不是为第1张扑克牌的值+1时
					//使用1张鬼牌
					tmpJokerCount--;
				}else {
				//第2张扑克牌为第1张扑克牌的值+1时
					//进行检查下一张扑克牌的准备
					checkIndex++;
					tmpCardNo2 = checkCardNos[checkIndex];
				}

				if(tmpCardNo2 == tmpCardNo +2 || tmpJokerCount > 0) { //第3张
				//第3张扑克牌为第1张扑克牌的值+2、或者是有鬼牌存在时
					if(tmpCardNo2 != tmpCardNo +2) {
					//第3张扑克牌不是为第1张扑克牌的值+2时
					//使用1张鬼牌
						tmpJokerCount--;
					}else {
					//第3张扑克牌为第1张扑克牌的值+2时
						//进行检查下一张扑克牌的准备
						checkIndex++;
						tmpCardNo2 = checkCardNos[checkIndex];
					}

					if(tmpCardNo2 == tmpCardNo +3 || tmpJokerCount > 0) { //第4张
					//第4张扑克牌为第1张扑克牌的值+3、或者是有鬼牌存在时
						if(tmpCardNo2 != tmpCardNo +3) {
						//第4张扑克牌为第1张扑克牌的值+3
							//使用1张鬼牌
							tmpJokerCount--;
						}else {
						//第4张扑克牌为第1张扑克牌的值+3
							//进行检查下一张扑克牌的准备
							checkIndex++;
							tmpCardNo2 = checkCardNos[checkIndex];
						}

						if(tmpCardNo2 == tmpCardNo +4 || tmpJokerCount > 0) { //第5张
						//第5张扑克牌为第1张扑克牌的值+4、或者有鬼牌时
							//这样就只有可能是Five Card，因此传回Straight
							return Straight_Rate;
						}
					}
				}
			}
		}

		//计算同样数字的扑克牌
		int[] sameNoCounts = new int[13];//储存了同样数字的数目的数组变量
		int sameNoSize = 0;
		for(int i=0; i < cardsLeng -jokerCount; i++) {
			if(sameNoCounts[checkCardNos[i]] == 0) {
				sameNoSize++;
			}
			sameNoCounts[checkCardNos[i]]++;
		}

		if(sameNoSize == 5) {
		//若在这时候有5种数字的话，就不符合任何牌面
			return NOTHING;

		}else if(sameNoSize == 4){
		//若在这时候有4种数字的话，就一定只有One Pair
		//牌面或鬼牌有One Pair
			if(jokerCount > 0) {
			//有鬼牌的时候
				if(	sameNoCounts[0] > 0 || sameNoCounts[10] > 0 ||
					sameNoCounts[11] > 0 || sameNoCounts[12] > 0) {
				//有1张10(J)以上的扑克牌时
					//传回One Pair
					return Jacks_or_Better_Rate;
				}else {
				//处理到了这个位置时一定没有符合任何牌面
					return NOTHING;
				}
			}else {
			//没有鬼牌时
				if(	sameNoCounts[0] > 1 || sameNoCounts[10] > 1 ||
					sameNoCounts[11] > 1 || sameNoCounts[12] > 1) {
				//有2张10(J)以上的扑克牌时,传回One Pair
					return Jacks_or_Better_Rate;
				}else {
				//处理到了这个位置时一定没有符合任何牌面
					return NOTHING;
				}
			}

		}else if(sameNoSize == 3){
		//若在这时候有3种数字的话，就一定是Two Pair
			if(jokerCount > 0) {
			//有2张或是1张鬼牌时为Three Card
				//传回Three Card
				return Three_of_a_Kind_Rate;
			}else {
			//没有鬼牌时
				//若有3种扑克牌、且有3个相同数字时为Three Card
				for(int i=0; i < sameNoCounts.length; i++) {
					if(sameNoCounts[i] > 2) {
					//有两张鬼牌时
						return Three_of_a_Kind_Rate;
					}
				}
			}
			//处理到这个位置时为Two Pair
			return Two_Pair_Rate;

		}else if(sameNoSize == 2) {
		//有2种数字时
			//检查为Four Card或是Full Hourse
			if(jokerCount == 2) {
			//有2张鬼牌时
				//Four Card
				return Four_of_a_Kind_Rate;

			}else if(jokerCount == 1) {
			//有1张鬼牌时
				//Four Card或是Full Hourse
				for(int i=0; i < sameNoCounts.length; i++) {
					if(sameNoCounts[i] > 2) {
					//有3张扑克牌为相同数字时为Four Card
						return Four_of_a_Kind_Rate;
					}
				}
				//处理到这个位置时为Full House
				return Full_House_Rate;
			}else {
			//没有鬼牌时
				//Four Card或是Full Hourse
				for(int i=0; i < sameNoCounts.length; i++) {
					if(sameNoCounts[i] > 3) {
					//有相同数字的4张牌时为Four Card
						return Four_of_a_Kind_Rate;
					}
				}
				//处理到这个位置时为Full House
				return Full_House_Rate;
			}
		}else {
		//只有1种数字时
			//Three Card与2张鬼牌、或是Four Card与1张鬼牌
			//传回Four Card
			return Five_of_a_Kind_Rate;
		}
	}
}