/*===================== cls_card2: 牌的基础类 ======================
	扑克牌的统一定义：
	1，单张牌的定义是一个长度为14的数组 [Id, Flower, Number, ArithF, ArithN, Score, Deal, Start, Play, Index, Over, Tag1, Tag2, Tag3]
		第一位：Id，牌的绝对id，即数组下标，从0开始计数。
		第二位：Flower，牌的物理花色，5:王 4:黑桃 3:红心 2:梅花 1:方块。
		第三位：Number，牌的物理大小，1:A 2:2 ... 9:9 10:10 11:J 12:Q 13:K 53:小王 54:大王。
		第四位：ArithF，牌的算法花色，区别于物理花色，用于牌型计算和比较牌的大小。
			要求是大于0的整数，不能等于0或小于0，默认等于物理花色。
		第五位：ArithN，牌的算法大小，区别于物理大小，用于牌型计算和比较牌的大小。
			要求是大于0的整数，不能等于0或小于0，默认等于物理大小。
		第六位：Score，牌的分值，如5、10、K。
		第七位：Deal，发牌状态。
			-2：规则去除的牌；
			-1：未发的牌（底牌）；
		   >=0：发牌发到谁手上，即座位号。
		第八位：Start，开局状态，开局时牌在谁手上，与座位编号对应。
		第九位：Play，出牌状态。
			-2：埋的牌；
			-1：未出的牌（手上的牌）；
		   >=0：牌是第几轮出出去的，从0开始计数。
		第十位：Index，本轮中的出牌顺序号，从0开始计数。
		第十一位：Over，牌局结束时被谁得到，与座位编号对应。
		第十二位：Tag1，扩展属性1。
		第十三位：Tag2，扩展属性2。
		第十四位：Tag3，扩展属性3。
	2，基础牌型的统一定义：
		所有基础牌型都由两个值表示：tong，同，表示一样的牌；shun，顺，表示连续的牌。
		  单张：tong=1，shun=1
		  对子：tong=2，shun=1
		两连对：tong=2，shun=2
		三连对：tong=2，shun=3
		  三个：tong=3，shun=1
		  飞机：tong=3，shun=2
		  四个：tong=4，shun=1
		五连顺：tong=1，shun=5
		六连顺：tong=1，shun=6
		其他基础牌型以此类推

	注意：
	1，此牌类是基础扑克牌类、通用扑克牌类；各子游戏可以直接使用，也可以继承此基础类后下编写自己的牌类。
	2，子游戏开发人员不能修改该文件。
	3，访问牌的属性时要求使用Get和Set方法，不能直接通过数组下标的形式访问。
===================================================================*/
var cls_card2 = {

	//新建一张牌
	New: function(id){
		return this.declare(id);
	},
	//牌的数据定义
	declare: function(id){
		//id转物理花色
		var IdToFlower = function(cardid){
			var yu = cardid % 54; 
			if (yu == 52 || yu == 53){ 
				return 5;
			}
			return parseInt(yu / 13) + 1;
		}
		//id转物理数值
		var IdToNumber = function(cardid){
			var yu = cardid % 54; 
			if (yu == 52){
				return 53;
			}
			if (yu == 53){
				return 54;
			}
			return yu % 13 + 1;
		}

		var o_card = [];
		o_card[0]  = id;
		o_card[1]  = IdToFlower(id);
		o_card[2]  = IdToNumber(id);
		o_card[3]  = o_card[1];
		o_card[4]  = o_card[2];
		o_card[5]  = null;
		o_card[6]  = null;
		o_card[7]  = null;
		o_card[8]  = null;
		o_card[9]  = null;
		o_card[10] = null;
		o_card[11] = null;
		o_card[12] = null;
		o_card[13] = null;
		return o_card;
	},
	//牌的id，整型，只读
	GetId: function(o_card){
		return o_card[0];
	},
	//牌的物理花色，整型，只读
	GetFlower: function(o_card){
		return o_card[1];
	},
	//牌的物理大小，整型，只读
	GetNumber: function(o_card){
		return o_card[2];
	},
	//牌的算法花色，整型
	GetArithF: function(o_card){
		return o_card[3];
	},
	SetArithF: function(o_card, value){
		o_card[3] = value;
	},
	//牌的算法大小，整型
	GetArithN: function(o_card){
		return o_card[4];
	},
	SetArithN: function(o_card, value){
		o_card[4] = value;
	},
	//牌的分值，整型
	GetScore: function(o_card){
		return o_card[5];
	},
	SetScore: function(o_card, value){
		o_card[5] = value;
	},
	//发牌状态，整型
	GetDeal: function(o_card){
		return o_card[6];
	},
	SetDeal: function(o_card, value){
		o_card[6] = value;
	},
	//开局状态，整型
	GetStart: function(o_card){
		return o_card[7];
	},
	SetStart: function(o_card, value){
		o_card[7] = value;
	},
	//出牌状态，整型
	GetPlay: function(o_card){
		return o_card[8];
	},
	SetPlay: function(o_card, value){
		o_card[8] = value;
	},
	//出牌顺序，整型
	GetIndex: function(o_card){
		return o_card[9];
	},
	SetIndex: function(o_card, value){
		o_card[9] = value;
	},
	//结束时被谁得到，整型
	GetOver: function(o_card){
		return o_card[10];
	},
	SetOver: function(o_card, value){
		o_card[10] = value;
	},
	//扩展属性
	GetTag1: function(o_card){
		return o_card[11];
	},
	SetTag1: function(o_card, value){
		o_card[11] = value;
	},
	GetTag2: function(o_card){
		return o_card[12];
	},
	SetTag2: function(o_card, value){
		o_card[12] = value;
	},
	GetTag3: function(o_card){
		return o_card[13];
	},
	SetTag3: function(o_card, value){
		o_card[13] = value;
	},
	/*
		以下提供几个针对牌数组的基础算法，这两个方法是基于牌的算法花色和算法大小实现的，各子游戏在调用前需要将牌的算法花色和算法大小先设置好。

		设置算法花色的原则是：
		1，如果对花色没要求则需要将所有牌的算法花色统一。比如斗地主中的五连顺是任何花色都可以一起连顺子的，则需要将所有牌的算法花色全部设置成0，表示都是同一花色，然后在同一花色下取顺子。
		2，如果对花色有要求则需要根据实际情况区分算法花色。比如升级中的两连对是指同一花色下的两连对，则需要将算法花色设置成不同的值，表示不同算法花色之间是不能组成两连对的。

		设置算法大小的原则是：算法大小即可表示是否连牌，也可表示牌的大小关系。
		1，设置算法大小时要求做到数字连续则表示是连牌。比如A的物理大小是1，K的物理大小是13，1和13是不连续的，此时需要将A的算法大小设置成14，将K的算法大小设置成13，14和13是连续的，表示A和K可以连牌。再比如王牌和A是不能作为连牌出现的，则需要将王的算法大小设置成16，将A的算法大小设置成14，16和14不是连续的，表示王和A不能连牌。
		2，设置算法大小时要求做到数字大小则表示是牌的大小。比如A的物理大小是1，K的物理大小是13，1比13小，但A比K大，此时需要将A的算法大小设置成14，将K的算法大小设置成13，14比13大，表示A比K大。再比如王牌比A大，则需要将王的算法大小设置成16，将A的算法大小设置成14，16大于14，表示王比A大。
	*/

	//根据算法花色筛选牌
	FilterCardListByArithF: function(o_cardlist, ArithF){
		/*参数说明
		o_cardlist：需要进行筛选的牌数组
		ArithF：要筛选的算法花色，默认不筛选

		返回值：筛选后的牌数组*/
		var result = [];
		for (var i = 0; i < o_cardlist.length; i++) {
			var o_card = o_cardlist[i];
			var card_ArithF = this.GetArithF(o_card);
			if (!ArithF || card_ArithF == ArithF) {
				result.push(o_cardlist[i]);
			}
		}
		return result;
	},

	//根据算法大小筛选牌
	FilterCardListByArithN: function(o_cardlist, min_ArithN, max_ArithN){
		/*参数说明
		o_cardlist：需要进行筛选的牌数组
		min_ArithN：要筛选的算法大小最小值，>=，默认不限制
		max_ArithN：要筛选的算法大小最大值，<=，默认不限制
		返回值：筛选后的牌数组*/
		var result = [];
		for (var i = 0; i < o_cardlist.length; i++) {
			var o_card = o_cardlist[i];
			var card_ArithN = this.GetArithN(o_card);
			if ((!min_ArithN || card_ArithN >= min_ArithN) && 
				(!max_ArithN || card_ArithN <= max_ArithN)) {
				result.push(o_cardlist[i]);
			}
		}
		return result;
	},

	//根据算法大小对牌数组进行排序(冒泡排序法)
	SortCardList: function(o_cardlist, options){
		/*参数说明
		o_cardlist: 需要进行排序的牌数组
		options   : 排序选项，长度为2的数组，结构为[大小排序方向，花色排序方向]
			第一位: 算法大小排序方向，0-从小到大排序 1-从大到小排序，默认为0。
			第二位: 物理花色排序方向，算法大小相同时是否再按物理花色排序，默认为0。
				0-根据算法大小排序方向默认选择物理花色排序方向，
					options[0]=0时，物理花色默认按“方块->梅花->红心->黑桃”排序；
					options[0]=1时，物理花色默认按“黑桃->红心->梅花->方块”排序。
				1-不按物理花色排序，在o_cardlist中是什么顺序就什么顺序。
				2-按物理花色从小到大，方块->梅花->红心->黑桃
				3-按物理花色从大到小，黑桃->红心->梅花->方块
		返回值: 排序后的牌数组*/
		var ArithN_direct = 0; //算法大小排序方向
		var Flower_direct = 0; //物理花色排序方向
		if (options) {
			ArithN_direct = parseInt(options[0]);
			Flower_direct = parseInt(options[1]);
		}
		if (!Flower_direct){
			if (ArithN_direct) {
				//算法大小从大到小排序时，默认按“黑桃->红心->梅花->方块”排序
				Flower_direct = 3;
			} else {
				//算法大小从小到大排序时，默认按“方块->梅花->红心->黑桃”排序
				Flower_direct = 2;
			}
		}

		//j与j+1互换位置
		var doChangej = function(){
			var tmp = o_cardlist[j];
			o_cardlist[j] = o_cardlist[j + 1];
			o_cardlist[j + 1] = tmp;
		}

		for (var i = 0; i < o_cardlist.length; i++){
			for (var j = 0; j < o_cardlist.length - i - 1; j++){
				var ArithN_j  = this.GetArithN(o_cardlist[j]);
				var ArithN_j1 = this.GetArithN(o_cardlist[j + 1]);
				if (ArithN_direct == 0 && ArithN_j > ArithN_j1){
					//从小到大排序
					doChangej();
					continue;
				}
				if (ArithN_direct == 1 && ArithN_j < ArithN_j1){
					//从大到小排序
					doChangej();
					continue;
				}
				if (ArithN_j == ArithN_j1){
					//算法大小相同时
					if (Flower_direct == 1){ 
						//不按物理花色排序
						continue;
					}
					var Flower_j  = this.GetFlower(o_cardlist[j]);
					var Flower_j1 = this.GetFlower(o_cardlist[j + 1]);
					if (Flower_direct == 2 && Flower_j > Flower_j1){
						//按“方块->梅花->红心->黑桃”排序
						doChangej();
						continue;
					}
					if (Flower_direct == 3 && Flower_j < Flower_j1){
						//按“黑桃->红心->梅花->方块”排序
						doChangej();
						continue;
					}
				}
			}
		}
		return o_cardlist;
	},

	//获取指定牌型(基础牌型)的各种组合(只组合，无排列)
	GetCardListByCardType: function(o_cardlist, cardtype, options){
		/*参数说明
		o_cardlist:在这些牌中获取指定牌型，必须是经过了从小到大排序后的牌数组。
		cardtype  :目标牌型，长度为2的数组，结构为[同，顺]。
				   例如单张为[1,1]，对子为[2,1]，五连顺为[1,5]。
		options   :取牌选项，长度为4的数组，结构为[结果数量，取牌方向，拆牌标志，一次标志]
			第一位:结果数量，0-获取所有可能的结果，>0要取的结果数量，默认为0。
				比如，牌数组为[2,3,5,7]时，
				当options[0]=0时，则取单张的结果为2，3，5，7；
				当options[0]=1时，则取单张的结果为2；
				当options[0]=3时，则取单张的结果为2，3，5。			
			第二位:取牌方向，0-从小到大取结果，1-从大到小取结果，默认为0。
			第三位:拆牌标志，0-不拆牌，1-拆牌，默认为0。
				比如，牌数组为[2,2,3,5,5,5,7]，
				当options[2]=0时，则取单张时会不取对子的牌和三张的牌，即结果为3，7；
				当options[2]=1时，则取单张时会拆掉对子的牌和三张的牌，即结果为2，3，5，7。
			第四位:一次标志，0-相同大小的牌只取一次，1-取所有情况，默认为0。
				比如，牌数组为[红心2, 黑桃2, 方块3, 方块5, 红心5, 黑桃5, 方块7]，
				当options[3]=0时，则取单张的结果为：红心2, 方块3, 方块5, 方块7；
				当options[3]=1时，则取单张时结果为：红心2, 黑桃2, 方块3, 方块5, 红心5, 黑桃5, 方块7。
		返回值：满足牌型要求的牌组合数组。
		格式如
			[
				[o_card, o_card, o_card, ...], 
				[o_card, o_card, o_card, ...], 
				[o_card, o_card, o_card, ...], 
				...
			]
		注意：统一用第一张牌的算法大小值表示牌型大小，比如34567是顺子，56789也是顺子，用3表示34567顺子的大小，用5表示56789顺子的大小，5大于3，表示56789的顺子比34567的顺子大*/

		var cardtype_tong = parseInt(cardtype[0]); //牌型-同
		var cardtype_shun = parseInt(cardtype[1]); //牌型-顺
		var options_count = 0; //结果数量
		var options_direct= 0; //取牌方向
		var options_split = 0; //拆牌标志
		var options_once  = 0; //一次标志
		if (options){
			options_count = parseInt(options[0]);
			options_direct= parseInt(options[1]);
			options_split = parseInt(options[2]);
			options_once  = parseInt(options[3]);
		}

		//将牌按大小分组，即相同大小的牌归为一组。如，将[2,2,3,5,5,5,7]这样的牌数组转成[[2,2],[3],[5,5,5],[7]]
		var SameGroupList = []; 
		var SameGroup = [];
		for (var i = 0; i < o_cardlist.length; i++){
			var o_card = o_cardlist[i];
			if (SameGroup.length == 0){
				SameGroup.push(o_card);
			} else {
				var card_ArithN = this.GetArithN(o_card);
				var SameGroup_ArithN = this.GetArithN(SameGroup[0]);
				if (card_ArithN == SameGroup_ArithN){
					SameGroup.push(o_card);
				} else {
					SameGroupList.push(SameGroup);
					SameGroup = [];
					SameGroup.push(o_card);
				}
			}
		}
		if (SameGroup.length > 0){
			SameGroupList.push(SameGroup);
		}

		//将牌分组按牌型的“同”获取各自的组合。例如，将[[2,2],[3],[5,5,5],[7]]这样的牌分组按“同”等于2转成[[[2,2]], [[方5,梅5],[方5,红5],[梅5,红5]]]
		var TongGroupList = [];
		for (var i = 0; i < SameGroupList.length; i++){
			if (SameGroupList[i].length < cardtype_tong){
				// TongGroupList.push([]);
				continue;
			} 
			if (SameGroupList[i].length == cardtype_tong){
				TongGroupList.push([SameGroupList[i]]);
				continue;
			} 
			if (SameGroupList[i].length > cardtype_tong){
				if (!options_split){ //不允许拆牌
					// TongGroupList.push([]);
					continue;
				}
				if (!options_once){ //同样大小的牌只取一次
					TongGroupList.push([SameGroupList[i].slice(0, cardtype_tong)]);
				} else {
					TongGroupList.push(min_CombineInAry(SameGroupList[i], cardtype_tong));
				}
			}
		}

		//返回结果
		var resultlist = [];
		var ShunGroup = [];
		//检查ShunGroup是否是连顺，如果是连顺则在ShunGroup取结果保存到resultlist中
		var check_return_ShunGroup = function(){
			var isShun = true;
			for (var j = 0; j < ShunGroup.length; j++){
				if (ShunGroup[j].length == 0) {
					isShun = false;
					break;
				}
				if (j > 0) {
					var j1_ArithN = this.GetArithN(ShunGroup[j-1][0][0]);
					var j_ArithN  = this.GetArithN(ShunGroup[j][0][0]);
					//相减等于1表示是顺
					if (j_ArithN - j1_ArithN != 1){
						isShun = false;
						break;
					}
				}
			}
			if (!isShun){
				return false;
			}
			var result = min_CombineByArys(ShunGroup);
			for (var j = 0; j < result.length; j++) {
				var temp = [];
				for (var k = 0; k < result[j].length; k++) {
					temp = temp.concat(result[j][k]);
				}
				resultlist.push(temp);

				if (options_count && resultlist.length >= options_count) {
					//达到了要取的结果数量
					return true;
				}
			}
			return false;
		}.bind(this);

		//按牌型的“顺”获取符合要求的结果
		if (!options_direct){
			//从小到大取结果
			for (var i = 0; i <= TongGroupList.length - cardtype_shun; i++){
				ShunGroup = TongGroupList.slice(i, i + cardtype_shun);
				if (check_return_ShunGroup()){
					return resultlist;
				}
			}
		} else {
			//从大到小取结果
			for (var i = TongGroupList.length - cardtype_shun; i >= 0; i--){
				ShunGroup = TongGroupList.slice(i, i + cardtype_shun);
				if (check_return_ShunGroup()){
					return resultlist;
				}
			}			
		}
		return resultlist;
	},
	GetCardListByCardTypeA: function(o_cardlist, cardtype, options, min_ArithN, max_ArithN){
		/*参数说明
		o_cardlist:同GetCardListByCardType中的参数说明。
		cardtype  :同GetCardListByCardType中的参数说明。
		options   :同GetCardListByCardType中的参数说明。
		min_ArithN:同FilterCardListByArithN中的参数说明。
		max_ArithN:同FilterCardListByArithN中的参数说明。
		返回值：同GetCardListByCardType中的参数说明。*/
		var cardlist = this.FilterCardListByArithN(o_cardlist, min_ArithN, max_ArithN);
		return this.GetCardListByCardType(cardlist, cardtype, options);
	},
	GetCardListByCardTypeB: function(o_cardlist, cardtype, options, ArithF, min_ArithN, max_ArithN){
		/*参数说明
		o_cardlist:可以是未排序的牌数组，该函数会实现排序。
		cardtype  :同GetCardListByCardType中的参数说明。
		options   :同GetCardListByCardType中的参数说明。
		ArithF    :同FilterCardListByArithF中的参数说明。
		min_ArithN:同FilterCardListByArithN中的参数说明。
		max_ArithN:同FilterCardListByArithN中的参数说明。
		返回值：同GetCardListByCardType中的参数说明。*/
		var cardlist = this.FilterCardListByArithF(o_cardlist, ArithF);
		this.SortCardList(cardlist);
		cardlist = this.FilterCardListByArithN(cardlist, min_ArithN, max_ArithN);
		return this.GetCardListByCardType(cardlist, cardtype, options);
	},

	//获取指定牌型(扩展牌型)的一种组合(只取一种组合)
	GetCardListByExtendCardTypeA: function(o_cardlist, cardtypelist){
		/*参数说明
		o_cardlist  :同GetCardListByCardTypeA中的参数说明。
		cardtypelist:扩展牌型和取牌选项。
			结构为[
					[cardtype, options, min_ArithN, max_ArithN],
					[cardtype, options, min_ArithN, max_ArithN],
					[cardtype, options, min_ArithN, max_ArithN]
				  ]
			其中cardtype、options、min_ArithN、max_ArithN同GetCardListByCardTypeA中的参数说明。
			例如3带1，cardtypelist=[
									[[3,1], [1,x,x,x], min_ArithN, max_ArithN], 
									[[1,1], [1,x,x,x], min_ArithN, max_ArithN]
								   ]
				3带2，cardtypelist=[
									[[3,1], [1,x,x,x], min_ArithN, max_ArithN], 
									[[1,1], [1,x,x,x], min_ArithN, max_ArithN],
									[[1,1], [1,x,x,x], min_ArithN, max_ArithN]
								   ]
			  3带1对，cardtypelist=[
									[[3,1], [1,x,x,x], min_ArithN, max_ArithN], 
									[[2,1], [1,x,x,x], min_ArithN, max_ArithN]
								   ]
			注意：options中第一参数一定为1，表示只取一个结果，如果传的值不等于1，也会按等于1处理。

		返回值：同GetCardListByCardTypeA中的参数说明。*/

		var cardlist = o_cardlist;
		var result = [];
		for (var i = 0; i < cardtypelist.length; i++){
			var cardtype = cardtypelist[i][0];
			var options  = cardtypelist[i][1];
			if (options[0] != 1){
				options[0] = 1;
			}
			var min_ArithN = cardtypelist[i][2];
			var max_ArithN = cardtypelist[i][3];
			var BaseCardGroup = this.GetCardListByCardTypeA(cardlist, cardtype, options, min_ArithN, max_ArithN);
			if (BaseCardGroup.length == 0){
				return [];
			}
			result = result.concat(BaseCardGroup[0]);
			cardlist = min_ary_deduct(cardlist, BaseCardGroup[0]);
		}
		return [result];
	},

	//获取牌数组的最大牌型
	GetMaxCardTypeByCardList: function(o_cardlist, option){
		/*参数说明
		o_cardlist: 必须是经过了从小到大排序后的牌数组。
			option: 选项，默认为0
		    	0-返回"同"最多的最大牌型(如果"同"相同则取"顺"最多的，如果"顺"也相同则取"值"最大的)
		    	1-返回"顺"最多的最大牌型(如果"顺"相同则取"同"最多的，如果"同"也相同则取"值"最大的)
		返回值：结构为[cardtype, cardlist]。其中，
			cardtype为基础牌型，结构为[同，顺]；
			cardlist为满足cardtype的牌数组，牌型相同时取最大值的牌。

		例如，当option=0时，
				牌数组为[3,7,7,7,9,9,J,J,J,Q,Q]，        返回值为[[3,1], [J,J,J]]
				牌数组为[3,7,7,7,8,8,8,9,9,J,J,J,Q,Q]，  返回值为[[3,2], [7,7,7,8,8,8]]
				牌数组为[3,7,7,7,8,8,8,9,9,J,J,J,Q,Q,Q]，返回值为[[3,2], [J,J,J,Q,Q,Q]]
			  当option=1时，
				牌数组为[2,4,5,6,8,9,J,J,Q,Q,K]，        返回值为[[1,3], [J,Q,K]]
				牌数组为[2,4,4,5,5,6,6,8,9,J,J,Q,Q,K]，  返回值为[[2,3], [4,4,5,5,6,6]]
				牌数组为[2,4,4,5,5,6,6,8,9,J,J,Q,Q,K,K]，返回值为[[2,3], [J,J,Q,Q,K,K]]*/
		var result = [];

		//将o_cardlist按大小分组。
		//如，将[2,2,3,5,5,5,7]这样的牌数组转成[[2,2],[3],[5,5,5],[7]]
		var changeto_SameGroupList = function(){
			var SameGroupList = []; 
			var SameGroup = [];
			for (var i = 0; i < o_cardlist.length; i++){
				var o_card = o_cardlist[i];
				if (SameGroup.length == 0){
					SameGroup.push(o_card);
				} else {
					var card_ArithN = this.GetArithN(o_card);
					var SameGroup_ArithN = this.GetArithN(SameGroup[0]);
					if (card_ArithN == SameGroup_ArithN){
						SameGroup.push(o_card);
					} else {
						SameGroupList.push(SameGroup);
						SameGroup = [];
						SameGroup.push(o_card);
					}
				}
			}
			if (SameGroup.length > 0){
				SameGroupList.push(SameGroup);
			}
			return SameGroupList;
		}.bind(this);

		var SameGroupList = changeto_SameGroupList();
		switch (option){
			case 0: //取"同"最多的牌型 [A,2,2,3,4,4,5,5,7,7,8,8,9,9,J,J,Q,Q,K,K]
				//检查ShunGroup是否是连顺 
				var check_ShunGroup_isShun = function(){
					for (var j = 0; j < ShunGroup.length; j++){
						if (ShunGroup[j].length == 0) {
							return false;
						}
						if (j > 0) {
							var j1_ArithN = this.GetArithN(ShunGroup[j-1][0]);
							var j_ArithN  = this.GetArithN(ShunGroup[j][0]);
							//相减等于1表示是顺
							if (j_ArithN - j1_ArithN != 1){
								return false;
							}
						}
					}
					return true;
				}.bind(this);

				result[0] = [SameGroupList[0].length, 1];
				result[1] = SameGroupList[0];
				for (var i = 1; i < SameGroupList.length; i++) {
					if (SameGroupList[i].length > result[0][0]){
						result[0] = [SameGroupList[i].length, 1];
						result[1] = SameGroupList[i];
					} else if (SameGroupList[i].length == result[0][0]){
						var ArithN_i = this.GetArithN(SameGroupList[i][0]);
						var ArithN_r = this.GetArithN(result[1][result[1].length - 1]);
						if (ArithN_i - ArithN_r == 1){ //相减等于1表示是顺
							result[0][1] = result[0][1] + 1;
							result[1] = result[1].concat(SameGroupList[i]);
						} else {
							if (i + result[0][1] <= SameGroupList.length){
								var ShunGroup = SameGroupList.slice(i, i + result[0][1]);
								var isShun = check_ShunGroup_isShun();
								if (isShun){
									var check_Tong = true;
									for (var j = 1; j < ShunGroup.length; j++) {
										if (ShunGroup[j].length != result[0][0]){
											check_Tong = false;
											break;
										}
									}
									if (check_Tong) {
										result[1] = [];
										for (var j = 0; j < ShunGroup.length; j++) {
											result[1] = result[1].concat(ShunGroup[j]);
										}
										i = i + result[0][1] - 1;
									}
								}						
							}
						}
					}
				}
				break;
			case 1: //取"顺"最多的牌型 [A,3,4,6,8,8,9,9,J,J,J,Q,Q,Q]
				//将SameGroupList转成ShunGroupList
				//如，将[[2,2],[3],[5,5,5],[6,6],[7],[9,9]]转成[[[2,2],[3]], [[5,5,5],[6,6],[7]], [[9,9]]]
				var changeto_ShunGroupList = function(){
					var ShunGroupList = [];
					for (var i = 0; i < SameGroupList.length; i++) {
						var ArithN_i = this.GetArithN(SameGroupList[i][0]);
						var isFound = false;
						for (var j = 0; j < ShunGroupList.length; j++) {
							var ArithN_j = this.GetArithN(ShunGroupList[j][ShunGroupList[j].length - 1][0]);
							if (ArithN_i - ArithN_j == 1) {
								ShunGroupList[j].push(SameGroupList[i]);
								isFound = true;
								break;
							}
						}
						if (!isFound){
							ShunGroupList.push([SameGroupList[i]]);
						}
					}
					return ShunGroupList;
				}.bind(this);

				//获取ShunGroup中最小的"同"数
				var get_ShunGroup_minTong = function(){
					var min_Tong = ShunGroup[0].length;
					for (var j = 1; j < ShunGroup.length; j++) {
						if (ShunGroup[j].length < min_Tong) {
							min_Tong = ShunGroup[j].length;
						}
					}
					return min_Tong;
				}.bind(this);

				//根据ShunGroup的min_Tong设置result
				var set_result_byShunGroup_byMinTong = function(){
					result[0] = [min_Tong, ShunGroup.length];
					result[1] = [];
					for (var j = 0; j < ShunGroup.length; j++) {
						result[1] = result[1].concat(ShunGroup[j].slice(0, min_Tong));
					}
				}.bind(this);

				var ShunGroupList = changeto_ShunGroupList();
				//在ShunGroupList中取最长的"顺"
				for (var i = 0; i < ShunGroupList.length; i++) {
					var ShunGroup = ShunGroupList[i];
					var min_Tong = get_ShunGroup_minTong();
					if (i == 0){
						set_result_byShunGroup_byMinTong();
					} else {
						if (ShunGroup.length > result[0][1]) {
							set_result_byShunGroup_byMinTong();
						} else if (ShunGroup.length == result[0][1]) {
							if (min_Tong >= result[0][0]){
								set_result_byShunGroup_byMinTong();
							}
						}
					}
				}
				break;
		}
		return result;
	},
	GetMaxCardTypeByCardListA: function(o_cardlist){
		/*参数说明 o_cardlist:可以是未排序的牌数组，该函数会实现排序。*/
		this.SortCardList(o_cardlist);
		return this.GetMaxCardTypeByCardList(o_cardlist);
	},

	//新建单张牌类
	NewClass: function(){
		var cls = {};
		cls.New       = cls_card2.New;
		cls.declare   = cls_card2.declare;
		cls.GetId     = cls_card2.GetId;
		cls.GetFlower = cls_card2.GetFlower;
		cls.GetNumber = cls_card2.GetNumber;
		cls.GetArithF = cls_card2.GetArithF;
		cls.SetArithF = cls_card2.SetArithF;
		cls.GetArithN = cls_card2.GetArithN;
		cls.SetArithN = cls_card2.SetArithN;
		cls.GetScore  = cls_card2.GetScore;
		cls.SetScore  = cls_card2.SetScore;
		cls.GetDeal   = cls_card2.GetDeal;
		cls.SetDeal   = cls_card2.SetDeal;
		cls.GetStart  = cls_card2.GetStart;
		cls.SetStart  = cls_card2.SetStart;
		cls.GetPlay   = cls_card2.GetPlay;
		cls.SetPlay   = cls_card2.SetPlay;
		cls.GetIndex  = cls_card2.GetIndex;
		cls.SetIndex  = cls_card2.SetIndex;
		cls.GetOver   = cls_card2.GetOver;
		cls.SetOver   = cls_card2.SetOver;
		cls.GetTag1   = cls_card2.GetTag1;
		cls.SetTag1   = cls_card2.SetTag1;
		cls.GetTag2   = cls_card2.GetTag2;
		cls.SetTag2   = cls_card2.SetTag2;
		cls.GetTag3   = cls_card2.GetTag3;
		cls.SetTag3   = cls_card2.SetTag3;
		cls.FilterCardListByArithF       = cls_card2.FilterCardListByArithF;
		cls.FilterCardListByArithN       = cls_card2.FilterCardListByArithN;
		cls.SortCardList                 = cls_card2.SortCardList;
		cls.GetCardListByCardType        = cls_card2.GetCardListByCardType;
		cls.GetCardListByCardTypeA       = cls_card2.GetCardListByCardTypeA;
		cls.GetCardListByCardTypeB       = cls_card2.GetCardListByCardTypeB;
		cls.GetCardListByExtendCardTypeA = cls_card2.GetCardListByExtendCardTypeA;
		cls.GetMaxCardTypeByCardList     = cls_card2.GetMaxCardTypeByCardList;
		cls.GetMaxCardTypeByCardListA    = cls_card2.GetMaxCardTypeByCardListA;
		return cls;
	}
}