斗地主AI JavaScript篇(1)

今天 有幸在这里做一下关于斗地主AI的 JS实现讲解

在处理AI的过程中 首先 我们要对模拟人类赞牌的过程 实现机器人算出最合理的出牌路线！

 

在这个过程中 我们需要用到的函数

1：排序函数：PxFux 返回一个经过对牌组排序的数组 不要干涉原来的数组

2：抽牌函数：MChouPai  返回一个被抽出的片段 和 抽出后剩余的部分

3：查找存在的牌型函数：SerCh 返回查找到的单牌 火箭 对子 3张 顺子 只要它有可能存在 就加入到队列去！

4：计算Pn值函数：GetTaMax 这里的Pn值 是计算出遍历出来的牌的好坏程度 用来筛选最好的牌

5：遍历除炸弹火箭2以外的所有剩余路径：GetAllPai
6：在GetAllPai 中使用到 GetAllLast函数 该函数是计算遍历出顺子组合后 剩下的牌在进行 3张 对子 和 单牌的加入

7：GetAllSun 遍历出所有 3张 单顺 双顺 3顺的组合 （记住为机器人赞牌，我们不必要去理会 3带1 3带2 或者飞机 等情况 因为这个情况我们可以再出牌的时候依据剩余的单牌 或对牌去决定要出飞机还是3带1 我们只需要找出 3张一样的 或者顺子啊等等）
8:GetAllSunLess 遍历出所有的顺子

9：GetAll2SunLess 遍历出所有的双顺

10：GetAll3SunLess 遍历所有的3顺

 

以上 遍历的值 都是以阶梯式的 并不等级

 

好比如 有两个顺子 两个 双顺

 

GetAllSunLess 得到的阶梯是这样的

 

顺子1--杂牌

顺子1-顺子2-杂牌

 

双顺1--杂牌

双顺1-双顺2-杂牌

 

那么在GetAllSun 的函数中 剩余的杂牌 可以依照3种情况在进行排列 格式如下

                              |顺子2--杂牌

           | 取顺子部分-+

           |                  | 顺子2-顺子3-杂牌

           |                     |双顺2--杂牌

顺子1--+取双顺部分 ---+

           |                     |双顺2-双顺3-杂牌

 

顺子1-顺子2-杂牌

 

双顺1--杂牌

双顺1-双顺2-杂牌

 如此类推 得到所有 顺子中的配对形式

 

每个末端节点 都取得一条完整的 顺子片段+没有顺子的杂牌

然后在用GetAllLast 对没有顺子的末端节点 的没有顺子的杂牌  再去取 3张 2张 1张

这样 最后返回一组没有杂牌的完整路径片段 Splt 的Array()

 

在用 GetTaMax 去计算PN值 取出一条合适的路径----------

 

以下给出 一些函数算法 ---

 

 

抽牌的函数----

//√内部函数：抽牌--不干涉进入数组---------------- //主要功能 按值 Num 从牌中抽出一组牌 然后再得到剩下的牌 //如 // [{num:15,key:1}{num:14,key:1}{num:13,key:1}] // 用 [13,14] 可抽出 返回 // {Splt:[{num:14,key:1}{num:13,key:1}],Less:[{num:15,key:1}]} function MChouPai(Arr,Cads){ if(Arr==null||Arr.length==0)return null; if(Arr.length>Cads.length)return null; var Less=Cads.slice(0); var Splt=new Array(); for(var i=0;i<Arr.length;i++) for(var k=0;k<Less.length;k++) if(Arr[i]==Less[k].num){Splt.push(Less[k]);Less.splice(k,1);break;} if(Splt.length!=Arr.length||(Splt.length+Less.length)!=Cads.length)return null; return {Splt:Splt,Less:Less} } // 在这个AI中 我会经常用到 Splt 表示抽出块 Less 表示剩余块！   

 

