在好例子网,分享、交流、成长!
您当前所在位置:首页Java 开发实例Android平台开发 → qq斗地主游戏app源码

qq斗地主游戏app源码

Android平台开发

下载此实例
  • 开发语言:Java
  • 实例大小:10.98M
  • 下载次数:47
  • 浏览次数:660
  • 发布时间:2018-03-26
  • 实例类别:Android平台开发
  • 发 布 人:xiaolovet
  • 文件格式:.zip
  • 所需积分:2
 相关标签: QQ 斗地主

实例介绍

【实例简介】android 4.0系统上测试 如下效果(没能自适应),但基本逻辑已实现,仅供参考学习

【实例截图】

from clipboard


from clipboard

【核心代码】

package com.peiandsky;

import java.util.Random;
import java.util.Vector;

import android.widget.Toast;

public class Poke {
	public static Random rand = new Random();

	public static void show(String text, int time) {
		Toast t = Toast.makeText(DDZ.ddz, text, time);
		t.show();
	}

	public static boolean inRect(int x, int y, int rectX, int rectY, int rectW,
			int rectH) {
		if (x < rectX || x > rectX   rectW || y < rectY || y > rectY   rectH) {
			return false;
		}
		return true;
	}

	// 0-53表示54张牌
	public static void shuffle(int[] pokes) {
		int len = pokes.length;
		// 对于54张牌中的任何一张,都随机找一张和它互换,将牌顺序打乱。
		for (int l = 0; l < len; l  ) {
			int des = rand.nextInt(54);
			int temp = pokes[l];
			pokes[l] = pokes[des];
			pokes[des] = temp;
		}
	}

	public static int getDZ() {
		return rand.nextInt(3);
		// return 0;
	}

	// 对pokes进行从大到小排序,采用冒泡排序
	public static void sort(int[] pokes) {
		for (int i = 0; i < pokes.length; i  ) {
			for (int j = i   1; j < pokes.length; j  ) {
				if (pokes[i] < pokes[j]) {
					int temp = pokes[i];
					pokes[i] = pokes[j];
					pokes[j] = temp;
				}
			}
		}
	}

	/**
	 * 16小王,17大王
	 */
	public static int getPokeValue(int poke) {
		// 当扑克值为52时,是小王
		if (poke == 52) {
			return 16;
		}
		// 当扑克值为53时,是大王
		if (poke == 53) {
			return 17;
		}
		// 其它情况下返回相应的值(3,4,5,6,7,8,9,10,11(J),12(Q),13(K),14(A),15(2))
		return poke / 4   3;
	}

	public static int getImageRow(int poke) {
		return poke / 13;
	}

	public static int getImageCol(int poke) {
		return poke % 13;
	}

	/**
	 * 是不是一个有效的牌型
	 * 
	 * @param pokes
	 * @return
	 */
	public static boolean isCard(int[] pokes) {
		if (getPokeType(pokes) == PokeType.error)
			return false;
		return true;
	}

