743 lines
27 KiB
JavaScript
743 lines
27 KiB
JavaScript
/*===================== 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]，返回值为[[3,2], [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;
|
||
}
|
||
}
|