查找存在牌型的函数--- 

 //√方法：查找存在的牌型---?我都有什么 我能攒什么牌---------- // Obj 进入的牌型数组 代表一组牌 单牌中 有 3个属性 num 是牌面数值 A对应14，2对应15 小王对应 16 大王17 // 返回 一个对象 其中 算出 这幅牌中 有没有火箭 单牌都是那些 对子都是那些 var SerCh=function(Obj) { if(Obj==null)return null; var Len=Obj.length; var Ars=PxFux(Obj,1);//按大到小排序 var Huo=false; //是否存在火箭--- var Dan=new Array(); //单牌 var Dui=new Array(); //对子 var San=new Array(); //三张 var Siz=new Array(); //四张 var Sun=new Array(); //单顺 var Sun2=new Array();//双顺 var Sun3=new Array();//三顺 //在找牌中我们不必要 找 4带1 4带2 或者 3带1 等等 因为这样的牌 待出牌的时候根据单牌数量会自己凑出 if(Len>1&&Ars[0].num==17&&Ars[1].num==16)Huo=true; //牌面中已经排序过了 所以 如果有火箭 就在第1 和第2张中 for(var i=0;i<Len;i++) { if(Dan.length==0||Ars[i].num!=Dan[Dan.length-1]) //如果没有加入 和 加入的不重复 就吧单牌加入进去 { if(!(Huo&&Ars[i].key==4))Dan.push(Ars[i].num); } } for(var i=0;i<Len-1;i++)if(Ars[i].num==Ars[i+1].num){if(Dui.length==0||Ars[i].num!=Dui[Dui.length-1])Dui.push(Ars[i].num);i++;} //类似加入 对子 for(var i=0;i<Len-2;i++)if(Ars[i].num==Ars[i+1].num&&Ars[i+2].num==Ars[i].num){if(San.length==0||Ars[i].num!=San[San.length-1])San.push(Ars[i].num);i+=2;}//加入3张 for(var i=0;i<Len-3;i++)if(Ars[i].num==Ars[i+1].num&&Ars[i+2].num==Ars[i].num&&Ars[i+3].num==Ars[i].num){if(Siz.length==0||Ars[i].num!=Siz[Siz.length-1])Siz.push(Ars[i].num);i+=3;}//加入4张 //查找顺子的最大最小数------ // 顺子中 我们只要找出 最大的 Max 最小的 Len 长度 val 是一个遍历出所有能抽成顺的集合 for(var i=0;i<Dan.length;i++){ if(Dan[i]>14)continue; //A以上的不能顺 if(Dan[i]<7)break; //开头是 7 以下的也不能顺 for(var k=i;k<Dan.length;k++){ var N=k+1; if(N==Dan.length||Dan[i]-Dan[N]!=N-i) { var len=N-i; if(len>4){ var val=GetSun1List(Dan[i],Dan[k]); Sun.push({Max:Dan[i],Min:Dan[k],Len:len,nlen:len,val:val})}; i=k; break; } } } //找双顺 for(var i=0;i<Dui.length;i++){ if(Dui[i]>14)continue; if(Dui[i]<5)break; for(var k=i;k<Dui.length;k++){ var N=k+1; if(N==Dui.length||Dui[i]-Dui[N]!=N-i){ var len=N-i; if(len>2){ var val=GetSun2List(Dui[i],Dui[k]); Sun2.push({Max:Dui[i],Min:Dui[k],Len:len,nlen:len*2,val:val}) }; i=k; break; } } } //找三顺 for(var i=0;i<San.length;i++){ if(San[i]>14)continue; if(San[i]<4)break; for(var k=i;k<San.length;k++){ var N=k+1; if(N==San.length||San[i]-San[N]!=N-i){ var len=N-i; if(len>1){ var val=GetSun3List(San[i],San[k]); Sun3.push({Max:San[i],Min:San[k],Len:len,nlen:len*3,val:val}); } i=k; break; } } } return {Huo:Huo,Dan:Dan,Dui:Dui,San:San,Siz:Siz,Sun:Sun,Sun2:Sun2,Sun3:Sun3}; }

 在这里 处理机器人赞牌的函数

//√方法：机器人赞牌AI--------------- var ZhanPai=function(Arr){ var Less=PxFux(Arr,1);//先对进入的牌进行一次高低排序 var Ts=SerCh(Less); //找出有什么牌 var Splt=new Array(); //提取块数组==== if(Ts.Huo){var Tobj=MChouPai([17,16],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:14,max:17,len:2});Less=Tobj.Less;}} //如果有火箭 把火箭加入到我们线路的第一步 //这样 我们认为 机器人 赞出了他的一步 火箭 基本上不参与其他牌型的排列 默认是单独的一步！ for(var i=0;i<Ts.Siz.length;i++){var N=Ts.Siz[i];var Tobj=MChouPai([N,N,N,N],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:13,max:N,len:4});Less=Tobj.Less;}} //如果有炸弹 也加入为一步 也不让他加入其他牌型排列！ //我们认为保留炸弹是最优牌型的首选 if(Ts.San.length>0&&Ts.San[0]==15){var Tobj=MChouPai([15,15,15],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:3,max:15,len:3});Less=Tobj.Less;}} if(Ts.Dui.length>0&&Ts.Dui[0]==15){var Tobj=MChouPai([15,15],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:2,max:15,len:2});Less=Tobj.Less;}} // 3个2 和 对2 基本上不参与顺子 的排列 所以 也可以加为一单独步骤 var Obj={Splt:Splt,Less:Less};// OK 到这里 我们要把 加入到 步骤里的片段 和 剩下的值绑定起来 交给 处理 顺子 和 3张 对牌 单张的 遍历函数去处理了！ var AllPais=GetAllPai(Obj);//得到 遍历的路线数组(优化过的算法 使遍历不要浪费太多CPU) return GetTaMax(AllPais);// 得到 一条 机器人认为最合适的路线 }