	/**
	 * pokes中的牌的顺序要按照牌的值排列,顺牌中不包含2
	 * 
	 * @param pokes
	 * @return
	 */
	public static int getPokeType(int[] pokes) {
		int len = pokes.length;
		// 当牌数量为1时,单牌
		if (len == 1) {
			return PokeType.danpai;
		}
		// 当牌数量为2时,可能是对牌和火箭
		if (len == 2) {
			if (pokes[0] == 53 && pokes[1] == 52) {
				return PokeType.huojian;
			}
			if (getPokeValue(pokes[0]) == getPokeValue(pokes[1])) {
				return PokeType.duipai;
			}
		}
		// 当牌数为3时,只可能是三顺
		if (len == 3) {
			if (getPokeValue(pokes[0]) == getPokeValue(pokes[1])
					&& getPokeValue(pokes[2]) == getPokeValue(pokes[1])) {
				return PokeType.sanzhang;
			}
		}
		// 当牌数为4时,可能是三带一或炸弹
		if (len == 4) {
			int firstCount = getPokeCount(pokes, pokes[0]);
			if (firstCount == 3 || getPokeCount(pokes, pokes[1]) == 3) {
				return PokeType.sandaiyi;
			}
			if (firstCount == 4) {
				return PokeType.zhadan;
			}
		}
		// 当牌数大于5时,判断是不是单顺
		if (len >= 5) {
			if (shunzi(pokes)) {
				return PokeType.danshun;
			}

		}
		// 当牌数为6时,四带二
		if (len == 6) {
			boolean have4 = false;
			boolean have1 = false;
			for (int i = 0; i < len; i  ) {
				int c = getPokeCount(pokes, pokes[i]);
				if (c == 4) {
					have4 = true;
				}
				if (c == 1) {
					have1 = true;
				}
			}

			if (have4 && have1) {
				return PokeType.sidaier;
			}
		}
		// 当牌数大于等于6时,先检测是不是双顺和三顺
		if (len >= 6) {
			// 双顺
			boolean shuangshunflag = true;
			for (int i = 0; i < len; i  ) {
				if (getPokeCount(pokes, pokes[i]) != 2) {
					shuangshunflag = false;
					break;
				}
			}
			if (shuangshunflag) {
				int[] tempPokes = new int[len / 2];
				for (int i = 0; i < len / 2; i  ) {
					tempPokes[i] = pokes[i * 2];
				}
				if (shunzi(tempPokes)) {
					return PokeType.shuangshun;
				}
			}
			System.out.println("shuangshun:"   shuangshunflag);
			// 三顺
			boolean sanshunflag = true;
			for (int i = 0; i < len; i  ) {
				if (getPokeCount(pokes, pokes[i]) != 3) {
					sanshunflag = false;
					break;
				}
			}
			if (sanshunflag) {
				int[] tempPokes = new int[len / 3];
				for (int i = 0; i < len / 3; i  ) {
					tempPokes[i] = pokes[i * 3];
				}
				if (shunzi(tempPokes)) {
					return PokeType.sanshun;
				}
			}

		}

		// 当牌数大于等于8,且能够被4整除时,判断是不是飞机
		if (len >= 8 && len % 4 == 0) {
			UniqInt ui = new UniqInt();
			int have1 = 0;
			for (int i = 0; i < pokes.length; i  ) {
				int c = getPokeCount(pokes, pokes[i]);
				if (c == 3) {
					ui.addInt(pokes[i]);
				} else if (c == 1) {
					have1  ;
				}
			}
			if (ui.size() == have1) {
				int[] tempArray = ui.getArray();
				sort(tempArray);
				if (shunzi(tempArray)) {
					return PokeType.feiji;
				}
			}

		}
		// 如果不是可知牌型,返回错误型
		return PokeType.error;

	}

	/**
	 * 判断是不是顺子
	 * 
	 * @param pokes
	 * @return
	 */
	public static boolean shunzi(int[] pokes) {
		int start = getPokeValue(pokes[0]);
		// 顺子中不能包含2,king
		if (start >= 15) {
			return false;
		}
		int next;
		for (int i = 1; i < pokes.length; i  ) {
			next = getPokeValue(pokes[i]);
			if (start - next != 1) {
				return false;
			}
			start = next;
		}
		return true;
	}

	// 统计一手牌中同值的牌出现的次数来判断是对牌,三顺,三带一,炸弹,四代二等
	public static int getPokeCount(int[] pokes, int poke) {
		int count = 0;
		for (int i = 0; i < pokes.length; i  ) {
			if (getPokeValue(pokes[i]) == getPokeValue(poke)) {
				count  ;
			}
		}
		return count;
	}

	// 通过给给出的一手牌,来返回它的牌值大小,pokes中的顺序是排列好的
	public static int getPokeTypeValue(int[] pokes, int pokeType) {
		// 这几种类型直接返回第一个值
		if (pokeType == PokeType.danpai || pokeType == PokeType.duipai
				|| pokeType == PokeType.danshun || pokeType == PokeType.sanshun
				|| pokeType == PokeType.shuangshun
				|| pokeType == PokeType.sanzhang || pokeType == PokeType.zhadan) {
			return getPokeValue(pokes[0]);
		}
		// 三带一和飞机返回数量为3的牌的最大牌值
		if (pokeType == PokeType.sandaiyi || pokeType == PokeType.feiji) {
			for (int i = 0; i <= pokes.length - 3; i  ) {
				if (getPokeValue(pokes[i]) == getPokeValue(pokes[i   1])
						&& getPokeValue(pokes[i   1]) == getPokeValue(pokes[i   2])) {
					return getPokeValue(pokes[i]);
				}
			}
		}
		// 四带二返回数量为4的牌值
		if (pokeType == PokeType.sidaier) {
			for (int i = 0; i < pokes.length - 3; i  ) {
				if (getPokeValue(pokes[i]) == getPokeValue(pokes[i   1])
						&& getPokeValue(pokes[i   1]) == getPokeValue(pokes[i   2])
						&& getPokeValue(pokes[i   2]) == getPokeValue(pokes[i   3])) {
					return getPokeValue(pokes[i]);
				}
			}
		}
		return 0;
	}

	/**
	 * true 第一个大
	 * 
	 * @param f
	 * @param s
	 * @return
	 */
	public static boolean compare(Card f, Card s) {
		// 当两种牌型相同时
		if (f.pokeType == s.pokeType) {
			// 两手牌牌型相同时,数量不同将无法比较,默认为第二个大,使s不能出牌
			if (f.pokes.length != s.pokes.length)
				return false;
			// 牌型相同,数量相同时,比较牌值
			return f.value > s.value;
		}
		// 在牌型不同的时候,如果f的牌型是火箭,则返回true
		if (f.pokeType == PokeType.huojian) {
			return true;
		}
		if (s.pokeType == PokeType.huojian) {
			return false;
		}
		// 排除火箭的类型,炸弹最大
		if (f.pokeType == PokeType.zhadan) {
			return true;
		}
		if (s.pokeType == PokeType.zhadan) {
			return false;
		}
		// 无法比较的情况,默认为s大于f
		return false;
	}

	public int[] findBigThanCard(Card card, int pokes[]) {
		return null;

	}