下面是遍历的所有函数========

//抽出可能出现第一个单顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种单顺能出现就返回多少种路线 function ChouChuSun(Obj){ var Ts=SerCh(Obj.Less); if(Ts.Sun.length==0)return null; var ZParr=new Array(); for(var i=0;i<Ts.Sun.length;i++) { var SunObj=Ts.Sun[i]; //顺的对象------ for(var n=0;n<SunObj.val.length;n++) { var nObj=MChouPai(SunObj.val[n],Obj.Less); if(nObj!=null) { var nSplt={data:nObj.Splt,type:8,max:nObj.Splt[0].num,len:nObj.Splt.length}; nObj.Splt=Obj.Splt.concat([nSplt]); ZParr.push(nObj); } } } if(ZParr.length==0)return null; return ZParr; } //抽出可能出现第一个双顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种双顺能出现就返回多少种路线 function ChouChu2Sun(Obj){ var Ts=SerCh(Obj.Less); if(Ts.Sun2.length==0)return null; var ZParr=new Array(); for(var i=0;i<Ts.Sun2.length;i++) { var SunObj=Ts.Sun2[i]; //顺的对象------ for(var n=0;n<SunObj.val.length;n++) { var nObj=MChouPai(SunObj.val[n],Obj.Less); if(nObj!=null) { var nSplt={data:nObj.Splt,type:9,max:nObj.Splt[0].num,len:nObj.Splt.length}; nObj.Splt=Obj.Splt.concat([nSplt]); ZParr.push(nObj); } } } if(ZParr.length==0)return null; return ZParr; } //抽出可能出现第一个3顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种3顺能出现就返回多少种路线 function ChouChu3Sun(Obj){ var Ts=SerCh(Obj.Less); if(Ts.Sun3.length==0)return null; var ZParr=new Array(); for(var i=0;i<Ts.Sun3.length;i++) { var SunObj=Ts.Sun3[i]; //顺的对象------ for(var n=0;n<SunObj.val.length;n++) { var nObj=MChouPai(SunObj.val[n],Obj.Less); if(nObj!=null) { var nSplt={data:nObj.Splt,type:10,max:nObj.Splt[0].num,len:nObj.Splt.length}; nObj.Splt=Obj.Splt.concat([nSplt]); ZParr.push(nObj); } } } if(ZParr.length==0)return null; return ZParr; } //抽出可能出现所有单顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种单顺能出现就返回多少种路线 function GetAllSunLess(Obj){ if(Obj.Less.length<5)return null; var ShunArr=new Array(); var nObj=ChouChuSun(Obj); if(nObj!=null) { ShunArr=ShunArr.concat(nObj); for(var i=0;i<nObj.length;i++) { var List=GetAllSunLess(nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } if(ShunArr.length==0)return null; return ShunArr; } //抽出可能出现所有2顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种2顺能出现就返回多少种路线 function GetAll2SunLess(Obj){ if(Obj.Less.length<6)return null; var ShunArr=new Array(); var nObj=ChouChu2Sun(Obj); if(nObj!=null) { ShunArr=ShunArr.concat(nObj); for(var i=0;i<nObj.length;i++) { var List=GetAll2SunLess(nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } if(ShunArr.length==0)return null; return ShunArr; } //抽出可能出现所有3顺的所有遍历 返回 抽出的顺子片段和剩余的杂牌，有多少种3顺能出现就返回多少种路线 function GetAll3SunLess(Obj){ if(Obj.Less.length<6)return null; var ShunArr=new Array(); var nObj=ChouChu3Sun(Obj); if(nObj!=null) { ShunArr=ShunArr.concat(nObj); for(var i=0;i<nObj.length;i++) { var List=GetAll3SunLess(nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } if(ShunArr.length==0)return null; return ShunArr; } //整合 几种出现的顺子交互配对--- function GetAllSun(Obj){ if(Obj.Less.length<5)return null; var ShunArr=new Array(); //获得 单顺--- var D_nObj=GetAllSunLess(Obj); if(D_nObj!=null) { ShunArr=ShunArr.concat(D_nObj); for(var i=0;i<D_nObj.length;i++) { var List=GetAllSun(D_nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } //获得 双顺--- var D_nObj=GetAll2SunLess(Obj); if(D_nObj!=null) { ShunArr=ShunArr.concat(D_nObj); for(var i=0;i<D_nObj.length;i++) { var List=GetAllSun(D_nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } //获得 三顺--- var D_nObj=GetAll3SunLess(Obj); if(D_nObj!=null) { ShunArr=ShunArr.concat(D_nObj); for(var i=0;i<D_nObj.length;i++) { var List=GetAllSun(D_nObj[i]); if(List!=null)ShunArr=ShunArr.concat(List); } } if(ShunArr.length==0)return null; return ShunArr; } // 处理完顺子后 再处理剩下的杂牌 function GetAllLast(Obj){ var Less=Obj.Less.slice(0); var Splt=Obj.Splt.slice(0); if(Less.length==0)return Splt; var Ts=SerCh(Obj.Less); for(var i=0;i<Ts.San.length;i++) { var N=Ts.San[i]; if(N==15)continue; var Tobj=MChouPai([N,N,N],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:3,max:N,len:3});Less=Tobj.Less;} } for(var i=0;i<Ts.Dui.length;i++) { var N=Ts.Dui[i]; if(N==15)continue; var Tobj=MChouPai([N,N],Less);if(Tobj!=null){Splt.push({data:Tobj.Splt,type:2,max:N,len:2});Less=Tobj.Less;} } for(var i=0;i<Less.length;i++){ Splt.push({data:[Less[i]],type:1,max:Less[i].num,len:1}); } Less.length=0; return Splt; } function GetAllPai(Obj){ var ShunArr=new Array(); ShunArr.push(GetAllLast(Obj)); var Suns=GetAllSun(Obj); if(Suns!=null) for(var i=0;i<Suns.length;i++) { var Item=GetAllLast(Suns[i]); ShunArr.push(Item); } return ShunArr; }