	public static int[] outCardByItsself(int pokes[], Person last, Person next) {
		AnalyzePoke analyze = AnalyzePoke.getInstance();
		analyze.setPokes(pokes);
		int cardArray[] = null;
		Vector<int[]> card_danpai = analyze.getCard_danpai();
		Vector<int[]> card_sanshun = analyze.getCard_sanshun();

		int danpai = card_danpai.size();
		int sanshun = card_sanshun.size();

		int[] miniType = analyze.getMinType(last, next);
		System.out.println("miniType:"   miniType[0]   ","   miniType[1]);
		switch (miniType[0]) {
		case PokeType.sanshun:
			// 先出三顺和飞机
			System.out.println("sanshun is over");
			if (sanshun > 0) {
				cardArray = card_sanshun.elementAt(miniType[1]);

				if (cardArray.length / 3 < danpai) {
					int[] desArray = new int[cardArray.length / 3 * 4];
					for (int i = 0; i < cardArray.length; i  ) {
						desArray[i] = cardArray[i];
					}
					for (int j = 0; j < cardArray.length / 3; j  ) {
						desArray[cardArray.length   j] = card_danpai
								.elementAt(j)[0];
					}
					Poke.sort(desArray);
					return desArray;
				} else {
					return cardArray;
				}
			}
			break;
		case PokeType.shuangshun:
			System.out.println("shuangshun is over");
			Vector<int[]> card_shuangshun = analyze.getCard_shuangshun();
			System.out.println("shuangshun:"   card_shuangshun.size());
			if (card_shuangshun.size() > 0) {
				cardArray = card_shuangshun.elementAt(miniType[1]);
				return cardArray;
			}
			break;
		case PokeType.danshun:
			System.out.println("danshun is over");
			Vector<int[]> card_danshun = analyze.getCard_danshun();
			if (card_danshun.size() > 0) {
				return card_danshun.elementAt(miniType[1]);
			}
			break;
		case PokeType.sanzhang:
			System.out.println("sanzhang is over");
			Vector<int[]> card_sanzhang = analyze.getCard_sanzhang();
			if (card_sanzhang.size() > 0) {
				int[] sanzhangArray = card_sanzhang.elementAt(miniType[1]);
				if (danpai > 0) {
					int newA[] = new int[] { sanzhangArray[0],
							sanzhangArray[1], sanzhangArray[2],
							card_danpai.elementAt(0)[0] };
					Poke.sort(newA);
					return newA;
				} else {
					return sanzhangArray;
				}
			}
			break;
		case PokeType.duipai:
			System.out.println("duipai is over");
			Vector<int[]> card_duipai = analyze.getCard_duipai();
			if (card_duipai.size() > 0) {
				return card_duipai.elementAt(miniType[1]);
			}
			break;
		case PokeType.danpai:
			System.out.println("danpai is over");
			if (danpai > 0) {
				return card_danpai.elementAt(miniType[1]);
			}
			break;
		}

		Vector<int[]> card_zhadan = analyze.getCard_zhadan();
		if (card_zhadan.size() > 0) {
			return card_zhadan.elementAt(0);
		}
		// 还需要判断下家的牌,是否是同盟
		// 出最大的单牌,上别人说去吧!
		return new int[] { pokes[0] };
	}

	// 出牌智能
	public static int[] findTheRightCard(Card card, int pokes[], Person last,
			Person next) {
		AnalyzePoke an = AnalyzePoke.getInstance();
		an.setPokes(pokes);
		int c = an.remainCount();
		// 当玩家只剩下一手牌的时候,无论如何都要出牌
		if (c == 1) {
			return findBigThanCardSimple2(card, pokes, 100);
		}

		// 判断我该不该要牌
		if (Desk.boss != last.id && Desk.boss != next.id) {
			// 我是boss,就要要牌
			// 判断他的剩余牌数
			int pokeLength = Desk.persons[card.personID].pokes.length;
			int must = pokeLength * 100 / 17;
			if (pokeLength <= 2) {
				must = 100;
			}
			return findBigThanCardSimple2(card, pokes, must);

		} else {
			if (Desk.boss == card.personID) {
				// 是地主出的牌,要牌
				int pokeLength = Desk.persons[card.personID].pokes.length;
				int must = pokeLength * 100 / 17;
				if (pokeLength <= 2) {
					must = 100;
				}
				return findBigThanCardSimple2(card, pokes, must);
			} else {
				// 我不是地主,牌也不是地主的牌,是自己家的牌
				if (card.personID == next.id) {
					// 不要牌,让他继续出,除非我一次出完
					if (c <= 3) {
						return findBigThanCardSimple2(card, pokes, 100);
					}
					return null;
				} else {
					// 牌的大小如果大于一定值我不要,否则我顺一个
					if (card.value < 12) {
						int pokeLength = Desk.persons[card.personID].pokes.length;
						int must = 100 - pokeLength * 100 / 17;
						if (pokeLength <= 4) {
							must = 0;
						}
						AnalyzePoke ana = AnalyzePoke.getInstance();
						ana.setPokes(next.pokes);
						if (ana.remainCount() <= 1) {
							if (ana.lastCardTypeEq(card.pokeType)
									&& (Desk.boss == next.id || (Desk.boss != next.id && Desk.boss != last.id))) {
								return findBigThanCardSimple2(card, pokes, 100);
							}
						} else {
							return findBigThanCardSimple2(card, pokes, must);
						}

					} else {
						return null;
					}
				}
			}
		}
		return null;
	}