筛选函数=========

function GetTaMax(Arr){ var MkObj=null; var Len=Arr.length; for(var i=0;i<Len;i++) { var Tp=Arr[i]; var Clen=Tp.length; var Dlen=0; for(var k=0;k<Clen;k++) { //Pn 取值 正常单牌的权值是 4 if(Tp[k].type==1){ // 如果是2以上 我们认为 这个单牌有能力自己出掉-- 还可以带一张牌 if(Tp[k].max>=15) { Dlen-=4; } //自己可以出掉--- else if(Tp[k].max>=11){} else if(Tp[k].max>=7) { Dlen+=4; } //小过 7 的牌 我们认为应该要带出去才行 else { Dlen+=8; } } if(Tp[k].type==2){ // 如果是对2以上 我们认为 这个单牌至少可以发一张单牌-- if(Tp[k].max>=15) { Dlen-=8; } //如果这个对牌 是公仔牌和A 我们认为 这个牌还不是很烂 else if(Tp[k].max>=11) { Dlen-=2; } else if(Tp[k].max>=7) { Dlen+=2; } //小过 7 的牌 我们认为应该要带出去才行 else { Dlen+=6; } } if(Tp[k].type==3){ // 如果是对2以上 我们认为 这个单牌至少可以发一张单牌-- if(Tp[k].max>=15) { Dlen-=12; } if(Tp[k].max>=11) { Dlen-=9; } else if(Tp[k].max>=7) { Dlen-=6; } else { Dlen-=4; } } if(Tp[k].type==10){ Dlen-=5; if(Tp[k].len>=15)Dlen-=10; if(Tp[k].len=12)Dlen-=9; if(Tp[k].len=9)Dlen-=7; if(Tp[k].len=6)Dlen-=4; } if(Tp[k].type==9){Dlen-=1;} if(Tp[k].type==8){Dlen-=1;} if(Tp[k].type==13){Dlen-=20;} if(Tp[k].type==14){Dlen-=20;} } Tp.Pn=(Clen*10)+Dlen; if(MkObj==null||Tp.Pn<MkObj.Pn)MkObj=Tp; } MkObj.Pn=MkObj.Pn<0?0:MkObj.Pn; SetTlInfo(MkObj); return MkObj; }

SetTlIofo 是为该筛选路径添加而外的属性信息 这里先不介绍---

筛选的Pn值对整个AI起着很关键的作用 在这里可以用来选出一副好牌，而在后期 他还可以用来判断是否压别人 或者是否拆牌来打

是否该出大牌了 或者依靠这个值 能大概知道自己能不能打完这手牌

比如基本上Pn值在<=10的时候 估计这个牌已经很好了 甚至可以打完

或者 如果拆牌后 再对拆牌后剩下的牌进行一次赞牌 发现拆牌后的Pn 大过 没有拆的Pn 证明此次拆牌是有损失的

可以依靠损失度 适当出牌！！

调整 这个函数的一些 调水值 用合理的思路去分析调整 可以更接近真人判断~~

 

今天 先介绍这么多~ 以后接着介绍 主动出牌 与被动出牌~

附带一个 赞牌后的输出--

 

Array
   (
      [0]=>Object Object
      (
         [data]=>Array
         (
            [0]=>Object Object
            (
               [num]=>15
               [txt]=>2
               [key]=>1
               [name]=>草花2
            )
            [1]=>Object Object
            (
               [num]=>15
               [txt]=>2
               [key]=>1
               [name]=>草花2
            )
            [2]=>Object Object
            (
               [num]=>15
               [txt]=>2
               [key]=>1
               [name]=>草花2
            )
         )
         [type]=>3
         [max]=>15
         [len]=>3
      )
      [1]=>Object Object
      (
         [data]=>Array
         (
            [0]=>Object Object
            (
               [num]=>11
               [txt]=>11
               [key]=>1
               [name]=>草花11
            )
            [1]=>Object Object
            (
               [num]=>10
               [txt]=>10
               [key]=>1
               [name]=>草花10
            )
            [2]=>Object Object
            (
               [num]=>9
               [txt]=>9
               [key]=>1
               [name]=>草花9
            )
            [3]=>Object Object
            (
               [num]=>8
               [txt]=>8
               [key]=>1
               [name]=>草花8
            )
            [4]=>Object Object
            (
               [num]=>7
               [txt]=>7
               [key]=>1
               [name]=>草花7
            )
         )
         [type]=>8
         [max]=>11
         [len]=>5
      )
      [2]=>Object Object
      (
         [data]=>Array
         (
            [0]=>Object Object
            (
               [num]=>6
               [txt]=>6
               [key]=>1
               [name]=>草花6
            )
            [1]=>Object Object
            (
               [num]=>6
               [txt]=>6
               [key]=>1
               [name]=>草花6
            )
            [2]=>Object Object
            (
               [num]=>5
               [txt]=>5
               [key]=>1
               [name]=>草花5
            )
            [3]=>Object Object
            (
               [num]=>5
               [txt]=>5
               [key]=>1
               [name]=>草花5
            )
            [4]=>Object Object
            (
               [num]=>4
               [txt]=>4
               [key]=>1
               [name]=>草花4
            )
            [5]=>Object Object
            (
               [num]=>4
               [txt]=>4
               [key]=>1
               [name]=>草花4
            )
            [6]=>Object Object
            (
               [num]=>3
               [txt]=>3
               [key]=>1
               [name]=>草花3
            )
            [7]=>Object Object
            (
               [num]=>3
               [txt]=>3
               [key]=>1
               [name]=>草花3
            )
         )
         [type]=>9
         [max]=>6
         [len]=>8
      )
      [3]=>Object Object
      (
         [data]=>Array
         (
            [0]=>Object Object
            (
               [num]=>14
               [txt]=>1
               [key]=>1
               [name]=>草花1
            )
            [1]=>Object Object
            (
               [num]=>14
               [txt]=>1
               [key]=>1
               [name]=>草花1
            )
            [2]=>Object Object
            (
               [num]=>14
               [txt]=>1
               [key]=>1
               [name]=>草花1
            )
            [3]=>Object Object
            (
               [num]=>13
               [txt]=>13
               [key]=>1
               [name]=>草花13
            )
            [4]=>Object Object
            (
               [num]=>13
               [txt]=>13
               [key]=>1
               [name]=>草花13
            )
            [5]=>Object Object
            (
               [num]=>13
               [txt]=>13
               [key]=>1
               [name]=>草花13
            )
         )
         [type]=>10
         [max]=>14
         [len]=>6
      )
      [4]=>Object Object
      (
         [data]=>Array
         (
            [0]=>Object Object
            (
               [num]=>11
               [txt]=>11
               [key]=>1
               [name]=>草花11
            )
         )
         [type]=>1
         [max]=>11
         [len]=>1
      )
      [Pn]=>2
      [Step]=>5
      [nDan]=>1
      [xDan]=>1
      [nDui]=>0
      [xDui]=>0
      [dDui]=>0
      [nSan]=>1
      [nZha]=>0
      [nSun1]=>1
      [nSun2]=>1
      [nSun3]=>1
      [nHuo]=>0
      [wDan]=>-2
      [nTow]=>3
   )