	// 从pokes数组中找到比card大的一手牌
	public static int[] findBigThanCardSimple2(Card card, int pokes[], int must) {
		try {
			// 获取card的信息,牌值,牌型
			int[] cardPokes = card.pokes;
			int cardValue = card.value;
			int cardType = card.pokeType;
			int cardLength = cardPokes.length;
			// 使用AnalyzePoke来对牌进行分析
			AnalyzePoke analyz = AnalyzePoke.getInstance();
			analyz.setPokes(pokes);

			Vector<int[]> temp;
			int size = 0;
			// 根据适当牌型选取适当牌
			switch (cardType) {
			case PokeType.danpai:
				temp = analyz.getCard_danpai();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					int v = Poke.getPokeValue(cardArray[0]);
					if (v > cardValue) {
						return cardArray;
					}
				}
				// 如果单牌中没有,则选择现有牌型中除火箭和4个2后的最大一个
				int st = 0;
				if (analyz.getCountWang() == 2) {
					st  = 2;
				}
				if (analyz.getCount2() == 4) {
					st  = 4;
				}
				if (Poke.getPokeValue(pokes[st]) > cardValue)
					return new int[] { pokes[st] };

				// 检查炸弹,根据紧迫性几率出牌,如果下家是和自己一伙的则顺延给下家

				break;
			case PokeType.duipai:
				temp = analyz.getCard_duipai();
				size = temp.size();

				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					int v = Poke.getPokeValue(cardArray[0]);
					if (v > cardValue) {
						return cardArray;
					}
				}

				// 如果对子中没有,则需要检查双顺
				temp = analyz.getCard_shuangshun();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					for (int j = cardArray.length - 1; j > 0; j--) {
						int v = Poke.getPokeValue(cardArray[j]);
						if (v > cardValue) {
							return new int[] { cardArray[j], cardArray[j - 1] };
						}
					}
				}
				// 如果双顺中没有,则需要检查三张
				temp = analyz.getCard_sanzhang();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					int v = Poke.getPokeValue(cardArray[0]);
					if (v > cardValue) {
						return new int[] { cardArray[0], cardArray[1] };
					}
				}
				// 如果三张中没有,则就考虑炸弹,下家也可以顺牌

				break;
			case PokeType.sanzhang:
				temp = analyz.getCard_sanzhang();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					int v = Poke.getPokeValue(cardArray[0]);
					if (v > cardValue) {
						return cardArray;
					}
				}
				break;
			case PokeType.sandaiyi:
				if (pokes.length < 4) {
					break;
				}
				boolean find = false;
				int[] sandaiyi = new int[4];
				temp = analyz.getCard_sanzhang();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] cardArray = temp.get(i);
					int v = Poke.getPokeValue(cardArray[0]);
					if (v > cardValue) {
						for (int j = 0; j < cardArray.length; j  ) {
							sandaiyi[j] = cardArray[j];
							find = true;
						}
					}
				}
				// 没有三张满足条件
				if (!find) {
					break;
				}
				// 再找一张组合成三带一
				temp = analyz.getCard_danpai();
				size = temp.size();
				if (size > 0) {
					int[] t = temp.get(0);
					sandaiyi[3] = t[0];
				} else {
					temp = analyz.getCard_danshun();
					size = temp.size();
					for (int i = 0; i < size; i  ) {
						int[] danshun = temp.get(i);
						if (danshun.length >= 6) {
							sandaiyi[3] = danshun[0];
						}
					}
				}
				// 从中随便找一个最小的
				if (sandaiyi[3] == 0) {
					for (int i = pokes.length - 1; i >= 0; i--) {
						if (Poke.getPokeValue(pokes[i]) != Poke
								.getPokeValue(sandaiyi[0])) {
							sandaiyi[3] = pokes[i];
						}
					}
				}
				if (sandaiyi[3] != 0) {
					Poke.sort(sandaiyi);
					return sandaiyi;
				}
				break;
			case PokeType.danshun:// 还值得优化
				temp = analyz.getCard_danshun();
				size = temp.size();
				for (int i = 0; i < size; i  ) {
					int[] danshun = temp.get(i);
					if (danshun.length == cardLength) {
						if (cardValue < Poke.getPokeValue(danshun[0])) {
							return danshun;
						}
					}
				}
				for (int i = 0; i < size; i  ) {
					int[] danshun = temp.get(i);
					if (danshun.length > cardLength) {
						if (danshun.length < cardLength
								|| danshun.length - cardLength >= 3) {
							if (rand.nextInt(100) < must) {
								if (cardValue >= Poke.getPokeValue(danshun[0])) {
									continue;
								}

								int index = 0;
								for (int k = 0; k < danshun.length; k  ) {
									if (cardValue < Poke
											.getPokeValue(danshun[k])) {
										index = k;
									} else {
										break;
									}
								}

								if (index   cardLength > danshun.length) {
									index = danshun.length - cardLength;
								}
								int[] newArray = new int[cardLength];
								int n = 0;
								for (int m = index; m < danshun.length; m  ) {
									newArray[n  ] = danshun[m];
								}
								return newArray;
							}
							break;
						}
						if (cardValue >= Poke.getPokeValue(danshun[0])) {
							continue;
						}
						int start = 0;
						int end = 0;
						if (danshun.length - cardLength == 1) {
							if (cardValue < Poke.getPokeValue(danshun[1])) {
								start = 1;
							} else {
								start = 0;
							}
						} else if (danshun.length - cardLength == 2) {
							if (cardValue < Poke.getPokeValue(danshun[2])) {
								start = 2;
							} else if (cardValue < Poke
									.getPokeValue(danshun[1])) {
								start = 1;
							} else {
								start = 0;
							}
						}
						int[] dan = new int[cardLength];
						int m = 0;
						for (int k = start; k < danshun.length; k  ) {
							dan[m  ] = danshun[k];
						}
						return dan;
					}
				}
				break;
			case PokeType.shuangshun:
				temp = analyz.getCard_shuangshun();
				size = temp.size();

				for (int i = size - 1; i >= 0; i--) {
					int cardArray[] = temp.get(i);
					if (cardArray.length < cardLength) {
						continue;
					}

					if (cardValue < Poke.getPokeValue(cardArray[0])) {
						if (cardArray.length == cardLength) {
							return cardArray;
						} else {
							int d = (cardArray.length - cardLength) / 2;
							int index = 0;
							for (int j = cardArray.length - 1; j >= 0; j--) {
								if (cardValue < Poke.getPokeValue(cardArray[j])) {
									index = j / 2;
									break;
								}
							}

							int total = cardArray.length / 2;
							int cardTotal = cardLength / 2;
							if (index   cardTotal > total) {
								index = total - cardTotal;
							}
							int shuangshun[] = new int[cardLength];
							int m = 0;
							for (int k = index * 2; k < cardArray.length; k  ) {
								shuangshun[m  ] = cardArray[k];
							}
							return shuangshun;
						}
					}
				}
				break;
			case PokeType.sanshun:
				temp = analyz.getCard_sanshun();
				size = temp.size();
				for (int i = size - 1; i >= 0; i--) {
					int[] cardArray = temp.get(i);
					if (cardLength > cardArray.length) {
						continue;
					}

					if (cardValue < Poke.getPokeValue(cardArray[0])) {
						if (cardLength == cardArray.length) {
							return cardArray;
						} else {
							int[] newArray = new int[cardLength];
							for (int k = 0; k < cardLength; k  ) {
								newArray[k] = cardArray[k];
							}
							return newArray;
						}
					}
				}
				break;
			case PokeType.feiji:
				// 暂时不处理
				break;
			case PokeType.zhadan:
				temp = analyz.getCard_zhadan();
				size = temp.size();
				int zd[] = null;
				if (size > 0) {
					for (int i = 0; i < size; i  ) {
						zd = temp.elementAt(i);
						if (cardValue < Poke.getPokeValue(zd[0])) {
							return zd;
						}
					}
				}
				break;
			case PokeType.huojian:
				return null;
			case PokeType.sidaier:
				// 暂时不处理,留待读者完成
				break;
			}
			// TODO 如果可以一次性出完,无论如何都要,留待读者完成
			// 根据must的值来判断要牌的必要性
			boolean needZd = false;
			if (must < 90) {
				must *= 0.2;
				if (rand.nextInt(100) < must) {
					needZd = true;
				}
			} else {
				needZd = true;
			}
			if (needZd) {
				temp = analyz.getCard_zhadan();
				size = temp.size();
				if (size > 0) {
					return temp.elementAt(size - 1);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	// public static int[] findBigThanCardSimple(Card card, int pokes[]) {
	// int cardType = card.pokeType;
	// int value = card.value;
	// int[] pokeWanted = new int[card.pokes.length];
	// boolean find = false;
	//
	// if (card.pokes.length <= pokes.length) {
	// switch (cardType) {
	// case PokeType.danpai:
	// for (int i = pokes.length - 1; i >= 0; i--) {
	// if (getPokeValue(pokes[i]) > value) {
	// pokeWanted[0] = pokes[i];
	// // pokes[i] = -1;
	// find = true;
	// break;
	// }
	// }
	// break;
	// case PokeType.duipai:
	// for (int i = pokes.length - 1; i > 0; i--) {
	// if (getPokeValue(pokes[i]) > value
	// && getPokeValue(pokes[i]) == getPokeValue(pokes[i - 1])) {
	// pokeWanted[0] = pokes[i];
	// pokeWanted[1] = pokes[i - 1];
	// // pokes[i] = -1;
	// // pokes[i - 1] = -1;
	// find = true;
	// break;
	// }
	// }
	// break;
	// case PokeType.sanzhang:
	// for (int i = pokes.length - 1; i > 1; i--) {
	// if (getPokeValue(pokes[i]) > value
	// && getPokeValue(pokes[i]) == getPokeValue(pokes[i - 1])
	// && getPokeValue(pokes[i]) == getPokeValue(pokes[i - 2])) {
	// pokeWanted[0] = pokes[i];
	// pokeWanted[1] = pokes[i - 1];
	// pokeWanted[2] = pokes[i - 2];
	// // pokes[i] = -1;
	// // pokes[i - 2] = -1;
	// // pokes[i - 1] = -1;
	// find = true;
	// break;
	// }
	// }
	// break;
	// case PokeType.sandaiyi:
	// for (int i = pokes.length - 1; i >= 2; i--) {
	// if (getPokeValue(pokes[i]) > value
	// && getPokeValue(pokes[i]) == getPokeValue(pokes[i - 1])
	// && getPokeValue(pokes[i]) == getPokeValue(pokes[i - 2])) {
	// pokeWanted[0] = pokes[i];
	// pokeWanted[1] = pokes[i - 1];
	// pokeWanted[2] = pokes[i - 2];
	// // pokes[i] = -1;
	// // pokes[i - 2] = -1;
	// // pokes[i - 1] = -1;
	//
	// if (i   1 >= pokes.length) {
	// if (i - 3 > 0) {
	// find = false;
	// } else {
	// pokeWanted[3] = pokes[i - 3];
	// // pokes[i - 3] = -1;
	// find = true;
	// break;
	// }
	// } else {
	// pokeWanted[3] = pokes[i   1];
	// // pokes[i   1] = -1;
	// find = true;
	// break;
	// }
	// }
	// }
	//
	// break;
	// case PokeType.danshun:// test
	// int minValue = value - card.pokes.length   1;
	// for (int i = pokes.length - 1; i >= 0; i--) {
	// if (getPokeValue(pokes[i]) > minValue) {
	// int currentValue = minValue;
	// int startIdx = pokeWanted.length - 1;
	// for (int j = i; j >= 0; j--) {
	// if (getPokeValue(pokes[j]) == currentValue) {
	//
	// pokeWanted[startIdx] = pokes[j];
	// if (startIdx == 0) {
	// find = true;
	// // for (int k = j; k < j  
	// // pokeWanted.length; i  ) {
	// // pokes[k] = -1;
	// // }
	// break;
	// }
	// startIdx--;
	// currentValue  ;
	// } else {
	// i = j - 1;
	// break;
	// }
	// }
	// if (find) {
	// break;
	// }
	// }
	// }
	// break;
	// case PokeType.shuangshun:// test
	// int len = pokeWanted.length;
	// for (int i = pokes.length - 1; i >= len - 1; i--) {
	// pokeWanted = getPartOfArray(pokes, i - len - 1, len);
	// if (getPokeType(pokeWanted) == PokeType.shuangshun) {
	// if (getPokeValue(pokeWanted[0]) > value) {
	// find = true;
	// // for (int k = i - len - 1; k < i - 1; i  ) {
	// // pokes[k] = -1;
	// // }
	// break;
	// }
	// }
	// }
	// break;
	// case PokeType.sanshun:
	// len = pokeWanted.length;
	// for (int i = pokes.length - 1; i >= len - 1; i--) {
	// pokeWanted = getPartOfArray(pokes, i - len - 1, len);
	// if (getPokeType(pokeWanted) == PokeType.sanshun) {
	// if (getPokeValue(pokeWanted[0]) > value) {
	// find = true;
	// // for (int k = i - len - 1; k < i - 1; i  ) {
	// // pokes[k] = -1;
	// // }
	// break;
	// }
	// }
	// }
	// break;
	// case PokeType.feiji:
	//
	// break;
	// case PokeType.sidaier:
	// break;
	//
	// }
	// } else {
	// switch (cardType) {
	// case PokeType.zhadan:
	//
	// break;
	// case PokeType.huojian:
	// break;
	// }
	//
	// }
	// if (find) {
	// return pokeWanted;
	// } else {
	// return null;
	// }
	//
	// }

	// public static int[] getPartOfArray(int pokes[], int start, int len)//
	// ;test
	// {
	// if (len <= 0) {
	// return null;
	// }
	// int[] newArray = new int[len];
	// int length = pokes.length;
	// if (start   len >= length) {
	// return null;
	// }
	// int j = 0;
	// for (int i = start; i < start   len; i  ) {
	// newArray[j  ] = pokes[i];
	// }
	// return newArray;
	// }

}

标签: QQ 斗地主

实例下载地址

qq斗地主游戏app源码

不能下载?内容有错? 点击这里报错 + 投诉 + 提问

好例子网口号:伸出你的我的手 — 分享

网友评论

发表评论

(您的评论需要经过审核才能显示)

查看所有0条评论>>

小贴士

感谢您为本站写下的评论,您的评论对其它用户来说具有重要的参考价值,所以请认真填写。

  • 类似“顶”、“沙发”之类没有营养的文字,对勤劳贡献的楼主来说是令人沮丧的反馈信息。
  • 相信您也不想看到一排文字/表情墙,所以请不要反馈意义不大的重复字符,也请尽量不要纯表情的回复。
  • 提问之前请再仔细看一遍楼主的说明,或许是您遗漏了。
  • 请勿到处挖坑绊人、招贴广告。既占空间让人厌烦,又没人会搭理,于人于己都无利。

关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享,对搜索内容的合法性不具有预见性、识别性、控制性,仅供学习研究,请务必在下载后24小时内给予删除,不得用于其他任何用途,否则后果自负。基于互联网的特殊性,平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查;无论平台是否已进行审查,用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场,基于网友分享,根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定,若资源存在侵权或相关问题请联系本站客服人员,点此联系我们。关于更多版权及免责申明参见 版权及免责申明

;
报警